Documentation

Core_QueryBuilder_Select extends Core_QueryBuilder_Selection
in package

HostCMS

Core

Querybuilder

Query builder. SELECT Database Abstraction Layer (DBAL)

http://dev.mysql.com/doc/refman/5.7/en/select.html

Subqueries http://dev.mysql.com/doc/refman/5.7/en/subqueries.html

The Subquery as Scalar Operand http://dev.mysql.com/doc/refman/5.7/en/scalar-subqueries.html // SELECT (SELECT MAX(column2) FROM t2) FROM t1 $oCore_QueryBuilder_Select2 = Core_QueryBuilder::select('MAX(column2)')->from('t2'); $oCore_QueryBuilder_Select = Core_QueryBuilder::select($oCore_QueryBuilder_Select2)->from('t1');

Comparisons Using Subqueries http://dev.mysql.com/doc/refman/5.7/en/comparisons-using-subqueries.html


// SELECT * FROM `t1` WHERE `column1` = (SELECT MAX(`column2`) FROM `t2`)
$oCore_QueryBuilder_Select2 = Core_QueryBuilder::select('MAX(column2)')->from('t2');

$oCore_QueryBuilder_Select = Core_QueryBuilder::select()->from('t1') ->where('column1', '=', $oCore_QueryBuilder_Select2);

$_dataBase

DataBase


    protected
        mixed
    $_dataBase
     = \NULL

$_defaultOperator

Default operator between conditions


    protected
        string
    $_defaultOperator
     = 'AND'

$_distinct

DISTINCT


    protected
        bool
    $_distinct
     = \FALSE

$_from

FROM


    protected
        array<string|int, mixed>
    $_from
     = array()

$_groupBy

GROUP BY


    protected
        array<string|int, mixed>
    $_groupBy
     = array()

$_having

HAVING


    protected
        array<string|int, mixed>
    $_having
     = array()

$_highPriority

HIGH_PRIORITY


    protected
        bool
    $_highPriority
     = \FALSE

$_indexHints

Index Hints


    protected
        array<string|int, mixed>
    $_indexHints
     = array()

$_join

JOIN


    protected
        array<string|int, mixed>
    $_join
     = array()

$_limit

LIMIT


    protected
        mixed
    $_limit
     = \NULL

$_offset

OFFSET


    protected
        mixed
    $_offset
     = \NULL

$_offsetPostgreSQLSyntax

Offset compatibility with PostgreSQL, default TRUE


    protected
        bool
    $_offsetPostgreSQLSyntax
     = \TRUE

$_operator

Current operator


    protected
        string
    $_operator
     = ''

$_orderBy

ORDER BY


    protected
        array<string|int, mixed>
    $_orderBy
     = array()

$_partition

PARTITION


    protected
        array<string|int, mixed>
    $_partition
     = array()

$_queryType

DataBase Query Type 0 - SELECT


    protected
        mixed
    $_queryType
     = 0

$_select

SELECT


    protected
        array<string|int, mixed>
    $_select
     = array()

$_sqlCalcFoundRows

SQL_CALC_FOUND_ROWS


    protected
        bool
    $_sqlCalcFoundRows
     = \FALSE

$_straightJoin

STRAIGHT_JOIN


    protected
        bool
    $_straightJoin
     = \FALSE

$_unbuffered

Query without fetching and buffering the result rows


    protected
        mixed
    $_unbuffered
     = \FALSE

$_union

Array of Core_QueryBuilder_Select's


    protected
        array<string|int, mixed>
    $_union
     = array()

$_unionLimit

UNION LIMIT


    protected
        mixed
    $_unionLimit
     = \NULL

$_unionOffset

UNION OFFSET


    protected
        mixed
    $_unionOffset
     = \NULL

$_unionOrderBy

UNION ORDER BY


    protected
        array<string|int, mixed>
    $_unionOrderBy
     = array()

$_where

WHERE


    protected
        array<string|int, mixed>
    $_where
     = array()

__call()

Triggered when invoking inaccessible methods in an object context


    public
                    __call(string $name, array<string|int, mixed> $arguments) : mixed

Parameters

$name : string: method name
$arguments : array<string|int, mixed>: arguments

Return values

