having example

$query->andWhere($query->expr()->notIn('`tag`.`id`', sprintf('(%s)', $subQuery->getSQL())));
        }
    }

    private function addDuplicateFilter(QueryBuilder $query): void
    {
        $subQuery = (new QueryBuilder($this->connection))
            ->select(['name'])
            ->from('tag')
            ->groupBy('name')
            ->having('COUNT(`name`) > 1');

        $query->innerJoin(
            '`tag`',
            sprintf('(%s)', $subQuery->getSQL()),
            'duplicate',
            'duplicate.`name` = `tag`.`name`'
        );
    }

    private function addAssignmentFilter(QueryBuilder $query, array $assignments): void
    {
        

/** * {@inheritdoc} */
  public function havingArguments() {
    return $this->query->havingArguments();
  }

  /** * {@inheritdoc} */
  public function having($snippet, $args = []) {
    $this->query->having($snippet, $args);
    return $this;
  }

  /** * {@inheritdoc} */
  public function havingCompile(Connection $connection) {
    return $this->query->havingCompile($connection);
  }

  /** * {@inheritdoc} */

$condition['field']->compile($sql_condition);
        $sql_query->condition($sql_condition);
      }
      else {
        $type = ((strtoupper($this->conjunction) == 'OR') || ($condition['operator'] == 'IS NULL')) ? 'LEFT' : 'INNER';
        $field = $tables->addField($condition['field'], $type, $condition['langcode']);
        $condition_class = QueryBase::getClass($this->namespaces, 'Condition');
        $condition_class::translateCondition($condition, $sql_query, $tables->isFieldCaseSensitive($condition['field']));
        $function = $condition['function'];
        $placeholder = ':db_placeholder_' . $conditionContainer->nextPlaceholder();
        $sql_field_escaped = '[' . str_replace('.', '].[', $field) . ']';
        $conditionContainer->having("$function($sql_field_escaped) {$condition['operator']} $placeholder", [$placeholder => $condition['value']]);
      }
    }
  }

  /** * {@inheritdoc} */
  public function exists($field, $function, $langcode = NULL) {
    return $this->condition($field, $function, NULL, 'IS NOT NULL', $langcode);
  }

  

        $builder->execute();
    }

    private function cleanupContentTypeEntries(): void
    {
        $ids = $this->em->getConnection()->createQueryBuilder()->from('s_core_menu', 'menu')
            ->select('id')
            ->andWhere('content_type IS NOT NULL')
            ->groupBy('content_type')
            ->having('COUNT(content_type) > 1')
            ->execute()
            ->fetchAll(PDO::FETCH_COLUMN);

        if (empty($ids)) {
            return;
        }

        $builder = $this->em->getConnection()->createQueryBuilder();
        $builder->delete('s_core_menu');
        $builder->andWhere('id IN (:ids)');
        $builder->setParameter('ids', $ids, Connection::PARAM_INT_ARRAY);
        

    $this->join('search_total', 't', '[i].[word] = [t].[word]');
    $this
      ->condition('i.type', $this->type)
      ->groupBy('i.type')
      ->groupBy('i.sid');

    // If the query is simple, we should have calculated the number of     // matching words we need to find, so impose that criterion. For non-     // simple queries, this condition could lead to incorrectly deciding not     // to continue with the full query.     if ($this->simple) {
      $this->having('COUNT(*) >= :matches', [':matches' => $this->matches]);
    }

    // Clone the query object to calculate normalization.     $normalize_query = clone $this->query;

    // For complex search queries, add the LIKE conditions; if the query is     // simple, we do not need them for normalization.     if (!$this->simple) {
      $normalize_query->join('search_dataset', 'd', '[i].[sid] = [d].[sid] AND [i].[type] = [d].[type] AND [i].[langcode] = [d].[langcode]');
      if (count($this->conditions)) {
        $normalize_query->condition($this->conditions);
      }

        $query = $this->connection->createQueryBuilder();
        $query->setParameter(':customerGroup', $customerGroup->getKey());

        $query->select('(' . $subQuery->getSQL() . ') as priceId')
            ->from('s_articles_prices', 'outerPrices')
            ->where('outerPrices.articleID IN (:products)')
            ->setParameter(':products', $ids, Connection::PARAM_INT_ARRAY)
            ->setParameter(':priceGroupCustomerGroup', $customerGroup->getId())
            ->groupBy('outerPrices.articleID')
            ->having('priceId IS NOT NULL');

        return $query->execute()->fetchAll(PDO::FETCH_COLUMN);
    }
}

