Puede crear una instancia de un adaptador usando su constructor. El constructor de un adaptador toma un argumento, que es un array de parámetros usados para declarar la conexión.

$db = new Zend_Db_Adapter_Pdo_Mysql(array(
    'host'     => '127.0.0.1',
    'username' => 'webuser',
    'password' => 'xxxxxxxx',
    'dbname'   => 'test'
));

Como alternativa al uso directo de un constructor de adaptador, puede crear una instancia de un adaptador usando el método estático Zend_Db::factory(). Este método carga dinámicamente el archivo de la clase adaptadora bajo demanda usando Zend_Loader::loadClass().

El primer argumento es una cadena que nombra la parte base del nombre de la clase adaptadora. Por ejemplo, la cadena 'Pdo_Mysql' corresponde a la clase Zend_Db_Adapter_Pdo_Mysql. El segundo argumento es el mismo array de parámetros que habría entregado al constructor del adaptador.

// No necesitamos la siguiente sentencia porque el
// archivo Zend_Db_Adapter_Pdo_Mysql será cargado por nosotros mediante el
// método de fábrica de Zend_Db.

// require_once 'Zend/Db/Adapter/Pdo/Mysql.php';

// Cargar automáticamente la clase Zend_Db_Adapter_Pdo_Mysql
// y crear una instancia de ella.
$db = Zend_Db::factory('Pdo_Mysql', array(
    'host'     => '127.0.0.1',
    'username' => 'webuser',
    'password' => 'xxxxxxxx',
    'dbname'   => 'test'
));

Si crea su propia clase que extienda Zend_Db_Adapter_Abstract, pero no nombra su clase con el prefijo de paquete "Zend_Db_Adapter", puede usar el método factory() para cargar su adaptador si especifica la parte inicial de la clase adaptadora con la clave 'adapterNamespace' en el array de parámetros.

// No necesitamos cargar el archivo de la clase adaptadora
// porque será cargado por nosotros mediante el método de fábrica de Zend_Db.

// Cargar automáticamente la clase MyProject_Db_Adapter_Pdo_Mysql y crear
// una instancia de ella.
$db = Zend_Db::factory('Pdo_Mysql', array(
    'host'             => '127.0.0.1',
    'username'         => 'webuser',
    'password'         => 'xxxxxxxx',
    'dbname'           => 'test',
    'adapterNamespace' => 'MyProject_Db_Adapter'
));

Opcionalmente, puede especificar cualquiera de los argumentos del método factory() como un objeto de tipo Zend_Config.

Si el primer argumento es un objeto de configuración, se espera que contenga una propiedad llamada adapter, que contenga la cadena que nombra la parte base del nombre de la clase adaptadora. Opcionalmente, el objeto puede contener una propiedad llamada params, con subpropiedades correspondientes a los nombres de parámetros del adaptador. Esto solo se utiliza si el segundo argumento del método factory() está ausente.

$config = new Zend_Config(
    array(
        'database' => array(
            'adapter' => 'Mysqli',
            'params'  => array(
                'host'     => '127.0.0.1',
                'dbname'   => 'test',
                'username' => 'webuser',
                'password' => 'secret',
            )
        )
    )
);

$db = Zend_Db::factory($config->database);

El segundo argumento del método factory() puede ser un array asociativo que contenga entradas correspondientes a los parámetros del adaptador. Este argumento es opcional. Si el primer argumento es de tipo Zend_Config, se asume que contiene todos los parámetros, y el segundo argumento se ignora.

La siguiente lista explica los parámetros comunes reconocidos por las clases adaptadoras de Zend_Db.

$options = array(
    Zend_Db::CASE_FOLDING => Zend_Db::CASE_UPPER
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'options'        => $options
);

$db = Zend_Db::factory('Db2', $params);

$options = array(
    Zend_Db::AUTO_QUOTE_IDENTIFIERS => false
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'options'        => $options
);

$db = Zend_Db::factory('Pdo_Mysql', $params);

$pdoParams = array(
    PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'driver_options' => $pdoParams
);

$db = Zend_Db::factory('Pdo_Mysql', $params);