mixed —

__construct()

Constructor.


    public
                    __construct([array<string|int, mixed> $args = array() ]) : mixed


$oCore_QueryBuilder_Select = Core_QueryBuilder::select('id', array('tableName.name', 'aliasName'));

Parameters

$args : array<string|int, mixed> = array(): list of arguments

Return values

mixed —

__set()

Run when writing data to inaccessible properties


    public
                    __set(string $property, string $value) : self

Parameters

$property : string: property name
$value : string: property value

Return values

self —

asAssoc()

Set result type as an array


    public
                    asAssoc() : self

Return values

self —

asObject()

Set result type as an object with className


    public
                    asObject([mixed $className = NULL ]) : self

Parameters

$className : mixed = NULL: Object class name

Return values

self —

build()

Build the SQL query


    public
                    build() : string

Return values

string —

The SQL query

chunk()

Retrieve a small chunk and feeds each one into $callback for processing. It stops looping when $callback returns FALSE


    public
                    chunk(int $count, callable $callback[, bool $bCache = TRUE ]) : bool

Parameters

$count : int: chunk size
$callback : callable
$bCache : bool = TRUE: use cache

Return values

bool —

clear()

Clear


    public
                    clear() : self

Return values

self —

clearFrom()

Clear FROM


    public
                    clearFrom() : self

Return values

self —

clearGroupBy()

Clear GROUP BY list


    public
                    clearGroupBy() : self

Return values

self —

clearHaving()

Clear HAVING list


    public
                    clearHaving() : self

Return values

self —

clearIndexHints()

Clear Index Hints


    public
                    clearIndexHints() : self

Return values

self —

clearJoin()

Clear JOIN


    public
                    clearJoin() : self

Return values

self —

clearLimit()

Clear LIMIT


    public
                    clearLimit() : self

Return values

self —

clearOffset()

Clear OFFSET


    public
                    clearOffset() : self

Return values

self —

clearOrderBy()

Clear ORDER BY


    public
                    clearOrderBy() : self

Return values

self —

clearSelect()

Clear SELECT list


    public
                    clearSelect() : self

Return values

self —

clearWhere()

Clear WHERE list


    public
                    clearWhere() : self

Return values

self —

close()

Close bracket in WHERE


    public
                    close() : self

Return values

self —

columns()

Add columns for select


    public
                    columns() : self


// SELECT `id`, `name`
$Core_QueryBuilder_Select->columns('id', 'name');
// SELECT id, name AS aliasName
$Core_QueryBuilder_Select->columns('id', array('name', 'aliasName'));

// SELECT id, tablename.name AS aliasName $Core_QueryBuilder_Select->columns('id', array('tablename.name', 'aliasName'));

Return values

self —

crossJoin()

In MySQL, CROSS JOIN is a syntactic equivalent to INNER JOIN (they can replace each other).


    public
                    crossJoin(string $table) : self

In standard SQL, they are not equivalent. INNER JOIN is used with an ON clause, CROSS JOIN is used otherwise.


// CROSS JOIN `join1`
$Core_QueryBuilder_Select->crossJoin('join1');

Parameters

$table : string: table name

Return values

self —

deleteFirstHaving()

Delete first HAVING condition


    public
                    deleteFirstHaving() : self

Return values

self —

deleteFirstWhere()

Delete first WHERE condition


    public
                    deleteFirstWhere() : self

Return values

self —

deleteLastHaving()

Delete last HAVING condition


    public
                    deleteLastHaving() : self

Return values

self —

deleteLastWhere()

Delete last WHERE condition


    public
                    deleteLastWhere() : self

Return values

self —

distinct()

Set DISTINCT


    public
                    distinct([bool $distinct = TRUE ]) : self


$oCore_QueryBuilder_Select = Core_QueryBuilder::select()->distinct();

Parameters

$distinct : bool = TRUE: DISTINCT option

Return values

self —

execute()

Execute query


    public
                    execute([ $sql = NULL ]) : Core_DataBase

Parameters

$sql : = NULL: SQL query

Return values

Core_DataBase —

firstJoin()

Add INNER JOIN first


    public
                    firstJoin(string $table, string $column[, string|null $expression = NULL ][, string|null $value = NULL ][, string|null $additionalConditions = NULL ]) : self

