__callsource public

__call( string $method , array $args )

Helps calling the and() and or() methods transparently.

Parameters

string $method

The method name.

array $args

The arguments to pass to the method.

Returns

Cake\Database\Expression\QueryExpression
\Cake\Database\Expression\QueryExpression

Throws

BadMethodCallException
\BadMethodCallException

__clonesource public

__clone( )

Clone this object and its subtree of expressions.

__constructsource public

__construct( string|array|Cake\Database\Expression\QueryExpression $conditions [] , array|Cake\Database\TypeMap $types [] , string $conjunction 'AND' )

Constructor. A new expression object can be created without any params and be built dynamically. Otherwise it is possible to pass an array of conditions containing either a tree-like array structure to be parsed and/or other expression objects. Optionally, you can set the conjunction keyword to be used for joining each part of this level of the expression tree.

Parameters

string|array|Cake\Database\Expression\QueryExpression $conditions optional []

tree-like array structure containing all the conditions to be added or nested inside this expression object.

array|Cake\Database\TypeMap $types optional []

associative array of types to be associated with the values passed in $conditions.

string $conjunction optional 'AND'

the glue that will join all the string conditions at this level of the expression tree. For example "AND", "OR", "XOR"...

See

QueryExpression::add() for more details on $conditions and $types

_addConditionssource protected

_addConditions( array $conditions , array $types )

Auxiliary function used for decomposing a nested array of conditions and build a tree structure inside this object to represent the full SQL expression. String conditions are stored directly in the conditions, while any other representation is wrapped around an adequate instance or of this class.

Parameters

array $conditions

list of conditions to be stored in this object

array $types

list of types associated on fields referenced in $conditions

_parseConditionsource protected

_parseCondition( string $field , mixed $value )

Parses a string conditions by trying to extract the operator inside it if any and finally returning either an adequate QueryExpression object or a plain string representation of the condition. This function is responsible for generating the placeholders and replacing the values by them, while storing the value elsewhere for future binding.

Parameters

string $field

The value from with the actual field and operator will be extracted.

mixed $value

The value to be bound to a placeholder for the field

Returns

string|Cake\Database\ExpressionInterface
string|\Cake\Database\ExpressionInterface

addsource public

add( string|array|Cake\Database\ExpressionInterface $conditions , array $types [] )

Adds one or more conditions to this expression object. Conditions can be expressed in a one dimensional array, that will cause all conditions to be added directly at this level of the tree or they can be nested arbitrarily making it create more expression objects that will be nested inside and configured to use the specified conjunction.

If the type passed for any of the fields is expressed "type[]" (note braces) then it will cause the placeholder to be re-written dynamically so if the value is an array, it will create as many placeholders as values are in it.

Parameters

string|array|Cake\Database\ExpressionInterface $conditions

single or multiple conditions to be added. When using an array and the key is 'OR' or 'AND' a new expression object will be created with that conjunction and internal array value passed as conditions.

array $types optional []

associative array of fields pointing to the type of the values that are being passed. Used for correctly binding values to statements.

Returns

mixed
$this

See

\Cake\Database\Query::where() for examples on conditions

addCasesource public

addCase( array|Cake\Database\ExpressionInterface $conditions , array|Cake\Database\ExpressionInterface $values [] , array $types [] )

Adds a new case expression to the expression object

Parameters

array|Cake\Database\ExpressionInterface $conditions

The conditions to test. Must be a ExpressionInterface instance, or an array of ExpressionInterface instances.

array|Cake\Database\ExpressionInterface $values optional []

associative array of values to be associated with the conditions passed in $conditions. If there are more $values than $conditions, the last $value is used as the ELSE value

array $types optional []

associative array of types to be associated with the values passed in $values

Returns

mixed
$this

and_source public

and_( string|array|Cake\Database\Expression\QueryExpression $conditions , array $types [] )

Returns a new QueryExpression object containing all the conditions passed and set up the conjunction to be "AND"

Parameters

string|array|Cake\Database\Expression\QueryExpression $conditions

to be joined with AND

