SQLConditionalExpression

Swap some text in the SQL query with another.

Note that values in parameters will not be replaced

Return the generated SQL string for this query

Is it ok for this to consider parameters? Test cases here!

Swap the use of one table with another.

Determine if this query is empty, and thus cannot be executed

Generate the SQL statement for this query.

Execute this query.

Copies the query parameters contained in this object to another SQLExpression

Construct a new SQLInteractExpression.

Sets the list of tables to query from or update

Add a table to include in the query or update

Set the connective property.

Get the connective property.

Use the disjunctive operator 'OR' to join filter expressions in the WHERE clause.

Use the conjunctive operator 'AND' to join filter expressions in the WHERE clause.

Add a LEFT JOIN criteria to the tables list.

Add an INNER JOIN criteria

Add an additional filter (part of the ON clause) on a join.

Set the filter (part of the ON clause) on a join.

Returns true if we are already joining to the given table alias

Return a list of tables that this query is selecting from.

Return a list of tables queried

Retrieves the finalized list of joins

This part of the code could be simplified

Ensure that framework "auto-generated" table JOINs are first in the finalised SQL query.

This prevents issues where developer-initiated JOINs attempt to JOIN using relations that haven't actually yet been scaffolded by the framework. Demonstrated by PostGres in errors like: "...ERROR: missing FROM-clause..."

Since uasort don't preserve the order of an array if the comparison is equal we have to resort to a merge sort. It's quick and stable: O(n*log(n)).

Set a WHERE clause.

Adds a WHERE clause.

Note that the database will execute any parameterized queries using prepared statements whenever available.

There are several different ways of doing this.

 // the entire predicate as a single string
 $query->addWhere("\"Column\" = 'Value'");

 // multiple predicates as an array
 $query->addWhere(array("\"Column\" = 'Value'", "\"Column\" != 'Value'"));

 // Shorthand for the above using argument expansion
 $query->addWhere("\"Column\" = 'Value'", "\"Column\" != 'Value'");

 // multiple predicates with parameters
 $query->addWhere(array('"Column" = ?' => $column, '"Name" = ?' => $value)));

 // Shorthand for simple column comparison (as above), omitting the '?'
 $query->addWhere(array('"Column"' => $column, '"Name"' => $value));

 // Multiple predicates, each with multiple parameters.
 $query->addWhere(array(
     '"ColumnOne" = ? OR "ColumnTwo" != ?' => array(1, 4),
     '"ID" != ?' => $value
 ));

 // Using a dynamically generated condition (any object that implements SQLConditionGroup)
 $condition = new ObjectThatImplements_SQLConditionGroup();
 $query->addWhere($condition);

Note that if giving multiple parameters for a single predicate the array of values must be given as an indexed array, not an associative array.

Also should be noted is that any null values for parameters may give unexpected behaviour. array('Column' => NULL) is shorthand for array('Column = ?', NULL), and will not match null values for that column, as 'Column IS NULL' is the correct syntax.

Additionally, be careful of key conflicts. Adding two predicates with the same condition but different parameters can cause a key conflict if added in the same array. This can be solved by wrapping each individual condition in an array. E.g.

// Multiple predicates with duplicate conditions
 $query->addWhere(array(
     array('ID != ?' => 5),
     array('ID != ?' => 6)
 ));

// Alternatively this can be added in two separate calls to addWhere
$query->addWhere(array('ID != ?' => 5));
$query->addWhere(array('ID != ?' => 6));

// Or simply omit the outer array
$query->addWhere(array('ID != ?' => 5), array('ID != ?' => 6));

If it's necessary to force the parameter to be considered as a specific data type by the database connector's prepared query processor any parameter can be cast to that type by using the following format.

 // Treat this value as a double type, regardless of its type within PHP
 $query->addWhere(array(
     'Column' => array(
         'value' => $variable,
         'type' => 'double'
     )
 ));

No description

No description

Return a list of WHERE clauses used internally.

Return a list of WHERE clauses used internally.

Given a key / value pair, extract the predicate and any potential parameters in a format suitable for storing internally as a list of parameterized conditions.

Given a list of conditions in any user-acceptable format, convert this to an array of parameterized predicates suitable for merging with $this->where.

Normalised predicates are in the below format, in order to avoid key collisions.

array(
 array('Condition != ?' => array('parameter')),
 array('Condition != ?' => array('otherparameter')),
 array('Condition = 3' => array()),
 array('Condition = ? OR Condition = ?' => array('parameter1', 'parameter2))
)

Given a list of conditions as per the format of $this->where, split this into an array of predicates, and a separate array of ordered parameters

Note, that any SQLConditionGroup objects will be evaluated here.

Checks whether this query is for a specific ID in a table

Doesn't work with combined statements (e.g. "Foo='bar' AND ID=5")

Checks whether this query is filtering on a foreign key, ie finding a has_many relationship

Doesn't work with combined statements (e.g. "Foo='bar' AND ParentID=5")

Generates an SQLDelete object using the currently specified parameters

Generates an SQLSelect object using the currently specified parameters.

Generates an SQLUpdate object using the currently specified parameters.

No fields will have any assigned values for the newly generated SQLUpdate object.