Parameters

$table : string: table name
$column : string: column name
$expression : string|null = NULL: expression
$value : string|null = NULL: value
$additionalConditions : string|null = NULL: additional conditions

Return values

self —

firstLeftJoin()

Add LEFT OUTER JOIN first


    public
                    firstLeftJoin(string $table, string $column[, string|null $expression = NULL ][, string|null $value = NULL ][, string|null $additionalConditions = NULL ]) : self

Parameters

$table : string: table name
$column : string: column name
$expression : string|null = NULL: expression
$value : string|null = NULL: value
$additionalConditions : string|null = NULL: additional conditions

Return values

self —

from()

Set FROM


    public
                    from() : self


// FROM `tableName`
$oCore_QueryBuilder_Select = $Core_QueryBuilder_Select->from('tableName');

// FROM tableName AS tableNameAlias $oCore_QueryBuilder_Select = $Core_QueryBuilder_Select->from(array('tableName', 'tableNameAlias'));

Return values

self —

getDataBase()

Get DataBase


    public
                    getDataBase() : Core_DataBase

Return values

Core_DataBase —

getFoundRows()

Get FOUND_ROWS()


    public
                    getFoundRows() : int


$iCount = Core_QueryBuilder::select()->getFoundRows();

Return values

int —

getFrom()

Get FROM


    public
                    getFrom() : array<string|int, mixed>

Return values

array<string|int, mixed> —

getGroupBy()

Get GROUP BY


    public
                    getGroupBy() : array<string|int, mixed>

Return values

array<string|int, mixed> —

getJoin()

Get JOIN


    public
                    getJoin() : array<string|int, mixed>

Return values

array<string|int, mixed> —

getOrderBy()

Get ORDER BY


    public
                    getOrderBy() : array<string|int, mixed>

Return values

array<string|int, mixed> —

getSelect()

Get SELECT


    public
                    getSelect() : array<string|int, mixed>

Return values

array<string|int, mixed> —

getWhere()

Get WHERE


    public
                    getWhere() : array<string|int, mixed>

Return values

array<string|int, mixed> —

group()

GROUP BY


    public
                    group(string $column) : self

Parameters

$column : string: column

Return values

self —

groupBy()

Set GROUP BY


    public
                    groupBy() : self


// GROUP BY `field`, COUNT(`id`)
$Core_QueryBuilder_Select->groupBy('field1')->groupBy('COUNT(id)');

Return values

self —

having()

Add HAVING


    public
                    having(string $column, string $expression, string $value) : self


// HAVING `a1` > '2'
$Core_QueryBuilder_Select->having('a1', '>', '2');
// HAVING a4 IN (17, 19, NULL, 'NULL')
$Core_QueryBuilder_Select->having('a4', 'IN', array(17,19, NULL, 'NULL'));

// HAVING a7 BETWEEN 1 AND 10 $Core_QueryBuilder_Select->having('a7', 'BETWEEN', array(1, 10));

Parameters

$column : string: column
$expression : string: expression
$value : string: value

Return values

self —

havingClose()

Close bracket in HAVING


    public
                    havingClose() : self

Return values

self —

havingOpen()

Open bracket in HAVING


    public
                    havingOpen() : self

Return values

self —

havingRaw()

Add raw expression into HAVING.


    public
                    havingRaw(string $expr) : self

ATTENTION! Danger, you should escape the query yourself!


// HAVING `a1` > 2
$Core_QueryBuilder_Select->havingRaw("`a1` > 2");

Parameters

$expr : string: expression

Return values

self —

highPriority()

Set HIGH_PRIORITY


    public
                    highPriority([bool $value = TRUE ]) : self


$oCore_QueryBuilder_Select = Core_QueryBuilder::select()->highPriority();

Parameters

$value : bool = TRUE

Return values

self —

indexHint()

Add Index Hints https://dev.mysql.com/doc/refman/5.7/en/index-hints.html


    public
                    indexHint(string $tableName, array<string|int, mixed> $options) : self


// USE INDEX (`col1_index`)
$Core_QueryBuilder_Select->indexHint('table1', array('USE INDEX', 'col1_index'));

