Returns new or existing Query builder class for this table.
@return ObjectBuilder
481026
public function getQueryBuilder()
    {
        if (!isset($this->queryBuilder)) {
            $this->queryBuilder = $this->getGeneratorConfig()->getConfiguredBuilder($this->getTable(), 'query');
        }

        return $this->queryBuilder;
    }
258287
protected function getQueryBuilderForDemand(): QueryBuilder
    {
        $queryBuilder = $this->getQueryBuilder();
        $queryBuilder
            ->select('*')
            ->from('sys_redirect')
            ->orderBy('source_host')
            ->addOrderBy('source_path');

        $constraints = [];
        if ($this->demand->hasSourceHost()) {
            $constraints[] =$queryBuilder->expr()->eq(
                'source_host',
                $queryBuilder->createNamedParameter($this->demand->getSourceHost(), \PDO::PARAM_STR)
            );
        }

        if ($this->demand->hasSourcePath()) {
            $escapedLikeString = '%' . $queryBuilder->escapeLikeWildcards($this->demand->getSourcePath()) . '%';
            $constraints[] = $queryBuilder->expr()->like(
                'source_path',
                $queryBuilder->createNamedParameter($escapedLikeString, \PDO::PARAM_STR)
            );
        }

        if ($this->demand->hasTarget()) {
            $escapedLikeString = '%' . $queryBuilder->escapeLikeWildcards($this->demand->getTarget()) . '%';
            $constraints[] = $queryBuilder->expr()->like(
                'target',
                $queryBuilder->createNamedParameter($escapedLikeString, \PDO::PARAM_STR)
            );
        }

        if ($this->demand->hasStatusCode()) {
            $constraints[] =$queryBuilder->expr()->eq(
                'target_statuscode',
                $queryBuilder->createNamedParameter($this->demand->getStatusCode(), \PDO::PARAM_INT)
            );
        }

        if (!empty($constraints)) {
            $queryBuilder->where(...$constraints);
        }
        return $queryBuilder;
    }
771189
public function isSourceQueryBuilder()
    {
        return is_object($this->getSource()) && get_class($this->getSource()) == \Illuminate\Database\Query\Builder::class;
    }
750799
protected function getBaseQueryBuilder($instance = null)
    {
        if (! $instance) {
            $instance = $this->query;
        }

        if ($instance instanceof EloquentBuilder) {
            return $instance->getQuery();
        }

        return $instance;
    }
1232140
public function query() : Builder
	{
		if (trim($conditions = $this->conditions) !== '') {
			$this->builder->where('condition', 'LIKE', $conditions);
		}

		return $this->builder;
	}
36443
public function build()
    {
        return new QueryConfiguration(
            $this->drawCall,
            $this->start,
            $this->length,
            $this->searchValue,
            $this->searchRegex,
            $this->columSearches,
            $this->columnOrders
        );
    }
30740
private function getLoadTypeQueryBuilder(): QueryBuilder
    {
        $q = $this->connection->createQueryBuilder();
        $expr = $q->expr();
        $q
            ->select([
                'c.id AS ezcontentclass_id',
                'c.version AS ezcontentclass_version',
                'c.serialized_name_list AS ezcontentclass_serialized_name_list',
                'c.serialized_description_list AS ezcontentclass_serialized_description_list',
                'c.identifier AS ezcontentclass_identifier',
                'c.created AS ezcontentclass_created',
                'c.modified AS ezcontentclass_modified',
                'c.modifier_id AS ezcontentclass_modifier_id',
                'c.creator_id AS ezcontentclass_creator_id',
                'c.remote_id AS ezcontentclass_remote_id',
                'c.url_alias_name AS ezcontentclass_url_alias_name',
                'c.contentobject_name AS ezcontentclass_contentobject_name',
                'c.is_container AS ezcontentclass_is_container',
                'c.initial_language_id AS ezcontentclass_initial_language_id',
                'c.always_available AS ezcontentclass_always_available',
                'c.sort_field AS ezcontentclass_sort_field',
                'c.sort_order AS ezcontentclass_sort_order',
                'c.language_mask AS ezcontentclass_language_mask',

                'a.id AS ezcontentclass_attribute_id',
                'a.serialized_name_list AS ezcontentclass_attribute_serialized_name_list',
                'a.serialized_description_list AS ezcontentclass_attribute_serialized_description_list',
                'a.identifier AS ezcontentclass_attribute_identifier',
                'a.category AS ezcontentclass_attribute_category',
                'a.data_type_string AS ezcontentclass_attribute_data_type_string',
                'a.can_translate AS ezcontentclass_attribute_can_translate',
                'a.is_required AS ezcontentclass_attribute_is_required',
                'a.is_information_collector AS ezcontentclass_attribute_is_information_collector',
                'a.is_searchable AS ezcontentclass_attribute_is_searchable',
                'a.placement AS ezcontentclass_attribute_placement',
                'a.data_float1 AS ezcontentclass_attribute_data_float1',
                'a.data_float2 AS ezcontentclass_attribute_data_float2',
                'a.data_float3 AS ezcontentclass_attribute_data_float3',
                'a.data_float4 AS ezcontentclass_attribute_data_float4',
                'a.data_int1 AS ezcontentclass_attribute_data_int1',
                'a.data_int2 AS ezcontentclass_attribute_data_int2',
                'a.data_int3 AS ezcontentclass_attribute_data_int3',
                'a.data_int4 AS ezcontentclass_attribute_data_int4',
                'a.data_text1 AS ezcontentclass_attribute_data_text1',
                'a.data_text2 AS ezcontentclass_attribute_data_text2',
                'a.data_text3 AS ezcontentclass_attribute_data_text3',
                'a.data_text4 AS ezcontentclass_attribute_data_text4',
                'a.data_text5 AS ezcontentclass_attribute_data_text5',
                'a.serialized_data_text AS ezcontentclass_attribute_serialized_data_text',

                'g.group_id AS ezcontentclass_classgroup_group_id',

                'ml.name AS ezcontentclass_attribute_multilingual_name',
                'ml.description AS ezcontentclass_attribute_multilingual_description',
                'ml.language_id AS ezcontentclass_attribute_multilingual_language_id',
                'ml.data_text AS ezcontentclass_attribute_multilingual_data_text',
                'ml.data_json AS ezcontentclass_attribute_multilingual_data_json',
            ])
            ->from('ezcontentclass', 'c')
            ->leftJoin(
                'c',
                'ezcontentclass_attribute',
                'a',
                $expr->andX(
                    $expr->eq('c.id', 'a.contentclass_id'),
                    $expr->eq('c.version', 'a.version')
                )
            )
            ->leftJoin(
                'c',
                'ezcontentclass_classgroup',
                'g',
                $expr->andX(
                    $expr->eq('c.id', 'g.contentclass_id'),
                    $expr->eq('c.version', 'g.contentclass_version')
                )
            )
            ->leftJoin(
                'a',
                'ezcontentclass_attribute_ml',
                'ml',
                $expr->andX(
                    $expr->eq('a.id', 'ml.contentclass_attribute_id'),
                    $expr->eq('a.version', 'ml.version')
                )
            )
            ->orderBy('a.placement');

        return $q;
    }
