Package | system.db.schema |
---|---|
Inheritance | class CDbCommandBuilder » CComponent |
Subclasses | CMssqlCommandBuilder, CMysqlCommandBuilder, COciCommandBuilder, CPgsqlCommandBuilder, CSqliteCommandBuilder |
Since | 1.0 |
Source Code | framework/db/schema/CDbCommandBuilder.php |
Property | Type | Description | Defined By |
---|---|---|---|
dbConnection | CDbConnection | database connection. | CDbCommandBuilder |
schema | CDbSchema | the schema for this command builder. | CDbCommandBuilder |
Property | Type | Description | Defined By |
---|---|---|---|
integerPrimaryKeyDefaultValue | string | Returns default value of the integer/serial primary key. Default value means that the next | CDbCommandBuilder |
Method | Description | Defined By |
---|---|---|
__call() | Calls the named method which is not a class method. | CComponent |
__construct() | CDbCommandBuilder | |
__get() | Returns a property value, an event handler list or a behavior based on its name. | CComponent |
__isset() | Checks if a property value is null. | CComponent |
__set() | Sets value of a component property. | CComponent |
__unset() | Sets a component property to be null. | CComponent |
applyCondition() | Alters the SQL to apply WHERE clause. | CDbCommandBuilder |
applyGroup() | Alters the SQL to apply GROUP BY. | CDbCommandBuilder |
applyHaving() | Alters the SQL to apply HAVING. | CDbCommandBuilder |
applyJoin() | Alters the SQL to apply JOIN clause. | CDbCommandBuilder |
applyLimit() | Alters the SQL to apply LIMIT and OFFSET. | CDbCommandBuilder |
applyOrder() | Alters the SQL to apply ORDER BY. | CDbCommandBuilder |
asa() | Returns the named behavior object. | CComponent |
attachBehavior() | Attaches a behavior to this component. | CComponent |
attachBehaviors() | Attaches a list of behaviors to the component. | CComponent |
attachEventHandler() | Attaches an event handler to an event. | CComponent |
bindValues() | Binds parameter values for an SQL command. | CDbCommandBuilder |
canGetProperty() | Determines whether a property can be read. | CComponent |
canSetProperty() | Determines whether a property can be set. | CComponent |
createColumnCriteria() | Creates a query criteria with the specified column values. | CDbCommandBuilder |
createCountCommand() | Creates a COUNT(*) command for a single table. | CDbCommandBuilder |
createCriteria() | Creates a query criteria. | CDbCommandBuilder |
createDeleteCommand() | Creates a DELETE command. | CDbCommandBuilder |
createFindCommand() | Creates a SELECT command for a single table. | CDbCommandBuilder |
createInCondition() | Generates the expression for selecting rows of specified primary key values. | CDbCommandBuilder |
createInsertCommand() | Creates an INSERT command. | CDbCommandBuilder |
createMultipleInsertCommand() | Creates a multiple INSERT command. | CDbCommandBuilder |
createPkCondition() | Generates the expression for selecting rows of specified primary key values. | CDbCommandBuilder |
createPkCriteria() | Creates a query criteria with the specified primary key. | CDbCommandBuilder |
createSearchCondition() | Generates the expression for searching the specified keywords within a list of columns. | CDbCommandBuilder |
createSqlCommand() | Creates a command based on a given SQL statement. | CDbCommandBuilder |
createUpdateCommand() | Creates an UPDATE command. | CDbCommandBuilder |
createUpdateCounterCommand() | Creates an UPDATE command that increments/decrements certain columns. | CDbCommandBuilder |
detachBehavior() | Detaches a behavior from the component. | CComponent |
detachBehaviors() | Detaches all behaviors from the component. | CComponent |
detachEventHandler() | Detaches an existing event handler. | CComponent |
disableBehavior() | Disables an attached behavior. | CComponent |
disableBehaviors() | Disables all behaviors attached to this component. | CComponent |
enableBehavior() | Enables an attached behavior. | CComponent |
enableBehaviors() | Enables all behaviors attached to this component. | CComponent |
evaluateExpression() | Evaluates a PHP expression or callback under the context of this component. | CComponent |
getDbConnection() | Returns database connection. | CDbCommandBuilder |
getEventHandlers() | Returns the list of attached event handlers for an event. | CComponent |
getLastInsertID() | Returns the last insertion ID for the specified table. | CDbCommandBuilder |
getSchema() | Returns the schema for this command builder. | CDbCommandBuilder |
hasEvent() | Determines whether an event is defined. | CComponent |
hasEventHandler() | Checks whether the named event has attached handlers. | CComponent |
hasProperty() | Determines whether a property is defined. | CComponent |
raiseEvent() | Raises an event. | CComponent |
Method | Description | Defined By |
---|---|---|
composeMultipleInsertCommand() | Creates a multiple INSERT command. | CDbCommandBuilder |
createCompositeInCondition() | Generates the expression for selecting rows with specified composite key values. | CDbCommandBuilder |
ensureTable() | Checks if the parameter is a valid table schema. | CDbCommandBuilder |
getIntegerPrimaryKeyDefaultValue() | Returns default value of the integer/serial primary key. Default value means that the next | CDbCommandBuilder |
database connection.
Returns default value of the integer/serial primary key. Default value means that the next autoincrement/sequence value would be used.
the schema for this command builder.
public void __construct(CDbSchema $schema)
| ||
$schema | CDbSchema | the schema for this command builder |
public function __construct($schema)
{
$this->_schema=$schema;
$this->_connection=$schema->getDbConnection();
}
public string applyCondition(string $sql, string $condition)
| ||
$sql | string | the SQL statement without WHERE clause |
$condition | string | the WHERE clause (without WHERE keyword) |
{return} | string | the altered SQL statement |
public function applyCondition($sql,$condition)
{
if($condition!='')
return $sql.' WHERE '.$condition;
else
return $sql;
}
Alters the SQL to apply WHERE clause.
public string applyGroup(string $sql, string $group)
| ||
$sql | string | SQL query string without GROUP BY. |
$group | string | GROUP BY |
{return} | string | SQL with GROUP BY. |
public function applyGroup($sql,$group)
{
if($group!='')
return $sql.' GROUP BY '.$group;
else
return $sql;
}
Alters the SQL to apply GROUP BY.
public string applyHaving(string $sql, string $having)
| ||
$sql | string | SQL query string without HAVING |
$having | string | HAVING |
{return} | string | SQL with HAVING |
public function applyHaving($sql,$having)
{
if($having!='')
return $sql.' HAVING '.$having;
else
return $sql;
}
Alters the SQL to apply HAVING.
public string applyJoin(string $sql, string $join)
| ||
$sql | string | the SQL statement to be altered |
$join | string | the JOIN clause (starting with join type, such as INNER JOIN) |
{return} | string | the altered SQL statement |
public function applyJoin($sql,$join)
{
if($join!='')
return $sql.' '.$join;
else
return $sql;
}
Alters the SQL to apply JOIN clause.
public string applyLimit(string $sql, integer $limit, integer $offset)
| ||
$sql | string | SQL query string without LIMIT and OFFSET. |
$limit | integer | maximum number of rows, -1 to ignore limit. |
$offset | integer | row offset, -1 to ignore offset. |
{return} | string | SQL with LIMIT and OFFSET |
public function applyLimit($sql,$limit,$offset)
{
if($limit>=0)
$sql.=' LIMIT '.(int)$limit;
if($offset>0)
$sql.=' OFFSET '.(int)$offset;
return $sql;
}
Alters the SQL to apply LIMIT and OFFSET. Default implementation is applicable for PostgreSQL, MySQL, MariaDB and SQLite.
public string applyOrder(string $sql, string $orderBy)
| ||
$sql | string | SQL statement without ORDER BY. |
$orderBy | string | column ordering |
{return} | string | modified SQL applied with ORDER BY. |
public function applyOrder($sql,$orderBy)
{
if($orderBy!='')
return $sql.' ORDER BY '.$orderBy;
else
return $sql;
}
Alters the SQL to apply ORDER BY.
public void bindValues(CDbCommand $command, array $values)
| ||
$command | CDbCommand | database command |
$values | array | values for binding (integer-indexed array for question mark placeholders, string-indexed array for named placeholders) |
public function bindValues($command, $values)
{
if(($n=count($values))===0)
return;
if(isset($values[0])) // question mark placeholders
{
for($i=0;$i<$n;++$i)
$command->bindValue($i+1,$values[$i]);
}
else // named placeholders
{
foreach($values as $name=>$value)
{
if($name[0]!==':')
$name=':'.$name;
$command->bindValue($name,$value);
}
}
}
Binds parameter values for an SQL command.
protected CDbCommand composeMultipleInsertCommand(mixed $table, array $data, array $templates=array (
))
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$data | array | list data to be inserted, each value should be an array in format (column name=>column value). If a key is not a valid column name, the corresponding value will be ignored. |
$templates | array | templates for the SQL parts. |
{return} | CDbCommand | multiple insert command |
protected function composeMultipleInsertCommand($table,array $data,array $templates=array())
{
if (empty($data))
throw new CDbException(Yii::t('yii','Can not generate multiple insert command with empty data set.'));
$templates=array_merge(
array(
'main'=>'INSERT INTO {{tableName}} ({{columnInsertNames}}) VALUES {{rowInsertValues}}',
'columnInsertValue'=>'{{value}}',
'columnInsertValueGlue'=>', ',
'rowInsertValue'=>'({{columnInsertValues}})',
'rowInsertValueGlue'=>', ',
'columnInsertNameGlue'=>', ',
),
$templates
);
$this->ensureTable($table);
$tableName=$table->rawName;
$params=array();
$columnInsertNames=array();
$rowInsertValues=array();
$columns=array();
foreach($data as $rowData)
{
foreach($rowData as $columnName=>$columnValue)
{
if(!in_array($columnName,$columns,true))
if($table->getColumn($columnName)!==null)
$columns[]=$columnName;
}
}
foreach($columns as $name)
$columnInsertNames[$name]=$this->getDbConnection()->quoteColumnName($name);
$columnInsertNamesSqlPart=implode($templates['columnInsertNameGlue'],$columnInsertNames);
foreach($data as $rowKey=>$rowData)
{
$columnInsertValues=array();
foreach($columns as $columnName)
{
$column=$table->getColumn($columnName);
$columnValue=array_key_exists($columnName,$rowData) ? $rowData[$columnName] : new CDbExpression('NULL');
if($columnValue instanceof CDbExpression)
{
$columnInsertValue=$columnValue->expression;
foreach($columnValue->params as $columnValueParamName=>$columnValueParam)
$params[$columnValueParamName]=$columnValueParam;
}
else
{
$columnInsertValue=':'.$columnName.'_'.$rowKey;
$params[':'.$columnName.'_'.$rowKey]=$column->typecast($columnValue);
}
$columnInsertValues[]=strtr($templates['columnInsertValue'],array(
'{{column}}'=>$columnInsertNames[$columnName],
'{{value}}'=>$columnInsertValue,
));
}
$rowInsertValues[]=strtr($templates['rowInsertValue'],array(
'{{tableName}}'=>$tableName,
'{{columnInsertNames}}'=>$columnInsertNamesSqlPart,
'{{columnInsertValues}}'=>implode($templates['columnInsertValueGlue'],$columnInsertValues)
));
}
$sql=strtr($templates['main'],array(
'{{tableName}}'=>$tableName,
'{{columnInsertNames}}'=>$columnInsertNamesSqlPart,
'{{rowInsertValues}}'=>implode($templates['rowInsertValueGlue'], $rowInsertValues),
));
$command=$this->getDbConnection()->createCommand($sql);
foreach($params as $name=>$value)
$command->bindValue($name,$value);
return $command;
}
Creates a multiple INSERT command. This method compose the SQL expression via given part templates, providing ability to adjust command for different SQL syntax.
public CDbCriteria createColumnCriteria(mixed $table, array $columns, mixed $condition='', array $params=array (
), string $prefix=NULL)
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$columns | array | column values that should be matched in the query (name=>value) |
$condition | mixed | query condition or criteria. If a string, it is treated as query condition; If an array, it is treated as the initial values for constructing a CDbCriteria; Otherwise, it should be an instance of CDbCriteria. |
$params | array | parameters to be bound to an SQL statement. This is only used when the third parameter is a string (query condition). In other cases, please use CDbCriteria::params to set parameters. |
$prefix | string | column prefix (ended with dot). If null, it will be the table name |
{return} | CDbCriteria | the created query criteria |
public function createColumnCriteria($table,$columns,$condition='',$params=array(),$prefix=null)
{
$this->ensureTable($table);
$criteria=$this->createCriteria($condition,$params);
if($criteria->alias!='')
$prefix=$this->_schema->quoteTableName($criteria->alias).'.';
$bindByPosition=isset($criteria->params[0]);
$conditions=array();
$values=array();
$i=0;
if($prefix===null)
$prefix=$table->rawName.'.';
foreach($columns as $name=>$value)
{
if(($column=$table->getColumn($name))!==null)
{
if(is_array($value))
$conditions[]=$this->createInCondition($table,$name,$value,$prefix);
elseif($value!==null)
{
if($bindByPosition)
{
$conditions[]=$prefix.$column->rawName.'=?';
$values[]=$value;
}
else
{
$conditions[]=$prefix.$column->rawName.'='.self::PARAM_PREFIX.$i;
$values[self::PARAM_PREFIX.$i]=$value;
$i++;
}
}
else
$conditions[]=$prefix.$column->rawName.' IS NULL';
}
else
throw new CDbException(Yii::t('yii','Table "{table}" does not have a column named "{column}".',
array('{table}'=>$table->name,'{column}'=>$name)));
}
$criteria->params=array_merge($values,$criteria->params);
if(isset($conditions[0]))
{
if($criteria->condition!='')
$criteria->condition=implode(' AND ',$conditions).' AND ('.$criteria->condition.')';
else
$criteria->condition=implode(' AND ',$conditions);
}
return $criteria;
}
Creates a query criteria with the specified column values.
protected string createCompositeInCondition(CDbTableSchema $table, array $values, string $prefix)
| ||
$table | CDbTableSchema | the table schema |
$values | array | list of primary key values to be selected within |
$prefix | string | column prefix (ended with dot) |
{return} | string | the expression for selection |
protected function createCompositeInCondition($table,$values,$prefix)
{
$keyNames=array();
foreach(array_keys($values[0]) as $name)
$keyNames[]=$prefix.$table->columns[$name]->rawName;
$vs=array();
foreach($values as $value)
$vs[]='('.implode(', ',$value).')';
return '('.implode(', ',$keyNames).') IN ('.implode(', ',$vs).')';
}
Generates the expression for selecting rows with specified composite key values.
public CDbCommand createCountCommand(mixed $table, CDbCriteria $criteria, string $alias='t')
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$criteria | CDbCriteria | the query criteria |
$alias | string | the alias name of the primary table. Defaults to 't'. |
{return} | CDbCommand | query command. |
public function createCountCommand($table,$criteria,$alias='t')
{
$this->ensureTable($table);
if($criteria->alias!='')
$alias=$criteria->alias;
$alias=$this->_schema->quoteTableName($alias);
if(!empty($criteria->group) || !empty($criteria->having))
{
$select=is_array($criteria->select) ? implode(', ',$criteria->select) : $criteria->select;
if($criteria->alias!='')
$alias=$criteria->alias;
$sql=($criteria->distinct ? 'SELECT DISTINCT':'SELECT')." {$select} FROM {$table->rawName} $alias";
$sql=$this->applyJoin($sql,$criteria->join);
$sql=$this->applyCondition($sql,$criteria->condition);
$sql=$this->applyGroup($sql,$criteria->group);
$sql=$this->applyHaving($sql,$criteria->having);
$sql="SELECT COUNT(*) FROM ($sql) sq";
}
else
{
if(is_string($criteria->select) && stripos($criteria->select,'count')===0)
$sql="SELECT ".$criteria->select;
elseif($criteria->distinct)
{
if(is_array($table->primaryKey))
{
$pk=array();
foreach($table->primaryKey as $key)
$pk[]=$alias.'.'.$this->_schema->quoteColumnName($key);
$pk=implode(', ',$pk);
}
else
$pk=$alias.'.'.$this->_schema->quoteColumnName($table->primaryKey);
$sql="SELECT COUNT(DISTINCT $pk)";
}
else
$sql="SELECT COUNT(*)";
$sql.=" FROM {$table->rawName} $alias";
$sql=$this->applyJoin($sql,$criteria->join);
$sql=$this->applyCondition($sql,$criteria->condition);
}
// Suppress binding of parameters belonging to the ORDER clause. Issue #1407.
if($criteria->order && $criteria->params)
{
$params1=array();
preg_match_all('/(:\w+)/',$sql,$params1);
$params2=array();
preg_match_all('/(:\w+)/',$this->applyOrder($sql,$criteria->order),$params2);
foreach(array_diff($params2[0],$params1[0]) as $param)
unset($criteria->params[$param]);
}
// Do the same for SELECT part.
if($criteria->select && $criteria->params)
{
$params1=array();
preg_match_all('/(:\w+)/',$sql,$params1);
$params2=array();
preg_match_all('/(:\w+)/',$sql.' '.(is_array($criteria->select) ? implode(', ',$criteria->select) : $criteria->select),$params2);
foreach(array_diff($params2[0],$params1[0]) as $param)
unset($criteria->params[$param]);
}
$command=$this->_connection->createCommand($sql);
$this->bindValues($command,$criteria->params);
return $command;
}
Creates a COUNT(*) command for a single table.
public CDbCriteria createCriteria(mixed $condition='', array $params=array (
))
| ||
$condition | mixed | query condition or criteria. If a string, it is treated as query condition (the WHERE clause); If an array, it is treated as the initial values for constructing a CDbCriteria object; Otherwise, it should be an instance of CDbCriteria. |
$params | array | parameters to be bound to an SQL statement. This is only used when the first parameter is a string (query condition). In other cases, please use CDbCriteria::params to set parameters. |
{return} | CDbCriteria | the created query criteria |
public function createCriteria($condition='',$params=array())
{
if(is_array($condition))
$criteria=new CDbCriteria($condition);
elseif($condition instanceof CDbCriteria)
$criteria=clone $condition;
else
{
$criteria=new CDbCriteria;
$criteria->condition=$condition;
$criteria->params=$params;
}
return $criteria;
}
Creates a query criteria.
public CDbCommand createDeleteCommand(mixed $table, CDbCriteria $criteria)
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$criteria | CDbCriteria | the query criteria |
{return} | CDbCommand | delete command. |
public function createDeleteCommand($table,$criteria)
{
$this->ensureTable($table);
$sql="DELETE FROM {$table->rawName}";
$sql=$this->applyJoin($sql,$criteria->join);
$sql=$this->applyCondition($sql,$criteria->condition);
$sql=$this->applyGroup($sql,$criteria->group);
$sql=$this->applyHaving($sql,$criteria->having);
$sql=$this->applyOrder($sql,$criteria->order);
$sql=$this->applyLimit($sql,$criteria->limit,$criteria->offset);
$command=$this->_connection->createCommand($sql);
$this->bindValues($command,$criteria->params);
return $command;
}
Creates a DELETE command.
public CDbCommand createFindCommand(mixed $table, CDbCriteria $criteria, string $alias='t')
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$criteria | CDbCriteria | the query criteria |
$alias | string | the alias name of the primary table. Defaults to 't'. |
{return} | CDbCommand | query command. |
public function createFindCommand($table,$criteria,$alias='t')
{
$this->ensureTable($table);
$select=is_array($criteria->select) ? implode(', ',$criteria->select) : $criteria->select;
if($criteria->alias!='')
$alias=$criteria->alias;
$alias=$this->_schema->quoteTableName($alias);
// issue 1432: need to expand * when SQL has JOIN
if($select==='*' && !empty($criteria->join))
{
$prefix=$alias.'.';
$select=array();
foreach($table->getColumnNames() as $name)
$select[]=$prefix.$this->_schema->quoteColumnName($name);
$select=implode(', ',$select);
}
$sql=($criteria->distinct ? 'SELECT DISTINCT':'SELECT')." {$select} FROM {$table->rawName} $alias";
$sql=$this->applyJoin($sql,$criteria->join);
$sql=$this->applyCondition($sql,$criteria->condition);
$sql=$this->applyGroup($sql,$criteria->group);
$sql=$this->applyHaving($sql,$criteria->having);
$sql=$this->applyOrder($sql,$criteria->order);
$sql=$this->applyLimit($sql,$criteria->limit,$criteria->offset);
$command=$this->_connection->createCommand($sql);
$this->bindValues($command,$criteria->params);
return $command;
}
Creates a SELECT command for a single table.
public string createInCondition(mixed $table, mixed $columnName, array $values, string $prefix=NULL)
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$columnName | mixed | the column name(s). It can be either a string indicating a single column or an array of column names. If the latter, it stands for a composite key. |
$values | array | list of key values to be selected within |
$prefix | string | column prefix (ended with dot). If null, it will be the table name |
{return} | string | the expression for selection |
public function createInCondition($table,$columnName,$values,$prefix=null)
{
if(($n=count($values))<1)
return '0=1';
$this->ensureTable($table);
if($prefix===null)
$prefix=$table->rawName.'.';
$db=$this->_connection;
if(is_array($columnName) && count($columnName)===1)
$columnName=reset($columnName);
if(is_string($columnName)) // simple key
{
if(!isset($table->columns[$columnName]))
throw new CDbException(Yii::t('yii','Table "{table}" does not have a column named "{column}".',
array('{table}'=>$table->name, '{column}'=>$columnName)));
$column=$table->columns[$columnName];
$values=array_values($values);
foreach($values as &$value)
{
$value=$column->typecast($value);
if(is_string($value))
$value=$db->quoteValue($value);
}
if($n===1)
return $prefix.$column->rawName.($values[0]===null?' IS NULL':'='.$values[0]);
else
return $prefix.$column->rawName.' IN ('.implode(', ',$values).')';
}
elseif(is_array($columnName)) // composite key: $values=array(array('pk1'=>'v1','pk2'=>'v2'),array(...))
{
foreach($columnName as $name)
{
if(!isset($table->columns[$name]))
throw new CDbException(Yii::t('yii','Table "{table}" does not have a column named "{column}".',
array('{table}'=>$table->name, '{column}'=>$name)));
for($i=0;$i<$n;++$i)
{
if(isset($values[$i][$name]))
{
$value=$table->columns[$name]->typecast($values[$i][$name]);
if(is_string($value))
$values[$i][$name]=$db->quoteValue($value);
else
$values[$i][$name]=$value;
}
else
throw new CDbException(Yii::t('yii','The value for the column "{column}" is not supplied when querying the table "{table}".',
array('{table}'=>$table->name,'{column}'=>$name)));
}
}
if(count($values)===1)
{
$entries=array();
foreach($values[0] as $name=>$value)
$entries[]=$prefix.$table->columns[$name]->rawName.($value===null?' IS NULL':'='.$value);
return implode(' AND ',$entries);
}
return $this->createCompositeInCondition($table,$values,$prefix);
}
else
throw new CDbException(Yii::t('yii','Column name must be either a string or an array.'));
}
Generates the expression for selecting rows of specified primary key values.
public CDbCommand createInsertCommand(mixed $table, array $data)
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$data | array | data to be inserted (column name=>column value). If a key is not a valid column name, the corresponding value will be ignored. |
{return} | CDbCommand | insert command |
public function createInsertCommand($table,$data)
{
$this->ensureTable($table);
$fields=array();
$values=array();
$placeholders=array();
$i=0;
foreach($data as $name=>$value)
{
if(($column=$table->getColumn($name))!==null && ($value!==null || $column->allowNull))
{
$fields[]=$column->rawName;
if($value instanceof CDbExpression)
{
$placeholders[]=$value->expression;
foreach($value->params as $n=>$v)
$values[$n]=$v;
}
else
{
$placeholders[]=self::PARAM_PREFIX.$i;
$values[self::PARAM_PREFIX.$i]=$column->typecast($value);
$i++;
}
}
}
if($fields===array())
{
$pks=is_array($table->primaryKey) ? $table->primaryKey : array($table->primaryKey);
foreach($pks as $pk)
{
$fields[]=$table->getColumn($pk)->rawName;
$placeholders[]=$this->getIntegerPrimaryKeyDefaultValue();
}
}
$sql="INSERT INTO {$table->rawName} (".implode(', ',$fields).') VALUES ('.implode(', ',$placeholders).')';
$command=$this->_connection->createCommand($sql);
foreach($values as $name=>$value)
$command->bindValue($name,$value);
return $command;
}
Creates an INSERT command.
public CDbCommand createMultipleInsertCommand(mixed $table, array $data)
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$data | array | list data to be inserted, each value should be an array in format (column name=>column value). If a key is not a valid column name, the corresponding value will be ignored. |
{return} | CDbCommand | multiple insert command |
public function createMultipleInsertCommand($table,array $data)
{
return $this->composeMultipleInsertCommand($table,$data);
}
Creates a multiple INSERT command. This method could be used to achieve better performance during insertion of the large amount of data into the database tables.
public string createPkCondition(mixed $table, array $values, string $prefix=NULL)
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$values | array | list of primary key values to be selected within |
$prefix | string | column prefix (ended with dot). If null, it will be the table name |
{return} | string | the expression for selection |
public function createPkCondition($table,$values,$prefix=null)
{
$this->ensureTable($table);
return $this->createInCondition($table,$table->primaryKey,$values,$prefix);
}
Generates the expression for selecting rows of specified primary key values.
public CDbCriteria createPkCriteria(mixed $table, mixed $pk, mixed $condition='', array $params=array (
), string $prefix=NULL)
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$pk | mixed | primary key value(s). Use array for multiple primary keys. For composite key, each key value must be an array (column name=>column value). |
$condition | mixed | query condition or criteria. If a string, it is treated as query condition; If an array, it is treated as the initial values for constructing a CDbCriteria; Otherwise, it should be an instance of CDbCriteria. |
$params | array | parameters to be bound to an SQL statement. This is only used when the second parameter is a string (query condition). In other cases, please use CDbCriteria::params to set parameters. |
$prefix | string | column prefix (ended with dot). If null, it will be the table name |
{return} | CDbCriteria | the created query criteria |
public function createPkCriteria($table,$pk,$condition='',$params=array(),$prefix=null)
{
$this->ensureTable($table);
$criteria=$this->createCriteria($condition,$params);
if($criteria->alias!='')
$prefix=$this->_schema->quoteTableName($criteria->alias).'.';
if(!is_array($pk)) // single key
$pk=array($pk);
if(is_array($table->primaryKey) && !isset($pk[0]) && $pk!==array()) // single composite key
$pk=array($pk);
$condition=$this->createInCondition($table,$table->primaryKey,$pk,$prefix);
if($criteria->condition!='')
$criteria->condition=$condition.' AND ('.$criteria->condition.')';
else
$criteria->condition=$condition;
return $criteria;
}
Creates a query criteria with the specified primary key.
public string createSearchCondition(mixed $table, array $columns, mixed $keywords, string $prefix=NULL, boolean $caseSensitive=true)
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$columns | array | list of column names for potential search condition. |
$keywords | mixed | search keywords. This can be either a string with space-separated keywords or an array of keywords. |
$prefix | string | optional column prefix (with dot at the end). If null, the table name will be used as the prefix. |
$caseSensitive | boolean | whether the search is case-sensitive. Defaults to true. |
{return} | string | SQL search condition matching on a set of columns. An empty string is returned if either the column array or the keywords are empty. |
public function createSearchCondition($table,$columns,$keywords,$prefix=null,$caseSensitive=true)
{
$this->ensureTable($table);
if(!is_array($keywords))
$keywords=preg_split('/\s+/u',$keywords,-1,PREG_SPLIT_NO_EMPTY);
if(empty($keywords))
return '';
if($prefix===null)
$prefix=$table->rawName.'.';
$conditions=array();
foreach($columns as $name)
{
if(($column=$table->getColumn($name))===null)
throw new CDbException(Yii::t('yii','Table "{table}" does not have a column named "{column}".',
array('{table}'=>$table->name,'{column}'=>$name)));
$condition=array();
foreach($keywords as $keyword)
{
$keyword='%'.strtr($keyword,array('%'=>'\%', '_'=>'\_', '\\'=>'\\\\')).'%';
if($caseSensitive)
$condition[]=$prefix.$column->rawName.' LIKE '.$this->_connection->quoteValue($keyword);
else
$condition[]='LOWER('.$prefix.$column->rawName.') LIKE LOWER('.$this->_connection->quoteValue($keyword).')';
}
$conditions[]=implode(' AND ',$condition);
}
return '('.implode(' OR ',$conditions).')';
}
Generates the expression for searching the specified keywords within a list of columns. The search expression is generated using the 'LIKE' SQL syntax. Every word in the keywords must be present and appear in at least one of the columns.
public CDbCommand createSqlCommand(string $sql, array $params=array (
))
| ||
$sql | string | the explicitly specified SQL statement |
$params | array | parameters that will be bound to the SQL statement |
{return} | CDbCommand | the created command |
public function createSqlCommand($sql,$params=array())
{
$command=$this->_connection->createCommand($sql);
$this->bindValues($command,$params);
return $command;
}
Creates a command based on a given SQL statement.
public CDbCommand createUpdateCommand(mixed $table, array $data, CDbCriteria $criteria)
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$data | array | list of columns to be updated (name=>value) |
$criteria | CDbCriteria | the query criteria |
{return} | CDbCommand | update command. |
public function createUpdateCommand($table,$data,$criteria)
{
$this->ensureTable($table);
$fields=array();
$values=array();
$bindByPosition=isset($criteria->params[0]);
$i=0;
foreach($data as $name=>$value)
{
if(($column=$table->getColumn($name))!==null)
{
if($value instanceof CDbExpression)
{
$fields[]=$column->rawName.'='.$value->expression;
foreach($value->params as $n=>$v)
$values[$n]=$v;
}
elseif($bindByPosition)
{
$fields[]=$column->rawName.'=?';
$values[]=$column->typecast($value);
}
else
{
$fields[]=$column->rawName.'='.self::PARAM_PREFIX.$i;
$values[self::PARAM_PREFIX.$i]=$column->typecast($value);
$i++;
}
}
}
if($fields===array())
throw new CDbException(Yii::t('yii','No columns are being updated for table "{table}".',
array('{table}'=>$table->name)));
$sql="UPDATE {$table->rawName} SET ".implode(', ',$fields);
$sql=$this->applyJoin($sql,$criteria->join);
$sql=$this->applyCondition($sql,$criteria->condition);
$sql=$this->applyOrder($sql,$criteria->order);
$sql=$this->applyLimit($sql,$criteria->limit,$criteria->offset);
$command=$this->_connection->createCommand($sql);
$this->bindValues($command,array_merge($values,$criteria->params));
return $command;
}
Creates an UPDATE command.
public CDbCommand createUpdateCounterCommand(mixed $table, array $counters, CDbCriteria $criteria)
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
$counters | array | counters to be updated (counter increments/decrements indexed by column names.) |
$criteria | CDbCriteria | the query criteria |
{return} | CDbCommand | the created command |
public function createUpdateCounterCommand($table,$counters,$criteria)
{
$this->ensureTable($table);
$fields=array();
foreach($counters as $name=>$value)
{
if(($column=$table->getColumn($name))!==null)
{
$value=(float)$value;
if($value<0)
$fields[]="{$column->rawName}={$column->rawName}-".(-$value);
else
$fields[]="{$column->rawName}={$column->rawName}+".$value;
}
}
if($fields!==array())
{
$sql="UPDATE {$table->rawName} SET ".implode(', ',$fields);
$sql=$this->applyJoin($sql,$criteria->join);
$sql=$this->applyCondition($sql,$criteria->condition);
$sql=$this->applyOrder($sql,$criteria->order);
$sql=$this->applyLimit($sql,$criteria->limit,$criteria->offset);
$command=$this->_connection->createCommand($sql);
$this->bindValues($command,$criteria->params);
return $command;
}
else
throw new CDbException(Yii::t('yii','No counter columns are being updated for table "{table}".',
array('{table}'=>$table->name)));
}
Creates an UPDATE command that increments/decrements certain columns.
protected void ensureTable(mixed &$table)
| ||
$table | mixed | table schema (CDbTableSchema) or table name (string). If this refers to a valid table name, this parameter will be returned with the corresponding table schema. |
protected function ensureTable(&$table)
{
if(is_string($table) && ($table=$this->_schema->getTable($tableName=$table))===null)
throw new CDbException(Yii::t('yii','Table "{table}" does not exist.',
array('{table}'=>$tableName)));
}
Checks if the parameter is a valid table schema. If it is a string, the corresponding table schema will be retrieved.
public CDbConnection getDbConnection()
| ||
{return} | CDbConnection | database connection. |
public function getDbConnection()
{
return $this->_connection;
}
protected string getIntegerPrimaryKeyDefaultValue()
| ||
{return} | string | default value of the integer/serial primary key. |
protected function getIntegerPrimaryKeyDefaultValue()
{
return 'NULL';
}
Returns default value of the integer/serial primary key. Default value means that the next autoincrement/sequence value would be used.
public mixed getLastInsertID(mixed $table)
| ||
$table | mixed | the table schema (CDbTableSchema) or the table name (string). |
{return} | mixed | last insertion id. Null is returned if no sequence name. |
public function getLastInsertID($table)
{
$this->ensureTable($table);
if($table->sequenceName!==null)
return $this->_connection->getLastInsertID($table->sequenceName);
else
return null;
}
Returns the last insertion ID for the specified table.
public CDbSchema getSchema()
| ||
{return} | CDbSchema | the schema for this command builder. |
public function getSchema()
{
return $this->_schema;
}
Signup or Login in order to comment.