// USE INDEX FOR JOIN (col1_index, col2_index) $Core_QueryBuilder_Select->indexHint('table1', array('USE INDEX', 'FOR JOIN', array('col1_index', 'col2_index')));

Parameters

$tableName : string: table name
$options : array<string|int, mixed>: [$action, $index_list] or [$action, $for, $index_list]

Return values

self —

isHighPriority()

Check if HIGH_PRIORITY was set


    public
                    isHighPriority() : bool

Return values

bool —

isStraightJoin()

Check if STRAIGHT_JOIN was set


    public
                    isStraightJoin() : bool

Return values

bool —

join()

INNER JOIN


    public
                    join(string $table, string $column[, string|null $expression = NULL ][, string|null $value = NULL ][, string|null $additionalConditions = NULL ]) : self


// INNER JOIN `join1` USING (`join_field`)
$Core_QueryBuilder_Select->join('join1', 'join_field');
// INNER JOIN jointable.join1 ON join_field = join_field2
$Core_QueryBuilder_Select->join('jointable.join1', 'join_field1', '=', 'join_field2');

// INNER JOIN jointable.join1 ON join_field = join_field2 AND A = '123' AND B = 'xyz' $Core_QueryBuilder_Select->join('jointable.join1', 'join_field1', '=', 'join_field2', array( array('AND' => array('A', '=', '123')), array('AND' => array('B', '=', 'xyz')) ));

Parameters

$table : string: table name
$column : string: column name
$expression : string|null = NULL: expression
$value : string|null = NULL: value
$additionalConditions : string|null = NULL: additional conditions

Return values

self —

leftJoin()

LEFT OUTER JOIN


    public
                    leftJoin(string $table, string $column[, string|null $expression = NULL ][, string|null $value = NULL ][, string|null $additionalConditions = NULL ]) : self


// LEFT OUTER JOIN `join1` USING (`join_field2`)
$Core_QueryBuilder_Select->leftJoin('join1', 'join_field2');

// LEFT OUTER JOIN jointable.join1 ON join_field = join_field2 $Core_QueryBuilder_Select->leftJoin('jointable.join1', 'join_field', '=', 'join_field2');

Parameters

$table : string: table name
$column : string: column name
$expression : string|null = NULL: expression
$value : string|null = NULL: value
$additionalConditions : string|null = NULL: additional conditions

Return values

self —

limit()

Set limit and offset


    public
                    limit(int $arg1[, int $arg2 = NULL ]) : self


// LIMIT 10
$Core_QueryBuilder_Select->limit(10);

// LIMIT 10 OFFSET 0 $Core_QueryBuilder_Select->limit(0, 10);

Parameters

$arg1 : int
$arg2 : int = NULL

Return values

self —

naturalJoin()

<code> // NATURAL JOIN `join1` $Core_QueryBuilder_Select->naturalJoin('join1'); </code>


    public
                    naturalJoin(string $table) : self

Parameters

$table : string: table name

Return values

self —

offset()

Set offset


    public
                    offset(int|null $offset) : self


// OFFSET 10
$Core_QueryBuilder_Select->offset(10);

Parameters

$offset : int|null: offset

Return values

self —

offsetPostgreSQLSyntax()

Offset compatibility with PostgreSQL, default TRUE $param boolean $compatible


    public
                    offsetPostgreSQLSyntax(mixed $compatible) : mixed

Parameters

$compatible : mixed

Return values

mixed —

open()

Open bracket in WHERE


    public
                    open() : self

Return values

self —

order()

Order options


    public
                    order(string $column[, string $direction = 'ASC' ][, bool $binary = FALSE ]) : mixed

Parameters

$column : string: column
$direction : string = 'ASC': sorting direction
$binary : bool = FALSE: binary option

Return values

mixed —

orderBy()

Set order column and direction


    public
                    orderBy(string $column[, string $direction = 'ASC' ][, bool $binary = FALSE ]) : self

http://dev.mysql.com/doc/refman/5.7/en/sorting-rows.html


// ORDER BY `field1` ASC
$Core_QueryBuilder_Select->orderBy('field1');
// ORDER BY field1 DESC
$Core_QueryBuilder_Select->orderBy('field1', 'DESC');
// ORDER BY BINARY field1 DESC
$Core_QueryBuilder_Select->orderBy('field1', 'DESC', TRUE);

