$_returnType
$_returnType : string
The type name this expression will return when executed
This class represents a function call string in a SQL statement. Calls can be constructed by passing the name of the function and a list of params.
For security reasons, all params passed are quoted by default unless explicitly told otherwise.
$_typeMap : \Cake\Database\TypeMap
__construct(string $name, array $params = array(), array $types = array(), string $returnType = 'string')
Constructor. Takes a name for the function to be invoked and a list of params to be passed into the function. Optionally you can pass a list of types to be used for each bound param.
By default, all params that are passed will be quoted. If you wish to use literal arguments, you need to explicitly hint this function.
$f = new FunctionExpression('CONCAT', ['CakePHP', ' rules']);
Previous line will generate CONCAT('CakePHP', ' rules')
$f = new FunctionExpression('CONCAT', ['name' => 'literal', ' rules']);
Will produce CONCAT(name, ' rules')
| string | $name | the name of the function to be constructed |
| array | $params | list of arguments to be passed to the function If associative the key would be used as argument when value is 'literal' |
| array | $types | associative array of types to be associated with the passed arguments |
| string | $returnType | The return type of this expression |
tieWith(string|null $conjunction = null) : string|$this
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.
| string|null | $conjunction | value to be used for joining conditions. If null it will not set any value, but return the currently stored one |
add(array $params, array $types = array(), boolean $prepend = false) : $this
Adds one or more arguments for the function call.
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.
| array | $params | list of arguments to be passed to the function If associative the key would be used as argument when value is 'literal' |
| array | $types | associative array of types to be associated with the passed arguments |
| boolean | $prepend | Whether to prepend or append to the list of arguments |
eq(string|\Cake\Database\ExpressionInterface $field, mixed $value, string|null $type = null) : $this
Adds a new condition to the expression object in the form "field = value".
| string|\Cake\Database\ExpressionInterface | $field | Database field to be compared against value |
| mixed | $value | The value to be bound to $field for comparison |
| string|null | $type | 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. |
notEq(string|\Cake\Database\ExpressionInterface $field, mixed $value, string|null $type = null) : $this
Adds a new condition to the expression object in the form "field != value".
| string|\Cake\Database\ExpressionInterface | $field | Database field to be compared against value |
| mixed | $value | The value to be bound to $field for comparison |
| string|null | $type | 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. |
gt(string|\Cake\Database\ExpressionInterface $field, mixed $value, string|null $type = null) : $this
Adds a new condition to the expression object in the form "field > value".
| string|\Cake\Database\ExpressionInterface | $field | Database field to be compared against value |
| mixed | $value | The value to be bound to $field for comparison |
| string|null | $type | the type name for $value as configured using the Type map. |
lt(string|\Cake\Database\ExpressionInterface $field, mixed $value, string|null $type = null) : $this
Adds a new condition to the expression object in the form "field < value".
| string|\Cake\Database\ExpressionInterface | $field | Database field to be compared against value |
| mixed | $value | The value to be bound to $field for comparison |
| string|null | $type | the type name for $value as configured using the Type map. |
gte(string|\Cake\Database\ExpressionInterface $field, mixed $value, string|null $type = null) : $this
Adds a new condition to the expression object in the form "field >= value".
| string|\Cake\Database\ExpressionInterface | $field | Database field to be compared against value |
| mixed | $value | The value to be bound to $field for comparison |
| string|null | $type | the type name for $value as configured using the Type map. |
lte(string|\Cake\Database\ExpressionInterface $field, mixed $value, string|null $type = null) : $this
Adds a new condition to the expression object in the form "field <= value".
| string|\Cake\Database\ExpressionInterface | $field | Database field to be compared against value |
| mixed | $value | The value to be bound to $field for comparison |
| string|null | $type | the type name for $value as configured using the Type map. |
isNull(string|\Cake\Database\ExpressionInterface $field) : $this
Adds a new condition to the expression object in the form "field IS NULL".
| string|\Cake\Database\ExpressionInterface | $field | database field to be tested for null |
isNotNull(string|\Cake\Database\ExpressionInterface $field) : $this
Adds a new condition to the expression object in the form "field IS NOT NULL".
| string|\Cake\Database\ExpressionInterface | $field | database field to be tested for not null |
like(string|\Cake\Database\ExpressionInterface $field, mixed $value, string|null $type = null) : $this
Adds a new condition to the expression object in the form "field LIKE value".
| string|\Cake\Database\ExpressionInterface | $field | Database field to be compared against value |
| mixed | $value | The value to be bound to $field for comparison |
| string|null | $type | the type name for $value as configured using the Type map. |
notLike(string|\Cake\Database\ExpressionInterface $field, mixed $value, string|null $type = null) : $this
Adds a new condition to the expression object in the form "field NOT LIKE value".
| string|\Cake\Database\ExpressionInterface | $field | Database field to be compared against value |
| mixed | $value | The value to be bound to $field for comparison |
| string|null | $type | the type name for $value as configured using the Type map. |
in(string|\Cake\Database\ExpressionInterface $field, string|array $values, string|null $type = null) : $this
Adds a new condition to the expression object in the form "field IN (value1, value2)".
| string|\Cake\Database\ExpressionInterface | $field | Database field to be compared against value |
| string|array | $values | the value to be bound to $field for comparison |
| string|null | $type | the type name for $value as configured using the Type map. |
addCase(array|\Cake\Database\ExpressionInterface $conditions, array|\Cake\Database\ExpressionInterface $values = array(), array $types = array()) : $this
Adds a new case expression to the expression object
| 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 | 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 |
| array | $types | associative array of types to be associated with the values passed in $values |
notIn(string|\Cake\Database\ExpressionInterface $field, array $values, string|null $type = null) : $this
Adds a new condition to the expression object in the form "field NOT IN (value1, value2)".
| string|\Cake\Database\ExpressionInterface | $field | Database field to be compared against value |
| array | $values | the value to be bound to $field for comparison |
| string|null | $type | the type name for $value as configured using the Type map. |
exists(\Cake\Database\ExpressionInterface $query) : $this
Adds a new condition to the expression object in the form "EXISTS (.
..)".
| \Cake\Database\ExpressionInterface | $query | the inner query |
notExists(\Cake\Database\ExpressionInterface $query) : $this
Adds a new condition to the expression object in the form "NOT EXISTS (.
..)".
| \Cake\Database\ExpressionInterface | $query | the inner query |
between(string|\Cake\Database\ExpressionInterface $field, mixed $from, mixed $to, string|null $type = null) : $this
Adds a new condition to the expression object in the form "field BETWEEN from AND to".
| string|\Cake\Database\ExpressionInterface | $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|null | $type | the type name for $value as configured using the Type map. |
and_(string|array|\Cake\Database\ExpressionInterface $conditions, array $types = array()) : \Cake\Database\Expression\QueryExpression
Returns a new QueryExpression object containing all the conditions passed and set up the conjunction to be "AND"
| string|array|\Cake\Database\ExpressionInterface | $conditions | to be joined with AND |
| array | $types | associative array of fields pointing to the type of the values that are being passed. Used for correctly binding values to statements. |
or_(string|array|\Cake\Database\ExpressionInterface $conditions, array $types = array()) : \Cake\Database\Expression\QueryExpression
Returns a new QueryExpression object containing all the conditions passed and set up the conjunction to be "OR"
| string|array|\Cake\Database\ExpressionInterface | $conditions | to be joined with OR |
| array | $types | associative array of fields pointing to the type of the values that are being passed. Used for correctly binding values to statements. |
not(string|array|\Cake\Database\ExpressionInterface $conditions, array $types = array()) : $this
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.
| string|array|\Cake\Database\ExpressionInterface | $conditions | to be added and negated |
| array | $types | associative array of fields pointing to the type of the values that are being passed. Used for correctly binding values to statements. |
sql(\Cake\Database\ValueBinder $generator) : string
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.
| \Cake\Database\ValueBinder | $generator | Placeholder generator object |
traverse(callable $callable) : void
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 ExpressionInterface
| callable | $callable | The callable to apply to all sub-expressions. |
iterateParts(callable $callable) : $this
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.
| callable | $callable | The callable to apply to each part. |
__call(string $method, array $args) : \Cake\Database\Expression\QueryExpression
Helps calling the `and()` and `or()` methods transparently.
| string | $method | The method name. |
| array | $args | The arguments to pass to the method. |
isCallable(callable $c) : boolean
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.
| callable | $c | The callable to check. |
Valid callable.
setTypeMap(array|\Cake\Database\TypeMap $typeMap) : $this
Creates a new TypeMap if $typeMap is an array, otherwise exchanges it for the given one.
| array|\Cake\Database\TypeMap | $typeMap | Creates a TypeMap if array, otherwise sets the given TypeMap |
getTypeMap() : \Cake\Database\TypeMap
Returns the existing type map.
typeMap(array|\Cake\Database\TypeMap|null $typeMap = null) : $this|\Cake\Database\TypeMap
Creates a new TypeMap if $typeMap is an array, otherwise returns the existing type map or exchanges it for the given one.
| array|\Cake\Database\TypeMap|null | $typeMap | Creates a TypeMap if array, otherwise sets the given TypeMap |
_castToExpression(mixed $value, string $type) : mixed
Conditionally converts the passed value to an ExpressionInterface object if the type class implements the ExpressionTypeInterface. Otherwise, returns the value unmodified.
| mixed | $value | The value to converto to ExpressionInterface |
| string | $type | The type name |
_addConditions(array $conditions, array $types) : void
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.
| array | $conditions | list of conditions to be stored in this object |
| array | $types | list of types associated on fields referenced in $conditions |
_parseCondition(string $field, mixed $value) : string|\Cake\Database\ExpressionInterface
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.
| 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 |
_calculateType(string|\Cake\Database\Expression\IdentifierExpression $field) : string|null
Returns the type name for the passed field if it was stored in the typeMap
| string|\Cake\Database\Expression\IdentifierExpression | $field | The field name to get a type for. |
The computed type or null, if the type is unknown.