Especifique la tabla de esta consulta usando el método from(). Puede especificar el nombre de la tabla como una cadena simple. Zend_Db_Select aplica entrecomillado de identificador alrededor del nombre de la tabla, de modo que puede usar caracteres especiales.

// Build this query:
//   SELECT *
//   FROM "products"

$select = $db->select()
             ->from( 'products' );

También puede especificar el nombre de correlación (a veces llamado el "alias de tabla") de una tabla. En lugar de una cadena simple, use un array asociativo que asigne el nombre de correlación al nombre de la tabla. En otras cláusulas de la consulta SQL, use este nombre de correlación. Si su consulta une más de una tabla, Zend_Db_Select genera nombres de correlación únicos basados en los nombres de las tablas, para cualquier tabla para la que no especifique el nombre de correlación.

// Build this query:
//   SELECT p.*
//   FROM "products" AS p

$select = $db->select()
             ->from( array('p' => 'products') );

Algunas marcas de RDBMS admiten un especificador de esquema delante de una tabla. Puede especificar el nombre de la tabla como "schemaName.tableName", donde Zend_Db_Select entrecomilla cada parte por separado, o puede especificar el nombre del esquema por separado. Un nombre de esquema especificado en el nombre de la tabla tiene precedencia sobre un esquema proporcionado por separado en caso de que se proporcionen ambos.

// Build this query:
//   SELECT *
//   FROM "myschema"."products"

$select = $db->select()
             ->from( 'myschema.products' );

// or

$select = $db->select()
             ->from('products', '*', 'myschema');

En el segundo argumento del método from(), puede especificar las columnas que se seleccionarán de la tabla respectiva. Si no especifica ninguna columna, el valor predeterminado es "*", el comodín SQL para "todas las columnas".

Puede listar las columnas en un array simple de cadenas, o como una asignación asociativa de alias de columna a nombre de columna. Si solo tiene una columna que consultar, y no necesita especificar un alias de columna, puede listarla como una cadena simple en lugar de un array.

Si proporciona un array vacío como argumento de columnas, no se incluye ninguna columna de la tabla respectiva en el conjunto de resultados. Vea un ejemplo de código en la sección sobre el método join().

Puede especificar el nombre de columna como "correlationName.columnName". Zend_Db_Select entrecomilla cada parte por separado. Si no especifica un nombre de correlación para una columna, se usa el nombre de correlación de la tabla nombrada en el método from() actual.

// Build this query:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'product_name'));

// Build the same query, specifying correlation names:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('p.product_id', 'p.product_name'));

// Build this query with an alias for one column:
//   SELECT p."product_id" AS prodno, p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('prodno' => 'product_id', 'product_name'));

Las columnas en las consultas SQL a veces son expresiones, no simplemente nombres de columna de una tabla. A las expresiones no se les debe aplicar nombres de correlación ni entrecomillado. Si su cadena de columna contiene paréntesis, Zend_Db_Select la reconoce como una expresión.

También puede crear un objeto de tipo Zend_Db_Expr explícitamente, para evitar que una cadena sea tratada como un nombre de columna. Zend_Db_Expr es una clase mínima que contiene una única cadena. Zend_Db_Select reconoce objetos de tipo Zend_Db_Expr y los convierte de nuevo a cadena, pero no aplica ninguna alteración, como entrecomillado o nombres de correlación.

	Nota
	Usar Zend_Db_Expr para nombres de columna no es necesario si su expresión de columna contiene paréntesis; Zend_Db_Select reconoce los paréntesis y trata la cadena como una expresión, omitiendo el entrecomillado y los nombres de correlación.

// Build this query:
//   SELECT p."product_id", LOWER(product_name)
//   FROM "products" AS p
// An expression with parentheses implicitly becomes
// a Zend_Db_Expr.

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'LOWER(product_name)'));

// Build this query:
//   SELECT p."product_id", (p.cost * 1.08) AS cost_plus_tax
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id',
                          'cost_plus_tax' => '(p.cost * 1.08)')
                   );

// Build this query using Zend_Db_Expr explicitly:
//   SELECT p."product_id", p.cost * 1.08 AS cost_plus_tax
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id',
                          'cost_plus_tax' =>
                              new Zend_Db_Expr('p.cost * 1.08'))
                    );

En los casos anteriores, Zend_Db_Select no altera la cadena para aplicar nombres de correlación o entrecomillado de identificador. Si esos cambios son necesarios para resolver ambigüedad, debe hacer los cambios manualmente en la cadena.