559534
public static function createQueryBuilder($queryBuilder)
    {
        if ($queryBuilder instanceof ORMBuilder) {
            return new ORMQueryBuilder($queryBuilder);
        }
        if ($queryBuilder instanceof DBALBuilder) {
            return new DBALQueryBuilder($queryBuilder);
        }

        throw new QueryBuilderException(
            sprintf('Invalid parameter "queryBuilder". Use %s or %s', ORMBuilder::class, DBALBuilder::class)
        );
    }
219677
public function newEloquentBuilder($query)
    {
        $builder = new TaxonomyBuilder($query);

        return isset($this->taxonomy) && $this->taxonomy ? $builder->where('taxonomy', $this->taxonomy) : $builder;
    }
86109
public function build()
    {
        $query = $this->qb;
        if ($this->getWhereExpression()) {
            $query->where($this->getWhereExpression());
        }
        foreach ($this->getWhereParameters() as $key => $param) {
            $query->setParameter($key, $param, is_array($param) ? Connection::PARAM_STR_ARRAY : null);
        }

        return $query;
    }
1224044
private function slaveQueryBuilder()
    {
        /** @var Connection $connection */
        $connection = $this->getEntityManager()->getConnection();
        if ($connection instanceof MasterSlaveConnection) {
            // Prefer a slave connection if available.
            $connection->connect('slave');
        }

        return new QueryBuilder($connection);
    }
819265
protected function newBaseQueryBuilder()
    {
        $conn = $this->getConnection();

        $grammar = $conn->getQueryGrammar();

        return new MbDatabaseQueryBuilder($conn, $grammar, $conn->getPostProcessor());
    }
301876
public function getQueryBuilder()
    {
        /** @var $queryBuilder QueryBuilder */
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('tx_gridelements_backend_layout');
        $queryBuilder->getRestrictions()
            ->removeAll()
            ->add(GeneralUtility::makeInstance(DeletedRestriction::class))
            ->add(GeneralUtility::makeInstance(HiddenRestriction::class));
        return $queryBuilder;
    }
114717
public function getObjectBuilder()
    {
        if (!isset($this->objectBuilder)) {
            $this->objectBuilder = $this->getGeneratorConfig()->getConfiguredBuilder($this->getTable(), 'object');
        }

        return $this->objectBuilder;
    }
570851
private function getItemSelectQuery(): QueryBuilder
    {
        $query = $this->connection->createQueryBuilder();
        $query->select('DISTINCT ngbm_collection_item.*')
            ->from('ngbm_collection_item');

        return $query;
    }
462797
public function buildQueryBuilder()
    {
        $builder = new QueryBuilder();

        foreach ($this->parsers as $parser) {
            if ($parser->wasApplied()) {
                $parser->apply($builder);
            }
        }

        foreach ($this->sorts as $sort) {
            $builder->orderBy($sort[0], $sort[1]);
        }

        if (!empty($this->perPage)) {
            $builder->setPageSize($this->perPage);
        }

        if (!empty($this->page)) {
            $builder->setPage($this->page);
        }

        if (!empty($this->searchQuery)) {
            $builder->setSearchQuery($this->searchQuery);
        }

        return $builder;
    }
1319295
protected function newBaseQueryBuilder()
    {
        $conn = $this->getConnection();

        $grammar = $conn->getQueryGrammar;

        return new QueryBuilder($conn, $grammar);
    }