echo $db->getConnection()
        ->getAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY);

$options = array(
    Zend_Db::ALLOW_SERIALIZATION => false
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'options'        => $options
);

$db = Zend_Db::factory('Pdo_Mysql', $params);

Crear una instancia de una clase Adapter no conecta inmediatamente al servidor RDBMS. El Adapter guarda los parámetros de conexión, y establece la conexión real bajo demanda, la primera vez que necesita ejecutar una consulta. Esto garantiza que crear un objeto Adapter sea rápido y económico. Puede crear una instancia de un Adapter incluso si no está seguro de que necesite ejecutar alguna consulta de base de datos durante la solicitud actual que su aplicación está atendiendo.

Si necesita forzar al Adapter a conectarse al RDBMS, use el método getConnection(). Este método devuelve un objeto para la conexión tal como lo representa la respectiva extensión de base de datos PHP. Por ejemplo, si usa cualquiera de las clases Adapter para controladores PDO, entonces getConnection() devuelve el objeto PDO, después de iniciarlo como una conexión activa a la base de datos específica.

Puede ser útil forzar la conexión si desea capturar cualquier excepción que lance como resultado de credenciales de cuenta no válidas, u otro fallo al conectarse al servidor RDBMS. Estas excepciones no se lanzan hasta que se establece la conexión, por lo que puede ayudar a simplificar el código de su aplicación si maneja las excepciones en un solo lugar, en lugar de en el momento de la primera consulta contra la base de datos.

Adicionalmente, un adaptador puede serializarse para almacenarlo, por ejemplo, en una variable de sesión. Esto puede ser muy útil no solo para el adaptador en sí, sino para otros objetos que lo agregan, como un objeto Zend_Db_Select. Por defecto, se permite serializar los adaptadores; si no lo desea, debería considerar pasar la opción Zend_Db::ALLOW_SERIALIZATION con FALSE, vea el ejemplo anterior. Para respetar el principio de conexiones perezosas, el adaptador no se reconectará por sí mismo después de ser deserializado. Debe entonces llamar usted mismo a getConnection(). Puede hacer que el adaptador se reconecte automáticamente pasando Zend_Db::AUTO_RECONNECT_ON_UNSERIALIZE con TRUE como opción del adaptador.

try {
    $db = Zend_Db::factory('Pdo_Mysql', $parameters);
    $db->getConnection();
} catch (Zend_Db_Adapter_Exception $e) {
    // quizás una credencial de acceso fallida, o quizás el RDBMS no está en ejecución
} catch (Zend_Exception $e) {
    // quizás factory() no pudo cargar la clase Adapter especificada
}

Puede ejecutar una consulta SQL SELECT y recuperar sus resultados en un solo paso usando el método fetchAll().

El primer argumento de este método es una cadena que contiene una sentencia SELECT. Alternativamente, el primer argumento puede ser un objeto de la clase Zend_Db_Select. El Adapter convierte automáticamente este objeto a una representación en cadena de la sentencia SELECT.

El segundo argumento de fetchAll() es un array de valores para sustituir los marcadores de posición de parámetros en la sentencia SQL.

$sql = 'SELECT * FROM bugs WHERE bug_id = ?';

$result = $db->fetchAll($sql, 2);

Por defecto, fetchAll() devuelve un array de filas, cada una de las cuales es un array asociativo. Las claves del array asociativo son las columnas o alias de columna nombrados en la consulta select.

Puede especificar un estilo diferente de obtención de resultados usando el método setFetchMode(). Los modos soportados se identifican mediante constantes:

$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchAll('SELECT * FROM bugs WHERE bug_id = ?', 2);

// $result es un array de objetos
echo $result[0]->bug_description;

El método fetchAssoc() devuelve los datos en un array de arrays asociativos, sin importar qué valor haya establecido para el modo de obtención, usando la primera columna como índice del array.

$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchAssoc(
    'SELECT bug_id, bug_description, bug_status FROM bugs'
);

// $result es un array de arrays asociativos, a pesar del modo de obtención
echo $result[2]['bug_description']; // Descripción del Bug #2
echo $result[1]['bug_description']; // Descripción del Bug #1