Si sus nombres de columna son palabras clave SQL o contienen caracteres especiales, debería usar el método quoteIdentifier() del Adaptador e interpolar el resultado en la cadena. El método quoteIdentifier() usa el entrecomillado SQL para delimitar el identificador, lo que deja claro que es un identificador para una tabla o una columna, y no cualquier otra parte de la sintaxis SQL.

Su código es más independiente de la base de datos si usa el método quoteIdentifier() en lugar de escribir comillas literalmente en su cadena, porque algunas marcas de RDBMS usan símbolos no estándar para entrecomillar identificadores. El método quoteIdentifier() está diseñado para usar los símbolos de entrecomillado apropiados según el tipo de adaptador. El método quoteIdentifier() también escapa cualquier carácter de comilla que aparezca dentro del propio nombre del identificador.

// Build this query,
// quoting the special column name "from" in the expression:
//   SELECT p."from" + 10 AS origin
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('origin' =>
                              '(p.' . $db->quoteIdentifier('from') . ' + 10)')
                   );

Puede haber casos en los que desee añadir columnas a una tabla FROM o JOIN existente después de que se hayan llamado esos métodos. El método columns() le permite añadir columnas específicas en cualquier momento antes de que se ejecute la consulta. Puede proporcionar las columnas como una cadena o Zend_Db_Expr, o como un array de estos elementos. El segundo argumento de este método puede omitirse, lo que implica que las columnas se añadirán a la tabla FROM; de lo contrario, debe usarse un nombre de correlación existente.

// Build this query:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'), 'product_id')
             ->columns('product_name');

// Build the same query, specifying correlation names:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'), 'p.product_id')
             ->columns('product_name', 'p');
             // Alternatively use columns('p.product_name')

Muchas consultas útiles implican usar un JOIN para combinar filas de varias tablas. Puede añadir tablas a una consulta Zend_Db_Select usando el método join(). Usar este método es similar a usar el método from(), excepto que también puede especificar una condición de unión en la mayoría de los casos.

// Build this query:
//   SELECT p."product_id", p."product_name", l.*
//   FROM "products" AS p JOIN "line_items" AS l
//     ON p.product_id = l.product_id

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'product_name'))
             ->join(array('l' => 'line_items'),
                    'p.product_id = l.product_id');

El segundo argumento de join() es una cadena que es la condición de unión. Esta es una expresión que declara los criterios por los cuales las filas de una tabla coinciden con las filas de la otra tabla. Puede usar nombres de correlación en esta expresión.

	Nota
	No se aplica ningún entrecomillado a la expresión que especifica para la condición de unión; si tiene nombres de columna que necesitan ser entrecomillados, debe usar quoteIdentifier() al formar la cadena para la condición de unión.

El tercer argumento de join() es un array de nombres de columna, como el usado en el método from(). El valor predeterminado es "*", y admite nombres de correlación, expresiones y Zend_Db_Expr de la misma manera que el array de nombres de columna en el método from().

Para no seleccionar ninguna columna de una tabla, use un array vacío como lista de columnas. Este uso también funciona en el método from(), pero normalmente desea algunas columnas de la tabla principal en sus consultas, mientras que podría no querer ninguna columna de una tabla unida.

// Build this query:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p JOIN "line_items" AS l
//     ON p.product_id = l.product_id

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'product_name'))
             ->join(array('l' => 'line_items'),
                    'p.product_id = l.product_id',
                    array() ); // empty list of columns

SQL tiene varios tipos de uniones. Vea la lista siguiente para los métodos que admiten distintos tipos de unión en Zend_Db_Select.

Además de estos métodos de unión, puede simplificar sus consultas usando los métodos JoinUsing. En lugar de proporcionar una condición completa a su unión, simplemente pasa el nombre de la columna por la que unir y el objeto Zend_Db_Select completa la condición por usted.

// Build this query:
//   SELECT *
//   FROM "table1"
//   JOIN "table2"
//   ON "table1".column1 = "table2".column1
//   WHERE column2 = 'foo'

$select = $db->select()
             ->from('table1')
             ->joinUsing('table2', 'column1')
             ->where('column2 = ?', 'foo');

Cada uno de los métodos de unión aplicables en el componente Zend_Db_Select tiene un método 'using' correspondiente.

Puede especificar criterios para restringir las filas del conjunto de resultados usando el método where(). El primer argumento de este método es una expresión SQL, y esta expresión se usa en una cláusula SQL WHERE de la consulta.