array $types optional []

associative array of fields pointing to the type of the values that are being passed. Used for correctly binding values to statements.

Returns

Cake\Database\Expression\QueryExpression
\Cake\Database\Expression\QueryExpression

betweensource public

between( mixed $field , mixed $from , mixed $to , string $type null )

Adds a new condition to the expression object in the form "field BETWEEN from AND to".

Parameters

mixed $field

The field name to compare for values in between the range.

mixed $from

The initial value of the range.

mixed $to

The ending value in the comparison range.

string $type optional null

the type name for $value as configured using the Type map.

Returns

mixed
$this

countsource public

count( )

Returns the number of internal conditions that are stored in this expression. Useful to determine if this expression object is void or it will generate a non-empty string when compiled

Returns

integer
int

Implementation of

Countable::count()

eqsource public

eq( string $field , mixed $value , string $type null )

Adds a new condition to the expression object in the form "field = value".

Parameters

string $field

Database field to be compared against value

mixed $value

The value to be bound to $field for comparison

string $type optional null

the type name for $value as configured using the Type map. If it is suffixed with "[]" and the value is an array then multiple placeholders will be created, one per each value in the array.

Returns

mixed
$this

gtsource public

gt( string $field , mixed $value , string $type null )

Adds a new condition to the expression object in the form "field > value".

Parameters

string $field

Database field to be compared against value

mixed $value

The value to be bound to $field for comparison

string $type optional null

the type name for $value as configured using the Type map.

Returns

mixed
$this

gtesource public

gte( string $field , mixed $value , string $type null )

Adds a new condition to the expression object in the form "field >= value".

Parameters

string $field

Database field to be compared against value

mixed $value

The value to be bound to $field for comparison

string $type optional null

the type name for $value as configured using the Type map.

Returns

mixed
$this

hasNestedExpressionsource public

hasNestedExpression( )

Returns true if this expression contains any other nested ExpressionInterface objects

Returns

boolean
bool

insource public

in( string $field , string|array $values , string $type null )

Adds a new condition to the expression object in the form "field IN (value1, value2)".

Parameters

string $field

Database field to be compared against value

string|array $values

the value to be bound to $field for comparison

string $type optional null

the type name for $value as configured using the Type map.

Returns

mixed
$this

isCallablesource public

isCallable( callable $c )

Check whether or not a callable is acceptable.

We don't accept ['class', 'method'] style callbacks, as they often contain user input and arrays of strings are easy to sneak in.

Parameters

callable $c

The callable to check.

Returns

boolean
Valid callable.

isNotNullsource public

isNotNull( string|Cake\Database\ExpressionInterface $field )

Adds a new condition to the expression object in the form "field IS NOT NULL".

Parameters

string|Cake\Database\ExpressionInterface $field

database field to be tested for not null

Returns

mixed
$this

isNullsource public

isNull( string|Cake\Database\ExpressionInterface $field )

Adds a new condition to the expression object in the form "field IS NULL".

Parameters

string|Cake\Database\ExpressionInterface $field

database field to be tested for null

Returns

mixed
$this

iteratePartssource public

iterateParts( callable $callable )

Executes a callable function for each of the parts that form this expression.

The callable function is required to return a value with which the currently visited part will be replaced. If the callable function returns null then the part will be discarded completely from this expression.

The callback function will receive each of the conditions as first param and the key as second param. It is possible to declare the second parameter as passed by reference, this will enable you to change the key under which the modified part is stored.

Parameters

callable $callable

The callable to apply to each part.

Returns

mixed
$this

likesource public

like( string $field , mixed $value , string $type null )

Adds a new condition to the expression object in the form "field LIKE value".

Parameters

string $field

Database field to be compared against value

mixed $value

The value to be bound to $field for comparison

string $type optional null

the type name for $value as configured using the Type map.

Returns

mixed
$this

ltsource public

lt( string $field , mixed $value , string $type null )

Adds a new condition to the expression object in the form "field < value".

Parameters

string $field

Database field to be compared against value

mixed $value

The value to be bound to $field for comparison