El método fetchCol() devuelve los datos en un array de valores, sin importar el valor que haya establecido para el modo de obtención. Esto solo devuelve la primera columna devuelta por la consulta. Cualquier otra columna devuelta por la consulta se descarta. Si necesita devolver una columna distinta de la primera, vea esta sección.

$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchCol(
    'SELECT bug_description, bug_id FROM bugs WHERE bug_id = ?', 2);

// contiene bug_description; bug_id no se devuelve
echo $result[0];

El método fetchPairs() devuelve los datos en un array de pares clave-valor, como un array asociativo con una sola entrada por fila. La clave de este array asociativo se toma de la primera columna devuelta por la consulta SELECT. El valor se toma de la segunda columna devuelta por la consulta SELECT. Cualquier otra columna devuelta por la consulta se descarta.

Debería diseñar la consulta SELECT de modo que la primera columna devuelta tenga valores únicos. Si hay valores duplicados en la primera columna, las entradas en el array asociativo se sobrescribirán.

$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchPairs('SELECT bug_id, bug_status FROM bugs');

echo $result[2];

El método fetchRow() devuelve los datos usando el modo de obtención actual, pero devuelve solo la primera fila obtenida del conjunto de resultados.

$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchRow('SELECT * FROM bugs WHERE bug_id = 2');

// note que $result es un solo objeto, no un array de objetos
echo $result->bug_description;

El método fetchOne() es como una combinación de fetchRow() con fetchCol(), en el sentido de que devuelve datos solo de la primera fila obtenida del conjunto de resultados, y devuelve solo el valor de la primera columna de esa fila. Por lo tanto, devuelve solo un único valor escalar, no un array ni un objeto.

$result = $db->fetchOne('SELECT bug_status FROM bugs WHERE bug_id = 2');

// este es un único valor de cadena
echo $result;

Puede añadir nuevas filas a una tabla de su base de datos usando el método insert(). El primer argumento es una cadena que nombra la tabla, y el segundo argumento es un array asociativo, que asigna nombres de columna a valores de datos.

$data = array(
    'created_on'      => '2007-03-22',
    'bug_description' => 'Something wrong',
    'bug_status'      => 'NEW'
);

$db->insert('bugs', $data);

Las columnas que excluya del array de datos no se especifican a la base de datos. Por lo tanto, siguen las mismas reglas que sigue una sentencia SQL INSERT: si la columna tiene una cláusula DEFAULT, la columna toma ese valor en la fila creada; en caso contrario, la columna queda en estado NULL.

Por defecto, los valores en su array de datos se insertan usando parámetros. Esto reduce el riesgo de algunos tipos de problemas de seguridad. No necesita aplicar escape o entrecomillado a los valores en el array de datos.

Podría necesitar que los valores en el array de datos se traten como expresiones SQL, en cuyo caso no deben entrecomillarse. Por defecto, todos los valores de datos pasados como cadenas se tratan como literales de cadena. Para especificar que el valor es una expresión SQL y por lo tanto no debe entrecomillarse, pase el valor en el array de datos como un objeto de tipo Zend_Db_Expr en lugar de una cadena simple.

$data = array(
    'created_on'      => new Zend_Db_Expr('CURDATE()'),
    'bug_description' => 'Something wrong',
    'bug_status'      => 'NEW'
);

$db->insert('bugs', $data);

Algunas marcas de RDBMS admiten claves primarias autoincrementales. Una tabla definida de esta manera genera un valor de clave primaria automáticamente durante un INSERT de una nueva fila. El valor de retorno del método insert() no es el último ID insertado, porque la tabla podría no tener una columna autoincremental. En su lugar, el valor de retorno es el número de filas afectadas (normalmente 1).

Si su tabla está definida con una clave primaria autoincremental, puede llamar al método lastInsertId() después de la inserción. Este método devuelve el último valor generado en el ámbito de la conexión actual a la base de datos.

$db->insert('bugs', $data);

// devuelve el último valor generado por una columna autoincremental
$id = $db->lastInsertId();