// Build this query:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE price > 100.00

$select = $db->select()
             ->from('products',
                    array('product_id', 'product_name', 'price'))
             ->where('price > 100.00');

	Nota
	No se aplica ningún entrecomillado a las expresiones proporcionadas a los métodos where() u orWhere(). Si tiene nombres de columna que necesitan ser entrecomillados, debe usar quoteIdentifier() al formar la cadena para la condición.

El segundo argumento del método where() es opcional. Es un valor que se sustituye en la expresión. Zend_Db_Select entrecomilla el valor y lo sustituye por un símbolo de interrogación ("?") en la expresión.

// Build this query:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE (price > 100.00)

$minimumPrice = 100;

$select = $db->select()
             ->from('products',
                    array('product_id', 'product_name', 'price'))
             ->where('price > ?', $minimumPrice);

Puede pasar un array como segundo parámetro al método where() cuando use el operador SQL IN.

// Build this query:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE (product_id IN (1, 2, 3))

$productIds = array(1, 2, 3);

$select = $db->select()
             ->from('products',
                    array('product_id', 'product_name', 'price'))
             ->where('product_id IN (?)', $productIds);

Puede invocar el método where() varias veces en el mismo objeto Zend_Db_Select. La consulta resultante combina los múltiples términos usando AND entre ellos.

// Build this query:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE (price > 100.00)
//     AND (price < 500.00)

$minimumPrice = 100;
$maximumPrice = 500;

$select = $db->select()
             ->from('products',
                    array('product_id', 'product_name', 'price'))
             ->where('price > ?', $minimumPrice)
             ->where('price < ?', $maximumPrice);

Si necesita combinar términos usando OR, use el método orWhere(). Este método se usa de la misma manera que el método where(), excepto que el término especificado va precedido de OR, en lugar de AND.

// Build this query:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE (price < 100.00)
//     OR (price > 500.00)

$minimumPrice = 100;
$maximumPrice = 500;

$select = $db->select()
             ->from('products',
                    array('product_id', 'product_name', 'price'))
             ->where('price < ?', $minimumPrice)
             ->orWhere('price > ?', $maximumPrice);

Zend_Db_Select pone automáticamente paréntesis alrededor de cada expresión que especifique usando los métodos where() u orWhere(). Esto ayuda a garantizar que la precedencia de operadores booleanos no cause resultados inesperados.

// Build this query:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE (price < 100.00 OR price > 500.00)
//     AND (product_name = 'Apple')

$minimumPrice = 100;
$maximumPrice = 500;
$prod = 'Apple';

$select = $db->select()
             ->from('products',
                    array('product_id', 'product_name', 'price'))
             ->where("price < $minimumPrice OR price > $maximumPrice")
             ->where('product_name = ?', $prod);

En el ejemplo anterior, los resultados serían bastante diferentes sin los paréntesis, porque AND tiene mayor precedencia que OR. Zend_Db_Select aplica los paréntesis de modo que el efecto es que cada expresión en llamadas sucesivas a where() se une más estrechamente que el AND que combina las expresiones.

En SQL, la cláusula GROUP BY le permite reducir las filas de un conjunto de resultados de consulta a una fila por cada valor único encontrado en las columnas nombradas en la cláusula GROUP BY.

En Zend_Db_Select, puede especificar las columnas a usar para calcular los grupos de filas usando el método group(). El argumento de este método es una columna o un array de columnas a usar en la cláusula GROUP BY.

// Build this query:
//   SELECT p."product_id", COUNT(*) AS line_items_per_product
//   FROM "products" AS p JOIN "line_items" AS l
//     ON p.product_id = l.product_id
//   GROUP BY p.product_id

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id'))
             ->join(array('l' => 'line_items'),
                    'p.product_id = l.product_id',
                    array('line_items_per_product' => 'COUNT(*)'))
             ->group('p.product_id');

Al igual que en el array de columnas del método from(), puede usar nombres de correlación en las cadenas de nombre de columna, y la columna se entrecomilla como identificador a menos que la cadena contenga paréntesis o sea un objeto de tipo Zend_Db_Expr.

En SQL, la cláusula HAVING aplica una condición de restricción sobre grupos de filas. Esto es similar a cómo una cláusula WHERE aplica una condición de restricción sobre filas. Pero las dos cláusulas son diferentes porque las condiciones WHERE se aplican antes de que se definan los grupos, mientras que las condiciones HAVING se aplican después de que se definan los grupos.

