Specify the table for this query using the from() method. You can specify the table name as a simple string. Zend_Db_Select applies identifier quoting around the table name, so you can use special characters.

<?php

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

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

?>

You can also specify the correlation name (sometimes called the "table alias") for a table. Instead of a simple string, use an associative array mapping the correlation name to the table name. In other clauses of the SQL query, use this correlation name. If your query joins more than one table, Zend_Db_Select generates unique correlation names based on the table names, for any tables for which you don't specify the correlation name.

<?php

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

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

?>

Some RDBMS brands support a leading schema specifier for a table. You can specify the table name as "schemaName.tableName". Zend_Db_Select quotes each part individually.

<?php

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

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

?>

In the second argument of the from() method, you can specify the columns to select from the respective table. If you specify no columns, the default is "*", the SQL wildcard for "all columns".

You can list the columns in a simple array of strings, or as an associative mapping of column alias to column name. If you only have one column to query, and you don't need to specify a column alias, you can list it as a plain string instead of an array.

You can specify the column name as "correlationName.columnName". Zend_Db_Select quotes each part individually. If you don't specify a correlation name for a column, it uses the correlation name for the table named in the current from() method.

<?php

// 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'));

?>

Columns in SQL queries are sometimes expressions, not simply column names from a table. Expressions should not have correlation names or quoting applied. If your column string contains parentheses, Zend_Db_Select recognizes it as an expression.

You also can create an object of type Zend_Db_Expr explicitly, to prevent a string from being treated as a column name. Zend_Db_Expr is a minimal class that contains a single string. Zend_Db_Select recognizes objects of type Zend_Db_Expr and converts them back to string, but does not apply any alterations, such as quoting or correlation names.

	Note
	Using Zend_Db_Expr for column names is not necessary if your column expression contains parentheses; Zend_Db_Select recognizes parentheses and treats the string as an expression, skipping quoting and correlation names.

<?php

// 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')));

?>

In the cases above, Zend_Db_Select does not alter the string to apply correlation names or identifier quoting. If those changes are necessary to resolve ambiguity, you must make the changes manually in the string.

If your column names are SQL keywords or contain special characters, you should use the Adapter's quoteIdentifier() method and interpolate the result into the string. The quoteIdentifier() method uses SQL quoting to delimit the identifier, which makes it clear that it is an identifier for a table or a column, and not any other part of SQL syntax.

Your code is more database-independent if you use the quoteIdentifier() method instead of typing quotes literally in your string, because some RDBMS brands use nonstandard symbols for quoting identifiers. The quoteIdentifier() method is designed to use the appropriate quoting symbols based on the adapter type. The quoteIdentifier() method also escapes any quote characters that appear within the identifier name itself.

<?php

// Build this query, quoting a 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)'));

?>

Many useful queries involve using a JOIN to combine rows from multiple tables. You can add tables to a Zend_Db_Select query using the join() method. Using this method is similar to the from() method, except you can also specify a join condition in most cases.

<?php

// 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');

?>

The second argument to join() is a string that is the join condition. This is an expression that declares the criteria by which rows in one table match rows in the the other table. You can use correlation names in this expression.

	Note
	No quoting is applied to the expression you specify for the join condition; if you have column names that need to be quoted, you must use quoteIdentifier() as you form the string for the join condition.

The third argument to join() is an array of column names, like that used in the from() method. It defaults to "*", supports correlation names, expressions, and Zend_Db_Expr in the same way as the array of column names in the from() method.

To select no columns from a table, use an empty array for the list of columns. This usage works in the from() method too, but typically you want some columns from the primary table in your queries, whereas you might want no columns from a joined table.

<?php

// 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 has several types of joins. See the list below for the methods to support different join types in Zend_Db_Select.

You can specify criteria for restricting rows of the result set using the where() method. The first argument of this method is a SQL expression, and this expression is used in a SQL WHERE clause in the query.

<?php

// 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');

?>

	Note
	No quoting is applied to expressions given to the where() or orWhere() methods. If you have column names that need to be quoted, you must use quoteIdentifier() as you form the string for the condition.

The second argument to the where() method is optional. It is a value to substitute into the expression. Zend_Db_Select quotes the value and substitutes it for a question-mark ("?") symbol in the expression.

This method accepts only one parameter. If you have an expression into which you need to substitute multiple variables, you must format the string manually, interpolating variables and performing quoting yourself.

<?php

// 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);

?>

You can invoke the where() method multiple times on the same Zend_Db_Select object. The resulting query combines the multiple terms together using AND between them.

<?php

// 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);

?>

If you need to combine terms together using OR, use the orWhere() method. This method is used in the same way as the where() method, except that the term specified is preceded by OR, instead of AND.

<?php

// 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 automatically puts parentheses around each expression you specify using the where() or orWhere() methods. This helps to ensure that Boolean operator precedence does not cause unexpected results.

<?php

// 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);

?>