->select('COUNT(c2.id)')
            ->where('c2.parentId = c.id')
            ->andWhere('c2.blog = 1');

        $builder = $this->createQueryBuilder('c');
        $builder->select([
            'c.id as id',
            'c.name as name',
            'c.position as position',
            'c.blog as blog',
        ]);
        $builder->having('childrenCount > 0 OR blog = 1');
        $builder->addSelect('(' . $subQuery->getDQL() . ') as childrenCount');

        return $builder;
    }

    /** * Helper function to select all path elements for the passed category. * * @param Category|null $category * @param string|array<string> $field * @param string|null $separator * * @return array|null */

  /** * Tests GROUP BY and HAVING clauses together. */
  public function testGroupByAndHaving() {
    $query = $this->connection->select('test_task', 't');
    $count_field = $query->addExpression('COUNT([task])', 'num');
    $task_field = $query->addField('t', 'task');
    $query->orderBy($count_field);
    $query->groupBy($task_field);
    $query->having('COUNT([task]) >= 2');
    $result = $query->execute();

    $num_records = 0;
    $last_count = 0;
    $records = [];
    // Verify that the results are returned in the correct order.     foreach ($result as $record) {
      $num_records++;
      $this->assertGreaterThanOrEqual(2, $record->$count_field);
      $this->assertGreaterThanOrEqual($last_count, $record->$count_field);
      $last_count = $record->$count_field;
      

        $query = $this->connection->createQueryBuilder();
        $query->setParameter(':customerGroup', $customerGroup->getKey());

        $query->select('(' . $subQuery->getSQL() . ') as priceId')
            ->from('s_articles_prices', 'outerPrices')
            ->where('outerPrices.articleID IN (:products)')
            ->setParameter(':products', $ids, Connection::PARAM_INT_ARRAY)
            ->setParameter(':priceGroupCustomerGroup', $customerGroup->getId())
            ->groupBy('outerPrices.articleID')
            ->having('priceId IS NOT NULL');

        return $query->execute()->fetchAll(PDO::FETCH_COLUMN);
    }
}

// Search forms         if (isset($filter[0]['property']) && $filter[0]['property'] === 'search') {
            $builder->where('form.name LIKE :search')
                ->orWhere('form.label LIKE :search')
                ->orWhere('translation.label LIKE :search')
                ->orWhere('translationFallback.label LIKE :search')
                ->orWhere('element.name LIKE :search')
                ->orWhere('element.label LIKE :search')
                ->orWhere('elementTranslation.label LIKE :search')
                ->setParameter('search', $filter[0]['value']);
            $builder->having('childrenCount = 0')
                ->andWhere('form.parentId IS NOT NULL');
        } elseif (!$node) { // Main forms             $builder->where('form.parentId IS NULL');
            $builder->having('childrenCount > 0');
        } else { // Child forms             $builder->where('form.parentId = :id')
                ->setParameter('id', $node);
        }

        $data = $builder->getQuery()->getArrayResult();

        

  public function testHavingPagerQuery() {
    $query = Database::getConnection()->select('test', 't')
      ->extend(PagerSelectExtender::class);
    $query
      ->fields('t', ['name'])
      ->orderBy('name')
      ->groupBy('name')
      ->having('MAX([age]) > :count', [':count' => 26])
      ->limit(5);

    $ages = $query
      ->execute()
      ->fetchCol();
    $this->assertEquals(['George', 'Ringo'], $ages, 'Pager query with having expression returned the correct ages.');
  }

  /** * Confirms that every pager gets a valid, non-overlapping element ID. */