Algunas marcas de RDBMS admiten un objeto de secuencia, que genera valores únicos para servir como valores de clave primaria. Para admitir secuencias, el método lastInsertId() acepta dos argumentos de cadena opcionales. Estos argumentos nombran la tabla y la columna, asumiendo que ha seguido la convención de que una secuencia se nombra usando los nombres de la tabla y la columna para los que la secuencia genera valores, y un sufijo "_seq". Esto se basa en la convención usada por PostgreSQL al nombrar secuencias para columnas SERIAL. Por ejemplo, una tabla "bugs" con columna de clave primaria "bug_id" usaría una secuencia llamada "bugs_bug_id_seq".

$db->insert('bugs', $data);

// devuelve el último valor generado por la secuencia 'bugs_bug_id_seq'.
$id = $db->lastInsertId('bugs', 'bug_id');

// alternativamente, devuelve el último valor generado por la secuencia 'bugs_seq'.
$id = $db->lastInsertId('bugs');

Si el nombre de su objeto de secuencia no sigue esta convención de nomenclatura, use el método lastSequenceId() en su lugar. Este método toma un único argumento de cadena, que nombra la secuencia literalmente.

$db->insert('bugs', $data);

// devuelve el último valor generado por la secuencia 'bugs_id_gen'.
$id = $db->lastSequenceId('bugs_id_gen');

Para las marcas de RDBMS que no admiten secuencias, incluyendo MariaDB, MySQL, Microsoft SQL Server, y SQLite, los argumentos del método lastInsertId() se ignoran, y el valor devuelto es el valor más reciente generado para cualquier tabla mediante operaciones INSERT durante la conexión actual. Para estas marcas de RDBMS, el método lastSequenceId() siempre devuelve NULL.

¿Por qué no usar "SELECT MAX(id) FROM table"?

A veces esta consulta devuelve el valor de clave primaria más reciente insertado en la tabla. Sin embargo, esta técnica no es segura de usar en un entorno donde múltiples clientes están insertando registros en la base de datos. Es posible, y por lo tanto está destinado a suceder eventualmente, que otro cliente inserte otra fila en el instante entre la inserción realizada por su aplicación cliente y su consulta para el valor MAX(id). Por lo tanto, el valor devuelto no identifica la fila que insertó, identifica la fila insertada por algún otro cliente. No hay forma de saber cuándo ha ocurrido esto. Usar un modo de aislamiento de transacciones fuerte como "repeatable read" puede mitigar este riesgo, pero algunas marcas de RDBMS no admiten el aislamiento de transacciones requerido para esto, o bien su aplicación puede usar un modo de aislamiento de transacciones más bajo por diseño. Además, usar una expresión como "MAX(id)+1" para generar un nuevo valor para una clave primaria no es seguro, porque dos clientes podrían realizar esta consulta simultáneamente, y luego ambos usar el mismo valor calculado para su siguiente operación INSERT. Todas las marcas de RDBMS proporcionan mecanismos para generar valores únicos, y para devolver el último valor generado. Estos mecanismos necesariamente funcionan fuera del ámbito del aislamiento de transacciones, por lo que no hay posibilidad de que dos clientes generen el mismo valor, y no hay posibilidad de que el valor generado por otro cliente se informe a la conexión de su cliente como el último valor generado.

Puede actualizar filas en una tabla de base de datos usando el método update() de un Adapter. Este método toma tres argumentos: el primero es el nombre de la tabla; el segundo es un array asociativo que asigna columnas por cambiar a nuevos valores a asignar a estas columnas.

Los valores en el array de datos se tratan como literales de cadena. Vea esta sección para información sobre el uso de expresiones SQL en el array de datos.

El tercer argumento es una cadena que contiene una expresión SQL que se usa como criterio para las filas a cambiar. Los valores e identificadores en este argumento no se entrecomillan ni se escapan. Usted es responsable de asegurar que cualquier contenido dinámico se interpole en esta cadena de forma segura. Vea esta sección para conocer métodos que le ayuden a hacer esto.

El valor de retorno es el número de filas afectadas por la operación de actualización.

$data = array(
    'updated_on'      => '2007-03-23',
    'bug_status'      => 'FIXED'
);