// ORDER BY field2 RAND() $Core_QueryBuilder_Select->orderBy('field1', 'RAND()');

Parameters

$column : string: column
$direction : string = 'ASC': sorting direction
$binary : bool = FALSE: binary option

Return values

self —

orderByRaw()

Add raw expression into ORDER BY.


    public
                    orderByRaw(string $expr) : self

ATTENTION! Danger, you should escape the query yourself!


// ORDER BY `field1` + `field2` ASC
$Core_QueryBuilder_Select->orderByRaw('`field1` + `field2` ASC');

Parameters

$expr : string: expression

Return values

self —

orHaving()

Add OR and HAVING, e.g. HAVING ... OR $column $expression $value


    public
                    orHaving(string $column, string $expression, string $value) : self


// HAVING `a1` > 2 OR `a2` < 7
$Core_QueryBuilder_Select->having('a1', '>', 2)->orHaving('a2', '<', 7);

Parameters

$column : string: column
$expression : string: expression
$value : string: value

Return values

self —

orWhere()

Add OR and WHERE, e.g. WHERE ... OR $column $expression $value


    public
                    orWhere(string $column[, string $expression = NULL ][, string $value = NULL ]) : self


// WHERE `a1` > 2 OR `a2` < 7
$Core_QueryBuilder_Select->where('a1', '>', 2)->orWhere('a2', '<', 7);

Parameters

$column : string: column
$expression : string = NULL: expression
$value : string = NULL: value

Return values

self —

orWhereBetween()

Add OR and WHERE $column BETWEEN x AND y


    public
                    orWhereBetween(string $column, string $from, string $to) : self


// WHERE ... OR `a7` BETWEEN 1 AND 10
$Core_QueryBuilder_Select->orWhereBetween('a7', 1, 10);

Parameters

$column : string: column
$from : string
$to : string

Return values

self —

orWhereColumn()

Set OR and verify two columns


    public
                    orWhereColumn(string $column1, string $expression, string $column2) : self


// WHERE ... OR `a1` = `a2`
$Core_QueryBuilder_Select->orWhereColumn('a1', '=', 'a2');

Parameters

$column1 : string: first column
$expression : string: expression
$column2 : string: second column

Return values

self —

orWhereIn()

Add OR and WHERE $column IN (x, y)


    public
                    orWhereIn(string $column, string $value) : self


// WHERE ... OR `a7` IN (1, 2, 'aaa')
$Core_QueryBuilder_Select->orWhereIn('a7', array(1, 2, 'aaa'));

Parameters

$column : string: column
$value : string: value

Return values

self —

orWhereIsNotNull()

Add OR and WHERE $column IS NOT NULL


    public
                    orWhereIsNotNull(string $column) : self


// WHERE `a1` IS NOT NULL
$Core_QueryBuilder_Select->orWhereIsNotNull('a1');

Parameters

$column : string: column

Return values

self —

orWhereIsNull()

Add OR and WHERE $column IS NULL


    public
                    orWhereIsNull(string $column) : self


// WHERE `a1` IS NULL OR `a2` IS NULL
$Core_QueryBuilder_Select->whereIsNull('a1')->orWhereIsNull('a2');

Parameters

$column : string: column

Return values

self —

orWhereNotBetween()

Add OR and WHERE $column NOT BETWEEN x AND y


    public
                    orWhereNotBetween(string $column, string $from, string $to) : self


// WHERE ... OR `a7` NOT BETWEEN 1 AND 10
$Core_QueryBuilder_Select->orWhereNotBetween('a7', 1, 10);

Parameters

$column : string: column
$from : string
$to : string

Return values

self —

orWhereNotIn()

Add OR and WHERE $column NOT IN (x, y)


    public
                    orWhereNotIn(string $column, string $value) : self


// WHERE ... OR `a7` NOT IN (1, 2, 'aaa')
$Core_QueryBuilder_Select->orWhereNotIn('a7', array(1, 2, 'aaa'));

Parameters

$column : string: column
$value : string: value

Return values

self —

partition()

