Allow the use of different database servers using the same code base.
Backdrop includes a database abstraction layer to provide a structured interface for dynamically constructing queries when appropriate, and to enforce security checks and similar good practices. The intent of this layer is to preserve the syntax and power of SQL as much as possible, but also allow developers to leverage more complex functionality in a unified way.
The system is built atop PHP's PDO (PHP Data Objects) database API and inherits much of its syntax and semantics.
Most Backdrop database SELECT queries are performed by a call to db_query() or db_query_range(). Module authors should also consider using the PagerDefault Extender for queries that return results that need to be presented on multiple pages (see https://drupal.org/node/508796), and the TableSort Extender for generating appropriate queries for sortable tables (see https://drupal.org/node/1848372).
For example, one might wish to return a list of the most recent 10 nodes authored by a given user. Instead of directly issuing the SQL query
SELECT n.nid, n.title, n.created FROM node n WHERE n.uid = $uid
ORDER BY n.created DESC LIMIT 0, 10;
one would instead call the Backdrop functions:
$result = db_query_range('SELECT n.nid, n.title, n.created
FROM {node} n WHERE n.uid = :uid
ORDER BY n.created DESC', 0, 10, array(':uid' => $uid));
foreach ($result as $record) {
// Perform operations on $record->title, etc. here.
}
Curly braces are used around "node" to provide table prefixing via DatabaseConnection::prefixTables(). The explicit use of a user ID is pulled out into an argument passed to db_query() so that SQL injection attacks from user input can be caught and nullified. The LIMIT syntax varies between database servers, so that is abstracted into db_query_range() arguments. Finally, note the PDO-based ability to iterate over the result set using foreach ().
All queries are passed as a prepared statement string. A prepared statement is a "template" of a query that omits literal or variable values in favor of placeholders. The values to place into those placeholders are passed separately, and the database driver handles inserting the values into the query in a secure fashion. That means you should never quote or string-escape a value to be inserted into the query.
There are two formats for placeholders: named and unnamed. Named placeholders are strongly preferred in all cases as they are more flexible and self-documenting. Named placeholders should start with a colon ":" and can be followed by one or more letters, numbers or underscores.
Named placeholders begin with a colon followed by a unique string. Example:
SELECT nid, title FROM {node} WHERE uid=:uid;
":uid" is a placeholder that will be replaced with a literal value when the query is executed. A given placeholder label cannot be repeated in a given query, even if the value should be the same. When using named placeholders, the array of arguments to the query must be an associative array where keys are a placeholder label (e.g., :uid) and the value is the corresponding value to use. The array may be in any order.
Unnamed placeholders are represented by a question mark. For example:
SELECT nid, title FROM {node} WHERE uid=?;
In this case, the array of arguments must be an indexed array of values to use in the exact same order as the placeholders in the query.
Note that placeholders should be a "complete" value. For example, when running a LIKE query the SQL wildcard character, %, should be part of the value, not the query itself. Thus, the following is incorrect:
SELECT nid, title FROM {node} WHERE title LIKE :title%;
It should instead read:
SELECT nid, title FROM {node} WHERE title LIKE :title;
and the value for :title should include a % as appropriate. Again, note the lack of quotation marks around :title. Because the value is not inserted into the query as one big string but as an explicitly separate value, the database server knows where the query ends and a value begins. That is considerably more secure against SQL injection than trying to remember which values need quotation marks and string escaping and which don't.
INSERT, UPDATE, and DELETE queries need special care in order to behave consistently across all different databases. Therefore, they use a special object-oriented API for defining a query structurally. For example, rather than:
INSERT INTO node (nid, title, body) VALUES (1, 'my title', 'my body');
one would instead write:
$fields = array('nid' => 1, 'title' => 'my title', 'body' => 'my body');
db_insert('node')->fields($fields)->execute();
This method allows databases that need special data type handling to do so, while also allowing optimizations such as multi-insert queries. UPDATE and DELETE queries have a similar pattern.
Backdrop also supports transactions, including a transparent fallback for databases that do not support transactions. To start a new transaction, call $txn = db_transaction(); in your own code. The transaction will remain open for as long as the variable $txn remains in scope. When $txn is destroyed, the transaction will be committed. If your transaction is nested inside of another then Backdrop will track each transaction and only commit the outer-most transaction when the last transaction object goes out out of scope, that is, all relevant queries completed successfully.
Example:
function my_transaction_function() {
// The transaction opens here.
$txn = db_transaction();
try {
$id = db_insert('example')
->fields(array(
'field1' => 'mystring',
'field2' => 5,
))
->execute();
my_other_function($id);
return $id;
}
catch (Exception $e) {
// Something went wrong somewhere, so roll back now.
$txn->rollback();
// Log the exception to watchdog.
watchdog_exception('type', $e);
}
// $txn goes out of scope here. Unless the transaction was rolled back, it
// gets automatically committed here.
}
function my_other_function($id) {
// The transaction is still open here.
if ($id % 2 == 0) {
db_update('example')
->condition('id', $id)
->fields(array('field2' => 10))
->execute();
}
}
See also
http://drupal.org/developing/api/database
File
- core/
includes/ database/ database.inc, line 11 - Core systems for the database layer.
Functions
Name |
Location | Description |
|---|---|---|
| db_and |
core/ |
Returns a new DatabaseCondition, set to "AND" all conditions together. |
| db_close |
core/ |
Closes the active database connection. |
| db_condition |
core/ |
Returns a new DatabaseCondition, set to the specified conjunction. |
| db_delete |
core/ |
Returns a new DeleteQuery object for the active database. |
| db_driver |
core/ |
Retrieves the name of the currently active database driver. |
| db_escape_field |
core/ |
Restricts a dynamic column or constraint name to safe characters. |
| db_escape_table |
core/ |
Restricts a dynamic table name to safe characters. |
| db_insert |
core/ |
Returns a new InsertQuery object for the active database. |
| db_like |
core/ |
Escapes characters that work as wildcard characters in a LIKE pattern. |
| db_merge |
core/ |
Returns a new MergeQuery object for the active database. |
| db_next_id |
core/ |
Retrieves a unique id. |
| db_or |
core/ |
Returns a new DatabaseCondition, set to "OR" all conditions together. |
| db_query |
core/ |
Executes an arbitrary query string against the active database. |
| db_query_range |
core/ |
Executes a query against the active database, restricted to a range. |
| db_query_temporary |
core/ |
Executes a SELECT query string and saves the result set to a temporary table. |
| db_select |
core/ |
Returns a new SelectQuery object for the active database. |
| db_set_active |
core/ |
Sets a new active database. |
| db_transaction |
core/ |
Returns a new transaction object for the active database. |
| db_truncate |
core/ |
Returns a new TruncateQuery object for the active database. |
| db_update |
core/ |
Returns a new UpdateQuery object for the active database. |
| db_xor |
core/ |
Returns a new DatabaseCondition, set to "XOR" all conditions together. |
Classes
|
Name |
Location | Description |
|---|---|---|
| Database |
core/ |
Primary front-controller for the database system. |
| DatabaseCondition |
core/ |
Generic class for a series of conditions in a query. |
| DatabaseConnection |
core/ |
Base Database API class. |
| DatabaseConnectionNotDefinedException |
core/ |
Exception thrown if an undefined database connection is requested. |
| DatabaseConnection_mysql |
core/ |
|
| DatabaseDriverNotSpecifiedException |
core/ |
Exception thrown if no driver is specified for a database connection. |
| DatabaseNotFoundException |
core/ |
Exception thrown when the specified database cannot be found. |
| DatabaseStatementBase |
core/ |
Default implementation of DatabaseStatementInterface. |
| DatabaseStatementEmpty |
core/ |
Empty implementation of a database statement. |
| DatabaseStatementPrefetch |
core/ |
An implementation of DatabaseStatementInterface that prefetches all data. |
| DatabaseTransaction |
core/ |
A wrapper class for creating and managing database transactions. |
| DatabaseTransactionCommitFailedException |
core/ |
Exception thrown when a commit() function fails. |
| DatabaseTransactionExplicitCommitNotAllowedException |
core/ |
Exception to deny attempts to explicitly manage transactions. |
| DatabaseTransactionNameNonUniqueException |
core/ |
Exception thrown when a savepoint or transaction name occurs twice. |
| DatabaseTransactionNoActiveException |
core/ |
Exception for when popTransaction() is called with no active transaction. |
| DatabaseTransactionOutOfOrderException |
core/ |
Exception thrown when a rollback() resulted in other active transactions being rolled-back. |
| DeleteQuery |
core/ |
General class for an abstracted DELETE operation. |
| FieldsOverlapException |
core/ |
Exception thrown if an insert query specifies a field twice. |
| InsertQuery |
core/ |
General class for an abstracted INSERT query. |
| InsertQuery_mysql |
core/ |
|
| InvalidMergeQueryException |
core/ |
Exception thrown for merge queries that do not make semantic sense. |
| MergeQuery |
core/ |
General class for an abstracted MERGE query operation. |
| NoFieldsException |
core/ |
Exception thrown if an insert query doesn't specify insert or default fields. |
| Query |
core/ |
Base class for query builders. |
| SelectQuery |
core/ |
Query builder for SELECT statements. |
| SelectQueryExtender |
core/ |
The base extender class for Select queries. |
| TruncateQuery |
core/ |
General class for an abstracted TRUNCATE operation. |
| TruncateQuery_mysql |
core/ |
|
| UpdateQuery |
core/ |
General class for an abstracted UPDATE operation. |
Interfaces
|
Name |
Location | Description |
|---|---|---|
| DatabaseStatementInterface |
core/ |
Represents a prepared statement. |
| QueryAlterableInterface |
core/ |
Interface for a query that can be manipulated via an alter hook. |
| QueryConditionInterface |
core/ |
Interface for a conditional clause in a query. |
| QueryExtendableInterface |
core/ |
Interface for extendable query objects. |
| QueryPlaceholderInterface |
core/ |
Interface for a query that accepts placeholders. |
| SelectQueryInterface |
core/ |
Interface definition for a Select Query object. |