$n = $db->update('bugs', $data, 'bug_id = 2');

Si omite el tercer argumento, entonces todas las filas en la tabla de la base de datos se actualizan con los valores especificados en el array de datos.

Si proporciona un array de cadenas como tercer argumento, estas cadenas se unen como términos en una expresión separados por operadores AND.

Si proporciona un array de arrays como tercer argumento, los valores se entrecomillarán automáticamente en las claves. Estos luego se unirán como términos, separados por operadores AND.

$data = array(
    'updated_on'      => '2007-03-23',
    'bug_status'      => 'FIXED'
);

$where[] = "reported_by = 'goofy'";
$where[] = "bug_status = 'OPEN'";

$n = $db->update('bugs', $data, $where);

// El SQL resultante es:
//  UPDATE "bugs" SET "update_on" = '2007-03-23', "bug_status" = 'FIXED'
//  WHERE ("reported_by" = 'goofy') AND ("bug_status" = 'OPEN')

$data = array(
    'updated_on'      => '2007-03-23',
    'bug_status'      => 'FIXED'
);

$where['reported_by = ?'] = 'goofy';
$where['bug_status = ?']  = 'OPEN';

$n = $db->update('bugs', $data, $where);

// El SQL resultante es:
//  UPDATE "bugs" SET "update_on" = '2007-03-23', "bug_status" = 'FIXED'
//  WHERE ("reported_by" = 'goofy') AND ("bug_status" = 'OPEN')

Puede eliminar filas de una tabla de base de datos usando el método delete(). Este método toma dos argumentos: el primero es una cadena que nombra la tabla.

El segundo argumento es una cadena que contiene una expresión SQL que se usa como criterio para las filas a eliminar. Los valores e identificadores en este argumento no se entrecomillan ni se escapan. Usted es responsable de asegurar que cualquier contenido dinámico se interpole en esta cadena de forma segura. Vea esta sección para conocer métodos que le ayuden a hacer esto.

El valor de retorno es el número de filas afectadas por la operación de eliminación.

$n = $db->delete('bugs', 'bug_id = 3');

Si omite el segundo argumento, el resultado es que se eliminan todas las filas de la tabla de la base de datos.

Si proporciona un array de cadenas como segundo argumento, estas cadenas se unen como términos en una expresión separados por operadores AND.

Si proporciona un array de arrays como segundo argumento, los valores se entrecomillarán automáticamente en las claves. Estos luego se unirán como términos, separados por operadores AND.