Set PARTITION


    public
                    partition(mixed $tableName, array<string|int, mixed> $partitions) : Core_QueryBuilder_Select


// FROM|JOIN `tableName` PARTITION (`p0`, `p1`)
$oCore_QueryBuilder_Select = $Core_QueryBuilder_Select->from('tableName')->partition('tableName', array('p0', 'p1'));

Parameters

$tableName : mixed
$partitions : array<string|int, mixed>

Return values

Core_QueryBuilder_Select —

quoteTable()

Quote columns


    public
                    quoteTable(mixed $tableName) : array<string|int, mixed>

Parameters

$tableName : mixed

Return values

array<string|int, mixed> —

rightJoin()

RIGHT OUTER JOIN


    public
                    rightJoin(string $table, string $column[, string $expression = NULL ][, string $value = NULL ][, string $additionalConditions = NULL ]) : self


// RIGHT OUTER JOIN `join1` USING (`join_field2`)
$Core_QueryBuilder_Select->rightJoin('join1', 'join_field2');

// RIGHT OUTER JOIN jointable.join1 ON join_field = join_field2 $Core_QueryBuilder_Select->rightJoin('jointable.join1', 'join_field', '=', 'join_field2');

Parameters

$table : string: table name
$column : string: column name
$expression : string = NULL: expression
$value : string = NULL: value
$additionalConditions : string = NULL: additional conditions

Return values

self —

rightJoinFirst()

Add RIGHT OUTER JOIN first


    public
                    rightJoinFirst(string $table, string $column[, string $expression = NULL ][, string $value = NULL ][, string $additionalConditions = NULL ]) : self

Parameters

$table : string: table name
$column : string: column name
$expression : string = NULL: expression
$value : string = NULL: value
$additionalConditions : string = NULL: additional conditions

Return values

self —

select()

Alias for columns()


    public
                    select() : mixed

Return values

mixed —

selectDistinct()

Set DISTINCT and add columns for select


    public
                    selectDistinct() : self

Return values

self —

setAnd()

Set operator as AND


    public
                    setAnd() : self

Return values

self —

setDataBase()

Set DataBase


    public
                    setDataBase(Core_DataBase $dataBase) : Core_QueryBuilder_Statement

Parameters

$dataBase : Core_DataBase

Return values

Core_QueryBuilder_Statement —

setDefaultOperator()

Set operator as a default operator


    public
                    setDefaultOperator() : self

Return values

self —

setOperator()

Set operator as a default operator


    public
                    setOperator(string $operator) : self

Parameters

$operator : string

Return values

self —

setOr()

Set operator as OR


    public
                    setOr() : self

Return values

self —

sqlCalcFoundRows()

Set SQL_CALC_FOUND_ROWS


    public
                    sqlCalcFoundRows([bool $value = TRUE ]) : self


$oCore_QueryBuilder_Select = Core_QueryBuilder::select()->sqlCalcFoundRows();

Parameters

$value : bool = TRUE

Return values

self —

straightJoin()

Set STRAIGHT_JOIN


    public
                    straightJoin([bool $value = TRUE ]) : self


$oCore_QueryBuilder_Select = Core_QueryBuilder::select()->straightJoin();

Parameters

$value : bool = TRUE

Return values

self —

unbuffered()

Query without fetching and buffering the result rows


    public
                    unbuffered(bool $unbuffered) : self

Parameters

$unbuffered : bool

Return values

self —

union()

UNION is used to combine the result from multiple SELECT statements into a single result set.


    public
                    union(Core_QueryBuilder_Select $object) : self


// (SELECT `id2`, `name2` FROM `tablename2`)
// UNION
// (SELECT `id`, `name` FROM `tablename` LIMIT 10 OFFSET 0)
$select1 = Core_QueryBuilder::select('id', 'name')->from('tablename')
	->limit(0, 10);

$select2 = Core_QueryBuilder::select('id2', 'name2')->from('tablename2') ->union($select1);

Parameters

$object : Core_QueryBuilder_Select

Return values

self —

unionAll()

UNION ALL is used to combine the result from multiple SELECT statements into a single result set.


    public
                    unionAll(Core_QueryBuilder_Select $object) : self