string $type optional null

the type name for $value as configured using the Type map.

Returns

mixed
$this

ltesource public

lte( string $field , mixed $value , string $type null )

Adds a new condition to the expression object in the form "field <= value".

Parameters

string $field

Database field to be compared against value

mixed $value

The value to be bound to $field for comparison

string $type optional null

the type name for $value as configured using the Type map.

Returns

mixed
$this

notsource public

not( string|array|Cake\Database\Expression\QueryExpression $conditions , array $types [] )

Adds a new set of conditions to this level of the tree and negates the final result by prepending a NOT, it will look like "NOT ( (condition1) AND (conditions2) )" conjunction depends on the one currently configured for this object.

Parameters

string|array|Cake\Database\Expression\QueryExpression $conditions

to be added and negated

array $types optional []

associative array of fields pointing to the type of the values that are being passed. Used for correctly binding values to statements.

Returns

mixed
$this

notEqsource public

notEq( string $field , mixed $value , string $type null )

Adds a new condition to the expression object in the form "field != value".

Parameters

string $field

Database field to be compared against value

mixed $value

The value to be bound to $field for comparison

string $type optional null

the type name for $value as configured using the Type map. If it is suffixed with "[]" and the value is an array then multiple placeholders will be created, one per each value in the array.

Returns

mixed
$this

notInsource public

notIn( string $field , array $values , string $type null )

Adds a new condition to the expression object in the form "field NOT IN (value1, value2)".

Parameters

string $field

Database field to be compared against value

array $values

the value to be bound to $field for comparison

string $type optional null

the type name for $value as configured using the Type map.

Returns

mixed
$this

notLikesource public

notLike( string $field , mixed $value , string $type null )

Adds a new condition to the expression object in the form "field NOT LIKE value".

Parameters

string $field

Database field to be compared against value

mixed $value

The value to be bound to $field for comparison

string $type optional null

the type name for $value as configured using the Type map.

Returns

mixed
$this

or_source public

or_( string|array|Cake\Database\Expression\QueryExpression $conditions , array $types [] )

Returns a new QueryExpression object containing all the conditions passed and set up the conjunction to be "OR"

Parameters

string|array|Cake\Database\Expression\QueryExpression $conditions

to be joined with OR

array $types optional []

associative array of fields pointing to the type of the values that are being passed. Used for correctly binding values to statements.

Returns

Cake\Database\Expression\QueryExpression
\Cake\Database\Expression\QueryExpression

sqlsource public

sql( Cake\Database\ValueBinder $generator )

Returns the string representation of this object so that it can be used in a SQL query. Note that values condition values are not included in the string, in their place placeholders are put and can be replaced by the quoted values accordingly.

Parameters

Cake\Database\ValueBinder $generator

Placeholder generator object

Returns

string
string

Implementation of

Cake\Database\ExpressionInterface::sql()

traversesource public

traverse( callable $callable )

Traverses the tree structure of this query expression by executing a callback function for each of the conditions that are included in this object. Useful for compiling the final expression, or doing introspection in the structure.

Callback function receives as only argument an instance of a QueryExpression

Parameters

callable $callable

The callable to apply to all sub-expressions.

Implementation of

Cake\Database\ExpressionInterface::traverse()

typesource public

type( string $conjunction null )

Changes the conjunction for the conditions at this level of the expression tree. If called with no arguments it will return the currently configured value.

Parameters

string $conjunction optional null

value to be used for joining conditions. If null it will not set any value, but return the currently stored one

Returns

string|$this
$this

defaultTypessource public

defaultTypes( array $types null )

Allows setting default types when chaining query

Parameters

array $types optional null

The array of types to set.

Returns

mixed
$this|array

typeMapsource public

typeMap( array|TypeMap $typeMap null )

Creates a new TypeMap if $typeMap is an array, otherwise returns the existing type map or exchanges it for the given one.

Parameters

array|TypeMap $typeMap optional null

Creates a TypeMap if array, otherwise sets the given TypeMap

Returns

mixed
$this|TypeMap

[]