El método quote() acepta un único argumento, un valor de cadena escalar. Devuelve el valor con caracteres especiales escapados de manera apropiada para el RDBMS que esté usando, y rodeado por delimitadores de valor de cadena. El delimitador de valor de cadena SQL estándar es la comilla simple (').

$name = $db->quote("O'Reilly");
echo $name;
// 'O\'Reilly'

$sql = "SELECT * FROM bugs WHERE reported_by = $name";

echo $sql;
// SELECT * FROM bugs WHERE reported_by = 'O\'Reilly'

Tenga en cuenta que el valor de retorno de quote() incluye los delimitadores de comilla alrededor de la cadena. Esto es diferente de algunas funciones que escapan caracteres especiales pero no añaden los delimitadores de comilla, por ejemplo mysql_real_escape_string().

Los valores pueden necesitar entrecomillarse o no según el contexto de tipo de dato SQL en el que se usen. Por ejemplo, en algunas marcas de RDBMS, un valor entero no debe entrecomillarse como cadena si se compara con una columna o expresión de tipo entero. En otras palabras, lo siguiente es un error en algunas implementaciones SQL, asumiendo que intColumn tiene un tipo de dato SQL de INTEGER

SELECT * FROM atable WHERE intColumn = '123'

Puede usar el segundo argumento opcional del método quote() para aplicar el entrecomillado de forma selectiva para el tipo de dato SQL que especifique.

$value = '1234';
$sql = 'SELECT * FROM atable WHERE intColumn = '
     . $db->quote($value, 'INTEGER');

Cada clase Zend_Db_Adapter ha codificado los nombres de los tipos de datos SQL numéricos para la respectiva marca de RDBMS. También puede usar las constantes Zend_Db::INT_TYPE, Zend_Db::BIGINT_TYPE, y Zend_Db::FLOAT_TYPE para escribir código de una manera más independiente del RDBMS.

Zend_Db_Table especifica los tipos SQL a quote() automáticamente al generar consultas SQL que hacen referencia a las columnas clave de una tabla.

El uso más típico del entrecomillado es interpolar una variable PHP en una expresión o sentencia SQL. Puede usar el método quoteInto() para hacer esto en un solo paso. Este método toma dos argumentos: el primer argumento es una cadena que contiene un símbolo de marcador de posición (?), y el segundo argumento es un valor o variable PHP que debe sustituirse por ese marcador de posición.

El símbolo de marcador de posición es el mismo símbolo usado por muchas marcas de RDBMS para parámetros posicionales, pero el método quoteInto() solo emula parámetros de consulta. El método simplemente interpola el valor en la cadena, escapa caracteres especiales, y aplica comillas alrededor de él. Los verdaderos parámetros de consulta mantienen la separación entre la cadena SQL y los parámetros a medida que la sentencia se analiza en el servidor RDBMS.

$sql = $db->quoteInto("SELECT * FROM bugs WHERE reported_by = ?", "O'Reilly");

echo $sql;
// SELECT * FROM bugs WHERE reported_by = 'O\'Reilly'

Puede usar el tercer parámetro opcional de quoteInto() para especificar el tipo de dato SQL. Los tipos de datos numéricos no se entrecomillan, y otros tipos sí.

$sql = $db
    ->quoteInto("SELECT * FROM bugs WHERE bug_id = ?", '1234', 'INTEGER');

echo $sql;
// SELECT * FROM bugs WHERE reported_by = 1234

Los valores no son la única parte de la sintaxis SQL que podría necesitar ser variable. Si usa variables PHP para nombrar tablas, columnas, u otros identificadores en sus sentencias SQL, podría necesitar entrecomillar también estas cadenas. Por defecto, los identificadores SQL tienen reglas de sintaxis similares a PHP y a la mayoría de otros lenguajes de programación. Por ejemplo, los identificadores no deben contener espacios, cierta puntuación o caracteres especiales, o caracteres internacionales. Además, ciertas palabras están reservadas para la sintaxis SQL, y no deben usarse como identificadores.

Sin embargo, SQL tiene una característica llamada identificadores delimitados, que permite opciones más amplias para la escritura de identificadores. Si encierra un identificador SQL entre el tipo apropiado de comillas, puede usar identificadores con formas que serían inválidas sin las comillas. Los identificadores delimitados pueden contener espacios, puntuación, o caracteres internacionales. También puede usar palabras reservadas SQL si las encierra en delimitadores de identificador.

El método quoteIdentifier() funciona como quote(), pero aplica los caracteres delimitadores de identificador a la cadena según el tipo de Adapter que use. Por ejemplo, el SQL estándar usa comillas dobles (") para delimitadores de identificador, y la mayoría de las marcas de RDBMS usan ese símbolo. MySQL usa comillas invertidas (`) por defecto. El método quoteIdentifier() también escapa caracteres especiales dentro del argumento de cadena.

// podríamos tener un nombre de tabla que sea una palabra reservada de SQL
$tableName = $db->quoteIdentifier("order");

$sql = "SELECT * FROM $tableName";

echo $sql
// SELECT * FROM "order"

Los identificadores delimitados SQL son sensibles a mayúsculas/minúsculas, a diferencia de los identificadores sin comillas. Por lo tanto, si usa identificadores delimitados, debe usar la escritura del identificador exactamente como está almacenada en su esquema, incluyendo las mayúsculas y minúsculas de las letras.

En la mayoría de los casos en que se genera SQL dentro de las clases Zend_Db, el valor por defecto es que todos los identificadores se delimitan automáticamente. Puede cambiar este comportamiento con la opción Zend_Db::AUTO_QUOTE_IDENTIFIERS. Especifique esto al instanciar el Adapter. Vea este ejemplo.