// (SELECT `id2`, `name2` FROM `tablename2`)
// UNION ALL
// (SELECT `id`, `name` FROM `tablename` LIMIT 10 OFFSET 0)
$select1 = Core_QueryBuilder::select('id', 'name')->from('tablename')
	->limit(0, 10);

$select2 = Core_QueryBuilder::select('id2', 'name2')->from('tablename2') ->unionAll($select1);

Parameters

$object : Core_QueryBuilder_Select

Return values

self —

unionLimit()

LIMIT for UNION


    public
                    unionLimit(string $arg1[, string $arg2 = NULL ]) : mixed

Parameters

$arg1 : string: offset
$arg2 : string = NULL: count

Return values

mixed —

unionOffset()

Set UNION offset


    public
                    unionOffset(int $offset) : selfion

Parameters

$offset : int: offset

Return values

selfion —

unionOrderBy()

ORDER BY for UNION


    public
                    unionOrderBy(string $column[, string $direction = 'ASC' ][, bool $binary = FALSE ]) : mixed

http://dev.mysql.com/doc/refman/5.7/en/union.html

Parameters

$column : string: column
$direction : string = 'ASC': sorting direction
$binary : bool = FALSE: binary option

Return values

mixed —

where()

Add WHERE


    public
                    where(string $column[, string $expression = NULL ][, string $value = NULL ]) : self


// WHERE `a1` > '2'
$Core_QueryBuilder_Select->where('a1', '>', '2');
// WHERE a4 IN (17, 19, NULL, 'NULL')
$Core_QueryBuilder_Select->where('a4', 'IN', array(17, 19, NULL, 'NULL'));

// WHERE a7 BETWEEN 1 AND 10 $Core_QueryBuilder_Select->where('a7', 'BETWEEN', array(1, 10));

Parameters

$column : string: column
$expression : string = NULL: expression
$value : string = NULL: value

Return values

self —

whereBetween()

Add WHERE $column BETWEEN x AND y


    public
                    whereBetween(string $column, string $from, string $to) : self


// WHERE `a7` BETWEEN 1 AND 10
$Core_QueryBuilder_Select->whereBetween('a7', 1, 10);

Parameters

$column : string: column
$from : string
$to : string

Return values

self —

whereColumn()

Verify two columns


    public
                    whereColumn(string $column1, string $expression, string $column2) : self


// WHERE `a1` = `a2`
$Core_QueryBuilder_Select->whereColumn('a1', '=', 'a2');

Parameters

$column1 : string: first column
$expression : string: expression
$column2 : string: second column

Return values

self —

whereIn()

Add WHERE $column IN (x, y)


    public
                    whereIn(string $column, string $value) : self


// WHERE `a7` IN (1, 2, 'aaa')
$Core_QueryBuilder_Select->whereIn('a7', array(1, 2, 'aaa'));

Parameters

$column : string: column
$value : string: value

Return values

self —

whereIsNotNull()

Add WHERE $column IS NOT NULL


    public
                    whereIsNotNull(string $column) : self


// WHERE `a2` IS NOT NULL
$Core_QueryBuilder_Select->whereIsNotNull('a2');

Parameters

$column : string: column

Return values

self —

whereIsNull()

Add WHERE $column IS NULL


    public
                    whereIsNull(string $column) : self


// WHERE `a1` IS NULL
$Core_QueryBuilder_Select->whereIsNull('a1');

Parameters

$column : string: column

Return values

self —

whereNotBetween()

Add WHERE $column NOT BETWEEN x AND y


    public
                    whereNotBetween(string $column, string $from, string $to) : self


// WHERE `a7` NOT BETWEEN 1 AND 10
$Core_QueryBuilder_Select->whereNotBetween('a7', 1, 10);

Parameters

$column : string: column
$from : string
$to : string

Return values

self —

whereNotIn()

Add WHERE $column NOT IN (x, y)


    public
                    whereNotIn(string $column, string $value) : self


// WHERE `a7` NOT IN (1, 2, 'aaa')
$Core_QueryBuilder_Select->whereNotIn('a7', array(1, 2, 'aaa'));

Parameters

$column : string: column
$value : string: value

Return values

self —

whereRaw()