In the example above, the results would be quite different without the parentheses, because AND has higher precedence than OR. Zend_Db_Select applies the parentheses so the effect is that each expression in successive calls to the where() bind more tightly than the AND that combines the expressions.

In SQL, the GROUP BY clause allows you to reduce the rows of a query result set to one row per unique value found in the column(s) named in the GROUP BY clause.

In Zend_Db_Select, you can specify the column(s) to use for calculating the groups of rows using the group() method. The argument to this method is a column or an array of columns to use in the GROUP BY clause.

<?php

// 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');

?>

Like the columns array in the from() method, you can use correlation names in the column name strings, and the column is quoted as an identifier unless the string contains parentheses or is an object of type Zend_Db_Expr.

In SQL, the HAVING clause applies a restriction condition on groups of rows. This is similar to how a WHERE clause applies a restriction condition on rows. But the two clauses are different because WHERE conditions are applied before groups are defined, whereas HAVING conditions are applied after groups are defined.

In Zend_Db_Select, you can specify conditions for restricting groups using the having() method. Its usage is similar to that of the where() method. The first argument is a string containing a SQL expression. The optional second argument is a value that is used to replace a positional parameter placeholder in the SQL expression. Expressions given in multiple invocations of the having() method are combined using the Boolean AND operator, or the OR operator if you use the orHaving() method.

<?php

// 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');

?>

	Note
	No quoting is applied to expressions given to the having() or orHaving() methods. If you have column names that need to be quoted, you must use quoteIdentifier() as you form the string for the condition.

In SQL, the ORDER BY clause specifies one or more columns or expressions by which the result set of a query is sorted. If multiple columns are listed, the secondary columns are used to resolve ties; the sort order is determined by the secondary columns if the preceding columns contain identical values. The default sorting is from least value to greatest value. You can also sort by greatest value to least value for a given column in the list by specifying the keyword DESC after that column.

In Zend_Db_Select, you can use the order() method to specify a column or an array of columns by which to sort. Each element of the array is a string naming a column. optionally with the ASC DESC keyword following it, separated by a space.

Like in the from() and group() methods, column names are quoted as identifiers, unless they contain contain parentheses or are an object of type Zend_Db_Expr.

<?php

// 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'));

?>

Some RDBMS brands extend SQL with a query clause known as the LIMIT clause. This clause reduces the number of rows in the result set to at most a number you specify. You can also specify to skip a number of rows before starting to output. This feature makes it easy to take a subset of a result set, for example when displaying query results on progressive pages of output.

In Zend_Db_Select, you can use the limit() method to specify the count of rows and the number of rows to skip. The first argument to this method is the desired count of rows. The second argument is the number of rows to skip.

<?php

// 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'))
    ->limit(10, 20);

?>

	Note
	The LIMIT syntax is not supported by all RDBMS brands. Some RDBMS require different syntax to support similar functionality. Each Zend_Db_Adapter_Abstract class includes a method to produce SQL appropriate for that RDBMS.

The distinct() method enables you to add the DISTINCT keyword to your SQL query.

<?php

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

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

?>

The forUpdate() method enables you to add the FOR UPDATE modifier to your SQL query.

<?php

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

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

?>

You can execute the query represented by the Zend_Db_Select object by passing it as the first argument to the query() method of a Zend_Db_Adapter_Abstract object. Use the Zend_Db_Select objects instead of a string query.

The query() method returns an object of type Zend_Db_Statement or PDOStatement, depending on the adapter type.

<?php

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

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

?>

As an alternative to using the query() method of the adapter object, you can use the query() method of the Zend_Db_Select object. Both methods return an object of type Zend_Db_Statement or PDOStatement, depending on the adapter type.

<?php

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

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

?>

If you need access to a string representation of the SQL query corresponding to the Zend_Db_Select object, use the __toString() method.

<?php

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

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

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

?>

The getPart() method returns a representation of one part of your SQL query. For example, you can use this method to return the array of expressions for the WHERE clause, or the array of columns (or column expressions) that are in the SELECT list, or the values of the count and offset for the LIMIT clause.

The return value is not a string containing a fragment of SQL syntax. The return value is an internal representation, which is typically an array structure containing values and expressions. Each part of the query has a different structure.

The single argument to the getPart() method is a string that identifies which part of the Select query to return. For example, the string 'from' identifies the part of the Select object that stores information about the tables in the FROM clause, including joined tables.

The Zend_Db_Select class defines constants you can use for parts of the SQL query. You can use these constant definitions, or you can the literal strings.

<?php

$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 );

?>

The reset() method enables you to clear one specified part of the SQL query, or else clear all parts of the SQL query if you omit the argument.

The single argument is optional. You can specify the part of the query to clear, using the same strings you used in the argument to the getPart() method. The part of the query you specify is reset to a default state.

If you omit the parameter, reset() changes all parts of the query to their default state. This makes the Zend_Db_Select object equivalent to a new object, as though you had just instantiated it.

<?php

// 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();

?>