En Zend_Db_Select, puede especificar condiciones para restringir grupos usando el método having(). Su uso es similar al del método where(). El primer argumento es una cadena que contiene una expresión SQL. El segundo argumento opcional es un valor que se usa para reemplazar un marcador de posición de parámetro posicional en la expresión SQL. Las expresiones proporcionadas en varias invocaciones del método having() se combinan usando el operador booleano AND, o el operador OR si usa el método orHaving().

// Build this query:
//   SELECT p."product_id", COUNT(*) AS line_items_per_product
//   FROM "products" AS p JOIN "line_items" AS l
//     ON p.product_id = l.product_id
//   GROUP BY p.product_id
//   HAVING line_items_per_product > 10

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id'))
             ->join(array('l' => 'line_items'),
                    'p.product_id = l.product_id',
                    array('line_items_per_product' => 'COUNT(*)'))
             ->group('p.product_id')
             ->having('line_items_per_product > 10');

	Nota
	No se aplica ningún entrecomillado a las expresiones proporcionadas a los métodos having() u orHaving(). Si tiene nombres de columna que necesitan ser entrecomillados, debe usar quoteIdentifier() al formar la cadena para la condición.

En SQL, la cláusula ORDER BY especifica una o más columnas o expresiones por las que se ordena el conjunto de resultados de una consulta. Si se listan varias columnas, las columnas secundarias se usan para resolver empates; el orden de clasificación se determina por las columnas secundarias si las columnas precedentes contienen valores idénticos. La ordenación predeterminada es de menor a mayor valor. También puede ordenar de mayor a menor valor para una columna dada en la lista especificando la palabra clave DESC después de esa columna.

En Zend_Db_Select, puede usar el método order() para especificar una columna o un array de columnas por las que ordenar. Cada elemento del array es una cadena que nombra una columna, opcionalmente seguida de la palabra clave ASC DESC, separada por un espacio.

Al igual que en los métodos from() y group(), los nombres de columna se entrecomillan como identificadores, a menos que contengan paréntesis o sean un objeto de tipo Zend_Db_Expr.

// Build this query:
//   SELECT p."product_id", COUNT(*) AS line_items_per_product
//   FROM "products" AS p JOIN "line_items" AS l
//     ON p.product_id = l.product_id
//   GROUP BY p.product_id
//   ORDER BY "line_items_per_product" DESC, "product_id"

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id'))
             ->join(array('l' => 'line_items'),
                    'p.product_id = l.product_id',
                    array('line_items_per_product' => 'COUNT(*)'))
             ->group('p.product_id')
             ->order(array('line_items_per_product DESC',
                           'product_id'));

Algunas marcas de RDBMS extienden SQL con una cláusula de consulta conocida como la cláusula LIMIT. Esta cláusula reduce el número de filas en el conjunto de resultados a lo sumo a un número que usted especifique. También puede especificar que se omita un número de filas antes de empezar a mostrar el resultado. Esta característica facilita tomar un subconjunto de un conjunto de resultados, por ejemplo al mostrar resultados de consulta en páginas progresivas de salida.

En Zend_Db_Select, puede usar el método limit() para especificar el número de filas y el número de filas a omitir. El primer argumento de este método es el número de filas deseado. El segundo argumento es el número de filas a omitir.

// Build this query:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p
//   LIMIT 10, 20
// Equivalent to:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p
//   LIMIT 20 OFFSET 10

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'product_name'))
             ->limit(20, 10);

	Nota
	La sintaxis LIMIT no es admitida por todas las marcas de RDBMS. Algunos RDBMS requieren una sintaxis diferente para admitir una funcionalidad similar. Cada clase Zend_Db_Adapter_Abstract incluye un método para producir el SQL apropiado para ese RDBMS.

Use el método limitPage() como una forma alternativa de especificar el número de filas y el desplazamiento. Este método le permite limitar el conjunto de resultados a uno de una serie de subconjuntos de longitud fija de filas del conjunto de resultados total de la consulta. En otras palabras, especifica la longitud de una "página" de resultados, y el número ordinal de la única página de resultados que desea que la consulta devuelva. El número de página es el primer argumento del método limitPage(), y la longitud de página es el segundo argumento. Ambos argumentos son obligatorios; no tienen valores predeterminados.

// Build this query:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p
//   LIMIT 10, 20

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'product_name'))
             ->limitPage(2, 10);