Add raw expression into WHERE.


    public
                    whereRaw(string $expr) : self

ATTENTION! Danger, you should escape the query yourself!


// WHERE `a1` > 2
$Core_QueryBuilder_Select->whereRaw("`a1` > 2");

Parameters

$expr : string: expression

Return values

self —

_buildExpression()

Build WHERE or HAVING expression


    protected
                    _buildExpression(array<string|int, mixed> $aConditions) : string

Parameters

$aConditions : array<string|int, mixed>: list of conditions

Return values

string —

The SQL query

_buildIndexHint()

Build INDEX expression


    protected
                    _buildIndexHint(array<string|int, mixed> $aTableIndexHints) : string

Parameters

$aTableIndexHints : array<string|int, mixed>

Return values

string —

The SQL query

_buildJoin()

Build JOIN expression


    protected
                    _buildJoin(array<string|int, mixed> $aJoins) : string

Parameters

$aJoins : array<string|int, mixed>

Return values

string —

The SQL query

_buildOrderBy()

Build ORDER BY expression


    protected
                    _buildOrderBy(array<string|int, mixed> $aOrderBy) : string

Parameters

$aOrderBy : array<string|int, mixed>

Return values

string —

The SQL query

_buildWhere()

Build expression for one condition


    protected
                    _buildWhere(string $column, string $expression, string $value) : string

Parameters

$column : string: column
$expression : string: expression
$value : string: value

Return values

string —

The SQL query

_isObjectSelect()

Is $object Core_QueryBuilder_Select


    protected
                    _isObjectSelect( $object) : bool

Parameters

$object :

Return values

bool —

_join()

http://dev.mysql.com/doc/refman/5.7/en/join.html


    protected
                    _join(string $type, string $table[, string|null $column = NULL ][, string|null $expression = NULL ][, string|null $value = NULL ][, string|null $additionalConditions = NULL ][, mixed $mode = NULL ]) : self

Parameters

$type : string: join type
$table : string: table name
$column : string|null = NULL: column name
$expression : string|null = NULL: expression
$value : string|null = NULL: value
$additionalConditions : string|null = NULL: additional conditions
$mode : mixed = NULL

Return values

self —

_quoteColumns()

Quote columns


    protected
                    _quoteColumns(array<string|int, mixed> $array) : array<string|int, mixed>

Parameters

$array : array<string|int, mixed>

Return values

array<string|int, mixed> —

_quoteTables()

Quote columns


    protected
                    _quoteTables(array<string|int, mixed> $array) : array<string|int, mixed>

Parameters

$array : array<string|int, mixed>

Return values

array<string|int, mixed> —

_quoteValues()

Quote arary of values


    protected
                    _quoteValues(array<string|int, mixed> $array) : array<string|int, mixed>

Parameters

$array : array<string|int, mixed>

Return values

array<string|int, mixed> —

Core_QueryBuilder_Select extends Core_QueryBuilder_Selection in package HostCMS Core Querybuilder

Tags

Table of Contents

Properties

$_dataBase

$_defaultOperator

$_distinct

$_from

$_groupBy

$_having

$_highPriority

$_indexHints

$_join

$_limit

$_offset

$_offsetPostgreSQLSyntax

$_operator

$_orderBy

$_partition

$_queryType

$_select

$_sqlCalcFoundRows

$_straightJoin

$_unbuffered

$_union

$_unionLimit

$_unionOffset

$_unionOrderBy

$_where

Methods

__call()

Parameters

Return values

__construct()

Parameters

Tags

Return values

__set()

Parameters

Return values

asAssoc()

Return values

asObject()

Parameters

Return values

build()

Return values

chunk()

Parameters

Return values

clear()

Return values

clearFrom()

Return values

clearGroupBy()

Return values

clearHaving()

Return values

clearIndexHints()

Return values

clearJoin()

Return values

clearLimit()

Return values

clearOffset()

Return values

clearOrderBy()

Return values

clearSelect()

Return values

clearWhere()

Return values

close()

Return values

columns()

Return values

crossJoin()

Parameters

Return values

deleteFirstHaving()

Core_QueryBuilder_Select extends Core_QueryBuilder_Selection
in package

HostCMS

Core

Querybuilder