El método distinct() le permite añadir la palabra clave DISTINCT a su consulta SQL.

// Build this query:
//   SELECT DISTINCT p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->distinct()
             ->from(array('p' => 'products'), 'product_name');

El método forUpdate() le permite añadir el modificador FOR UPDATE a su consulta SQL.

// Build this query:
//   SELECT FOR UPDATE p.*
//   FROM "products" AS p

$select = $db->select()
             ->forUpdate()
             ->from(array('p' => 'products'));

Puede construir consultas de unión con Zend_Db_Select pasando un array de objetos Zend_Db_Select o cadenas de consulta SQL al método union(). Como segundo parámetro puede pasar las constantes Zend_Db_Select::SQL_UNION o Zend_Db_Select::SQL_UNION_ALL para especificar qué tipo de unión desea realizar.

$sql1 = $db->select();
$sql2 = "SELECT ...";

$select = $db->select()
    ->union(array($sql1, $sql2))
    ->order("id");

Puede ejecutar la consulta representada por el objeto Zend_Db_Select pasándola como primer argumento al método query() de un objeto Zend_Db_Adapter_Abstract. Use objetos Zend_Db_Select en lugar de una consulta en forma de cadena.

El método query() devuelve un objeto de tipo Zend_Db_Statement o PDOStatement, según el tipo de adaptador.

$select = $db->select()
             ->from('products');

$stmt = $db->query($select);
$result = $stmt->fetchAll();

Como alternativa a usar el método query() del objeto adaptador, puede usar el método query() del objeto Zend_Db_Select. Ambos métodos devuelven un objeto de tipo Zend_Db_Statement o PDOStatement, según el tipo de adaptador.

$select = $db->select()
             ->from('products');

$stmt = $select->query();
$result = $stmt->fetchAll();

Si necesita acceso a una representación en cadena de la consulta SQL correspondiente al objeto Zend_Db_Select, use el método __toString().

$select = $db->select()
             ->from('products');

$sql = $select->__toString();
echo "$sql\n";

// The output is the string:
//   SELECT * FROM "products"

El método getPart() devuelve una representación de una parte de su consulta SQL. Por ejemplo, puede usar este método para devolver el array de expresiones de la cláusula WHERE, o el array de columnas (o expresiones de columna) que están en la lista SELECT, o los valores del número de filas y el desplazamiento para la cláusula LIMIT.

El valor de retorno no es una cadena que contenga un fragmento de sintaxis SQL. El valor de retorno es una representación interna, que normalmente es una estructura de array que contiene valores y expresiones. Cada parte de la consulta tiene una estructura diferente.

El único argumento del método getPart() es una cadena que identifica qué parte de la consulta Select se debe devolver. Por ejemplo, la cadena 'from' identifica la parte del objeto Select que almacena información sobre las tablas en la cláusula FROM, incluidas las tablas unidas.

La clase Zend_Db_Select define constantes que puede usar para partes de la consulta SQL. Puede usar estas definiciones de constantes, o puede usar las cadenas literales.

$select = $db->select()
             ->from('products')
             ->order('product_id');

// You can use a string literal to specify the part
$orderData = $select->getPart( 'order' );

// You can use a constant to specify the same part
$orderData = $select->getPart( Zend_Db_Select::ORDER );

// The return value may be an array structure, not a string.
// Each part has a different structure.
print_r( $orderData );

El método reset() le permite borrar una parte especificada de la consulta SQL, o bien borrar todas las partes de la consulta SQL si omite el argumento.

El único argumento es opcional. Puede especificar la parte de la consulta que se debe borrar, usando las mismas cadenas que usó en el argumento del método getPart(). La parte de la consulta que especifique se restablece a un estado predeterminado.

Si omite el parámetro, reset() cambia todas las partes de la consulta a su estado predeterminado. Esto hace que el objeto Zend_Db_Select sea equivalente a un objeto nuevo, como si lo acabara de instanciar.

// Build this query:
//   SELECT p.*
//   FROM "products" AS p
//   ORDER BY "product_name"

$select = $db->select()
             ->from(array('p' => 'products')
             ->order('product_name');

// Changed requirement, instead order by a different columns:
//   SELECT p.*
//   FROM "products" AS p
//   ORDER BY "product_id"

// Clear one part so we can redefine it
$select->reset( Zend_Db_Select::ORDER );

// And specify a different column
$select->order('product_id');

// Clear all parts of the query
$select->reset();