repo_zf1/documentation/manual/es/module_specs/Zend_Db_Select.xml

<?xml version="1.0" encoding="UTF-8"?>
    <!-- EN-Revision: 19726 -->
    <!-- Reviewed: no -->
<sect1 id="zend.db.select">

    <title>Zend_Db_Select</title>

    <sect2 id="zend.db.select.introduction">

        <title>Descripción del Objeto Select</title>

        <para>
            El objeto
            <classname>Zend_Db_Select</classname>
            object representa una declaración de
            consulta
            <acronym>SELECT</acronym>
            de
            <acronym>SQL</acronym>
            .
            La clase tiene métodos para agregar partes individuales a la
            consulta. Se pueden
            especificar algunas partes de la consulta usando
            los métodos en
            <acronym>PHP</acronym>
            y sus estructuras de datos, y
            la clase forma la sintaxis
            <acronym>SLQ</acronym>
            correcta. Después de construir la
            consulta, puede ejecutarla como si se hubiera escrito
            como un
            string.
        </para>

        <para>
            Las posibilidades de
            <classname>Zend_Db_Select</classname>
            incluyen:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    Métodos Orientados a objetos para especificar consultas
                    <acronym>SQL</acronym>
                    pieza-a-pieza;
                </para>
            </listitem>

            <listitem>
                <para>
                    Abstracción de partes de las consultas
                    <acronym>SQL</acronym>
                    , independiente de la Base de
                    datos;
                </para>
            </listitem>

            <listitem>
                <para>
                    Entrecomillado automático de identificadores de metadatos
                    en la mayoría de los
                    casos, soportanto identificadores que
                    contienen palabras reservadas de
                    <acronym>SQL</acronym>
                    y
                    caracteres especiales;
                </para>
            </listitem>

            <listitem>
                <para>
                    Entrecomillado de identificadores y valores, para ayudar
                    a reducir el riesgo de
                    ataque por inyección
                    <acronym>SQL</acronym>
                    .
                </para>
            </listitem>
        </itemizedlist>

        <para>
            El uso de
            <classname>Zend_Db_Select</classname>
            no es
            obligatorio. Para consultas
            <acronym>SELECT</acronym>
            muy simples, es usualmente más
            simple especificar la consulta completa como un string y
            ejecutarla
            usando un método del Adapter como
            <methodname>query()</methodname>
            o
            <methodname>fetchAll()</methodname>
            . Usar
            <classname>Zend_Db_Select</classname>
            es útil si se necesita
            ensamblar una consulta
            <acronym>SELECT</acronym>
            proceduralmente, o basada en
            condiciones lógicas en la aplicación.
        </para>

    </sect2>

    <sect2 id="zend.db.select.creating">

        <title>Creando un Objeto Select</title>

        <para>
            Se puede crear una instancia del objeto
            <classname>Zend_Db_Select</classname>
            usando el método
            <methodname>select()</methodname>
            de un objeto
            <classname>Zend_Db_Adapter_Abstract</classname>
            .
        </para>

        <example id="zend.db.select.creating.example-db">

            <title>Ejemplo del método select() del adaptador</title>

            <programlisting language="php"><![CDATA[
$db = Zend_Db::factory( ...options... );
$select = $db->select();
]]></programlisting>

        </example>

        <para>
            Otra manera de crear el objeto
            <classname>Zend_Db_Select</classname>
            es con su constructor,
            especificando el adaptador de base de datos como un argumento.
        </para>

        <example id="zend.db.select.creating.example-new">

            <title>Ejemplo de creación de un nuevo objeto Select</title>

            <programlisting language="php"><![CDATA[
$db = Zend_Db::factory( ...options... );
$select = new Zend_Db_Select($db);
]]></programlisting>

        </example>

    </sect2>

    <sect2 id="zend.db.select.building">

        <title>Construyendo consultas Select</title>

        <para>
            Cuando se construye una consulta, puede agregar cláusulas a ésta,
            una por una. Hay un
            método separado para agregar cada una al objeto
            <classname>Zend_Db_Select</classname>
            .
        </para>

        <example id="zend.db.select.building.example">

            <title>Ejemplo de uso de métodos que agregan cláusulas</title>

            <programlisting language="php"><![CDATA[
// Crear el objeto Zend_Db_Select
$select = $db->select();

// Agregar una cláusula FROM
$select->from( ...specify table and columns... )

// Agregar una cláusula WHERE
$select->where( ...specify search criteria... )

// Agregar una cláusula ORDER BY
$select->order( ...specify sorting criteria... );
]]></programlisting>

        </example>

        <para>
            También puede utilizar la mayoría de los métodos del objeto
            <classname>Zend_Db_Select</classname>
            con una interfaz fluida.
            Una interfaz fluida significa que cada método devuelve una
            referencia al objeto que se ha llamado, así se puede llamar
            inmediatamente a otro método.
        </para>

        <example id="zend.db.select.building.example-fluent">

            <title>Ejemplo de uso de la interfaz fluida.</title>

            <programlisting language="php"><![CDATA[
$select = $db->select()
    ->from( ...specify table and columns... )
    ->where( ...specify search criteria... )
    ->order( ...specify sorting criteria... );
]]></programlisting>

        </example>

        <para>Los ejemplos en esta sección muestran el uso de la interfaz
            fluída, pero también se
            puede usar la interfaz no-fluída en todos
            los casos. A menudo es necesario utilizar la
            interfaz no-fluída, por
            ejemplo, si su aplicación necesita realizar cierta lógica antes
            de
            añadir una cláusula a la consulta.</para>

        <sect3 id="zend.db.select.building.from">

            <title>Agregando una cláusula FROM</title>

            <para>
                Especifique la tabla para esta consulta usando el método
                <methodname>from()</methodname>
                . Se puede especificar el
                nombre de la tabla como un string.
                <classname>Zend_Db_Select</classname>
                aplica el
                identificador entrecomillando el nombre de la tabla, así puede
                utilizar
                caracteres especiales.
            </para>

            <example id="zend.db.select.building.from.example">

                <title>Ejemplo del método from()</title>

                <programlisting language="php"><![CDATA[
// Construye la consulta:
//   SELECT *
//   FROM "products"

$select = $db->select()
             ->from( 'products' );
]]></programlisting>

            </example>

            <para>
                Puede especificar un nombre de correlación (también llamado a
                veces "alias de tabla")
                para una tabla. En lugar de un string,
                se usa un array asociativo que mapee el nombre
                de correlación
                con el nombre de la tabla. En otras cláusulas de consulta
                <acronym>SQL</acronym>
                ,
                utilice nombre de correlación. Si su consulta se une con más de
                una tabla,
                <classname>Zend_Db_Select</classname>
                genera una
                correlación unica de nombres basados en el nombre de la tabla,
                para una
                tabla a la cual no se le espicifique un nombre de
                correlación.
            </para>

            <example id="zend.db.select.building.from.example-cname">

                <title>Ejemplo especificando una tabla con nombre de
                    correlación</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   SELECT p.*
//   FROM "products" AS p

$select = $db->select()
             ->from( array('p' => 'products') );
]]></programlisting>

            </example>

            <para>
                Algunos
                <acronym>RDBMS</acronym>
                apoyan el uso de un especificador de esquema
                para una tabla. Puede especificar el
                nombre de la tabla como
                "
                "<code>schemaName.tableName</code>"
                ",
                donde
                <classname>Zend_Db_Select</classname>
                entrecomillará cada
                parte individualmente, o tambien puedes especificar el nombre de
                esquema por separado. Un nombre de esquema especificado en el
                nombre de la tabla toma
                precedencia en sobre un esquema dado por
                separado en el caso de que ambos sean dados.
            </para>

            <example id="zend.db.select.building.from.example-schema">

                <title>Ejemplo especificando un nombre de esquema</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   SELECT *
//   FROM "myschema"."products"

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

// o

$select = $db->select()
             ->from('products', '*', 'myschema');
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.columns">

            <title>Agregando Columnas</title>

            <para>
                En el segundo argumento del método
                <methodname>from()</methodname>
                , puede especificar las
                columnas que seleccionar desde la tabla respectiva. Si no
                especifica columnas, por defecto será
                "
                <methodname>*</methodname>
                ", el comodín
                <acronym>SQL</acronym>
                para "todas las columnas".
            </para>

            <para>Puede listar las columnas en un simple array de strings, o en
                un array asociativo
                mapeando los alias de columnas a su nombre
                de tabla. Si solo se especifica una
                columna en la consulta y no
                necesita especificar un alias de columna, puede listarla
                solo
                con un string en lugar de un array.</para>

            <para>
                Si se entrega un array vacío como el argumento de las tablas,
                no se incluirán
                columnas en el resultado. Vea un
                <link linkend="zend.db.select.building.join.example-no-columns">código de
                    ejemplo</link>
                en la sección del método
                <methodname>join()</methodname>
                .
            </para>

            <para>
                Puedes especificar el nombre de columna como
                "
                <code>nombreCorrelacionado.nombreDeColumna</code>
                ".
                <classname>Zend_Db_Select</classname>
                entrecomillará cada
                parte individualmente. Si no especifica un nombre de correlación
                para una columna, se usará el nombre de correlación para la
                tabla nombrada en el
                método actual
                <methodname>from()</methodname>
                .
            </para>

            <example id="zend.db.select.building.columns.example">

                <title>Ejemplos especificando columnas</title>

                <programlisting language="php"><![CDATA[
// Construir esta consulta:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

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

// Construir la misma consulta, especificando nombres de correlación
//   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'));

// Construir esta consulta con una alias para una columna:
//   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'));
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.columns-expr">

            <title>Agregando una Expresión en las Columns</title>

            <para>
                Las columnas en consultas
                <acronym>SQL</acronym>
                a veces son
                expresiones, no simples columnas de una tabla. Las expresiones
                no deberían
                tener nombres de correlación o entrecomillado
                aplicado. Si sus columnas contienen
                paréntesis,
                <classname>Zend_Db_Select</classname>
                las reconoce como una
                expresión.
            </para>

            <para>
                Tambien puede crear un objeto de tipo
                <classname>Zend_Db_Expr</classname>
                explícitamente, para
                prevenir que el string sea tratado como columna.
                <classname>Zend_Db_Expr</classname>
                es una clase mínima, que
                contiene un simple string.
                <classname>Zend_Db_Select</classname>
                reconoce el objeto de tipo
                <classname>Zend_Db_Expr</classname>
                y
                lo convierte de vuelta en el string, pero no le aplica ninguna
                alteración, tal como
                el entrecomillado o la correlación de
                nombres.
            </para>

            <note>

                <para>
                    El Uso de
                    <classname>Zend_Db_Expr</classname>
                    para
                    nombres de columnas no es necesario si la expresión de la
                    columna contiene
                    paréntesis;
                    <classname>Zend_Db_Select</classname>
                    reconoce y trata
                    el string como expresión, saltándose el entrecomillado y la
                    correlación de nombres.
                </para>

            </note>

            <example id="zend.db.select.building.columns-expr.example">

                <title>Ejemplos especificando columnas que contienen
                    expresiones</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   SELECT p."product_id", LOWER(product_name)
//   FROM "products" AS p
// Una expresion con parentesis implicitamente se transforma en
// un Zend_Db_Expr.

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

// Construya esta consulta:
//   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)')
                   );

// Construya esta consulta usando Zend_Db_Expr explícitamente:
//   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'))
                    );
]]></programlisting>

            </example>

            <para>
                En los casos anteriores,
                <classname>Zend_Db_Select</classname>
                no altera el string
                para aplicar correlación de nombres o entrecomillado de
                identificadores. Si estos cambios son necesarios para resolver
                ambigüedades, deberías
                realizar cambios manualmente en el
                string.
            </para>

            <para>
                Si el nombre de su columna es alguna palabra reservada de
                <acronym>SQL</acronym>
                o contiene caracteres especiales,
                debería usar el método
                <methodname>quoteIdentifier()</methodname>
                del Adapdator e
                interpolar el resultado en un string. El método
                <methodname>quoteIdentifier()</methodname>
                usa
                entrecomillado
                <acronym>SQL</acronym>
                para delimitar el
                identificador, the identifier, dejando en claro que es un
                identificador de tabla o columna y no otra parte de la sintaxis
                <acronym>SQL</acronym>
                .
            </para>

            <para>
                Su código es más independiente de la base de datos si se usa
                el método
                <methodname>quoteIdentifier()</methodname>
                en vez de
                las excribir literalmente las comillas en la cadena, debido a
                que algunos
                <acronym>RDBMS</acronym>
                no usan simbolos estándar para entrecomillar
                identificadores. El método
                <methodname>quoteIdentifier()</methodname>
                está diseñado
                para usar los símbolos apropiados para entrecomillar basado en
                el tipo
                del adaptador. El método
                <methodname>quoteIdentifier()</methodname>
                también escapa
                cual caracter de comilla que aparezca en el nombre del
                identificador
                mismo.
            </para>

            <example id="zend.db.select.building.columns-quoteid.example">

                <title>Ejemplo de entrecomillado de columnas en una
                    expresión</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta, entrecomillando el nombre
// especial de la columna llamada "from" en la expresión:
//   SELECT p."from" + 10 AS origin
//   FROM "products" AS p

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

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.columns-atomic">

            <title>Agregar columnas a una tabla FROM o JOIN existente</title>

            <para>
                Puede haber casos en los que desea agregar columnas a una
                tabla FROM o JOIN después
                de que estos métodos han sido
                llamados. El método
                <methodname>columns()</methodname>
                permite
                agregar columnas en cualquier punto antes de ejecutar la
                consulta. Puedes
                pasar las columnas bien como un string, un
                <classname>Zend_Db_Expr</classname>
                o un array de estos
                elementos. El segundo argumento para este método puede ser
                omitido, implicando que las columnas serán agregadas a una tabla
                FROM, en otro caso
                debería usarse un nombre de correlación
                existente.
            </para>

            <example id="zend.db.select.building.columns-atomic.example">

                <title>
                    Ejemplos agregando columnas con el
                    método
                    <methodname>columns()</methodname>
                </title>

                <programlisting language="php"><![CDATA[
// Construir la consulta:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

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

// Construir la misma consulta, especificando correlación de nombres:
//   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');
             // Alternativamente puede usar columns('p.product_name')
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.join">

            <title>Agregar Otra Tabla a la Consulta Query con JOIN</title>

            <para>
                Muchas consultas útiles involucran el uso de un
                <acronym>JOIN</acronym>
                para combinar filas de
                multiples tablas. Puedes agregar tablas a una consulta
                <classname>Zend_Db_Select</classname>
                usando el método
                <methodname>join()</methodname>
                . Usar este método, es
                similar al método
                <methodname>from()</methodname>
                , excepto que
                puedes especificar una condición de unión en la mayoría de los
                casos.
            </para>

            <example id="zend.db.select.building.join.example">

                <title>Ejemplo del método join()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   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');
]]></programlisting>

            </example>

            <para>
                El segundo argumento
                <methodname>join()</methodname>
                es un
                string que es usado como condición de unión. Esta es una
                expresión que declara
                un criterio por el cual las filas en una
                tabla concuerdan con las filas de la otra
                tabla. Puedes
                especificar correlación de nombres en esta expresión.
            </para>

            <note>

                <para>
                    No se aplica entrecomillado en la expresión especificada
                    para la condición de
                    unión; si tienes problemas con nombres
                    que necesitan ser entrecomillados, deberás
                    usar
                    <methodname>quoteIdentifier()</methodname>
                    para formar
                    el string de condición de unión.
                </para>

            </note>

            <para>
                El tercer argumento
                <methodname>join()</methodname>
                es un
                array de nombres de columnas, como al usar el método
                <methodname>from()</methodname>
                . Este es por defecto
                "
                <code>*</code>
                ", soporta correlación de
                nombres, expresiones, y
                <classname>Zend_Db_Expr</classname>
                de
                la misma manera que el array de nombres de columnas en el método
                <methodname>from()</methodname>
                .
            </para>

            <para>
                Para no seleccionar columnas de una tabla, use un array vacío
                para la lista de
                columnas. El uso de esto trabaja con el método
                <methodname>from()</methodname>
                también, pero en general
                deseará algunas columnas de la tabla primaria en sus
                consultas,
                a la vez que no se desean columnas de la tabla unida.
            </para>

            <example id="zend.db.select.building.join.example-no-columns">

                <title>Ejemplo especificando ninguna columna</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   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
]]></programlisting>

                <para>
                    Note el array vacío
                    <methodname>array()</methodname>
                    en
                    el ejemplo anterior en lugar de una lista de columnas de la
                    tabla unida.
                </para>

            </example>

            <para>
                SQL tiene muchos tipos de uniones. Vea una lista a
                continuación para los métodos que
                soporta cada tipo de unión en
                <classname>Zend_Db_Select</classname>
                .
            </para>

            <itemizedlist>
                <listitem>
                    <para>
                        <command>INNER JOIN</command>
                        con los métodos
                        <methodname>join(table, join,
                            [columns])</methodname>
                        o
                        <methodname>joinInner(table, join,
                            [columns])</methodname>
                        .
                    </para>

                    <para>Éste es el tipo de unión más comun. Las filas de cada
                        tabla son comparadas
                        usando la condición de unión
                        especificada. El resultado incluye solo las
                        filas que
                        satisfacen la condición. El resultado puede ser vacío si
                        no hay
                        filas que satisfagan la condición.</para>

                    <para>
                        Todos los
                        <acronym>RDBMS</acronym>
                        soportan este tipo de unión.
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <command>LEFT JOIN</command>
                        con el método
                        <methodname>joinLeft(table, condition,
                            [columns])</methodname>
                        .
                    </para>

                    <para>Todas las filas de tabla a la izquierda del operando
                        son incluidas,
                        pareando las filas de la tabla a la
                        derecha del operando, y las columnas de
                        la tabla a la
                        derecha del operando son rellenadas con NULLs si no
                        existen
                        filas que coincidan con la tabla a la izquierda.</para>

                    <para>
                        Todos los
                        <acronym>RDBMS</acronym>
                        soportan este tipo de unión.
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <command>RIGHT JOIN</command>
                        con el método
                        <methodname>joinRight(table, condition,
                            [columns])</methodname>
                        .
                    </para>

                    <para>Unión exterior por la derecha es el complementario de
                        la unión exterior por
                        la izquierda. Todas las filas de
                        la tabla a la derecha del operando son
                        incluidas,
                        pareando las filas de la tabla a la izquierda del
                        operando
                        incluidas, y las columnas de la tabla a la
                        izquierda del operando son
                        rellenadas con NULLs si no
                        existen filas que coincidan con la tabla de la
                        derecha.</para>

                    <para>
                        Algunos
                        <acronym>RDBMS</acronym>
                        no soportan este tipo de join, pero en
                        general, cualquier unión por la
                        derecha puede
                        representarse por una unión por la izquierda invirtiendo
                        el
                        orden de las tablas.
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <command>FULL JOIN</command>
                        con el método
                        <methodname>joinFull(table, condition,
                            [columns])</methodname>
                        .
                    </para>

                    <para>Una unión externa total es como una combinación de
                        una unión exterior por
                        la izquierda y una unión exterior
                        por la derecha. Todas las filas de ambas
                        tablas son
                        incluidas, vinculadas entre sí en la misma fila si
                        satisfacen la
                        condición de unión, y en otro caso, se
                        vinculan con valores nulos en lugar de
                        columnas de la
                        otra tabla.</para>

                    <para>
                        Algunos
                        <acronym>RDBMS</acronym>
                        no soportan este tipo de unión.
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <command>CROSS JOIN</command>
                        con el método
                        <methodname>joinCross(table,
                            [columns])</methodname>
                        .
                    </para>

                    <para>
                        Una unión cruzada es un Producto Cartesiano. Cada
                        fila en la primera tabla es
                        pareada con cada una en la
                        segunda tabla. Por lo tanto, el número de filas en
                        el
                        resultado es igual al producto del número de filas en
                        cada tabla. Puede
                        filtrar el conjunto de resultados con
                        el uso de condiciones en un cláusula
                        <constant>WHERE</constant>
                        ; de esta
                        forma una unión cruzada es similar a la antigua sintaxis
                        de unión en
                        <acronym>SQL</acronym>
                        -89.
                    </para>

                    <para>
                        El método
                        <methodname>joinCross()</methodname>
                        no
                        tiene parámetros para especificar una condición de
                        unión. Algunos
                        <acronym>RDBMS</acronym>
                        S no soportan este tipo de unión.
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <command>NATURAL JOIN</command>
                        con el método
                        <methodname>joinNatural(table,
                            [columns])</methodname>
                        .
                    </para>

                    <para>
                        Una unión natural compara cualquier columa(s) que
                        aparezca con el nombre en
                        ambas tablas. La comparación
                        es el equivalente de todas las columna(s);
                        comparando
                        las columnas usando desigualdad no es una unión natural.
                        Solo la
                        unión interna natural es soportada por este API,
                        aun cuando
                        <acronym>SQL</acronym>
                        permita una unión
                        externa natural.
                    </para>

                    <para>
                        El método
                        <methodname>joinNatural()</methodname>
                        no
                        tiene parámetros para especificar una condición.
                    </para>
                </listitem>
            </itemizedlist>

            <para>
                Además de los métodos de unión, puede simplificar las
                consultas usando métodos
                JoinUsing. En vez de proveer una
                condición completa a la unión, simplemente pase el
                nombre de
                columna en la que se hará la unión y el objeto
                <classname>Zend_Db_Select</classname>
                completa la condición.
            </para>

            <example id="zend.db.select.building.joinusing.example">

                <title>Ejemplo de método joinUsing()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   SELECT *
//   FROM "table1"
//   JOIN "table2"
//   ON "table1".column1 = "table2".column1
//   WHERE column2 = 'foo'

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

            </example>

            <para>
                Cada uno de los métodos aplicables para uniones en el
                componente
                <classname>Zend_Db_Select</classname>
                tiene su
                correspondiente método 'using' (usando)
            </para>

            <itemizedlist>
                <listitem>
                    <para>
                        <methodname>joinUsing(table, join,
                            [columns])</methodname>
                        y
                        <methodname>joinInnerUsing(table, join,
                            [columns])</methodname>
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <methodname>joinLeftUsing(table, join,
                            [columns])</methodname>
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <methodname>joinRightUsing(table, join,
                            [columns])</methodname>
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <methodname>joinFullUsing(table, join,
                            [columns])</methodname>
                    </para>
                </listitem>
            </itemizedlist>

        </sect3>

        <sect3 id="zend.db.select.building.where">

            <title>Agregar una cláusula WHERE</title>

            <para>
                Puede especificar un criterio para restringir las filas de
                resultado usando el método
                <methodname>where()</methodname>
                . El
                primer argumento de este método es una expresión
                <acronym>SQL</acronym>
                , y esta expresión es usada como una
                expresión
                <acronym>SQL</acronym>
                <constant>WHERE</constant>
                en la consulta.
            </para>

            <example id="zend.db.select.building.where.example">

                <title>Ejemplo del método where()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   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');
]]></programlisting>

            </example>

            <note>

                <para>
                    No se aplica entrecomillado en una expresión dada en el
                    método
                    <methodname>where()</methodname>
                    u
                    <methodname>orWhere()</methodname>
                    . Si tiene nombres de
                    columnas que necesitan ser entrecomillados, debe usar el
                    método
                    <methodname>quoteIdentifier()</methodname>
                    para
                    formar el string de la condición.
                </para>

            </note>

            <para>
                El segundo argumento del método
                <methodname>where()</methodname>
                es opcional. Es un valor
                para sustituir en la expresión.
                <classname>Zend_Db_Select</classname>
                entrecomilla el valor
                y lo sustituye por un signo de interrogación
                ("
                <methodname>?</methodname>
                ") en la expresión.
            </para>

            <para>Este método acepta solo un parámetro. Si tiene una expresión
                en la cual necesita
                sustituir múltiples variables, deberá formar
                el string manualmente, interpolando
                variables y realizando
                entrecomillado manualmente.</para>

            <example id="zend.db.select.building.where.example-param">

                <title>Ejemplo de parámetro en el método where()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   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);
]]></programlisting>

            </example>

            <para>
                You can pass an array as the second parameter to the
                <methodname>where()</methodname>
                method when using the SQL IN operator.
            </para>

            <example id="zend.db.select.building.where.example-array">

                <title>Example of an array parameter in the where() method</title>

                <programlisting language="php"><![CDATA[
// 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);
]]></programlisting>

            </example>

            <para>
                You can invoke the
                <methodname>where()</methodname>
                method multiple times on the
                same
                <classname>Zend_Db_Select</classname>
                object. The resulting query combines the
                multiple terms together using
                <acronym>AND</acronym>
                between them.
            </para>

            <example id="zend.db.select.building.where.example-and">

                <title>Ejemplo de métodos where() múltiples</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   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);
]]></programlisting>

            </example>

            <para>
                Si necesita combinar terminos
                usando
                <acronym>OR</acronym>
                , use el método
                <methodname>orWhere()</methodname>
                . Este método se usa del
                mismo modo que el método
                <methodname>where()</methodname>
                ,
                excepto que el término especificado es precedido por
                <acronym>OR</acronym>
                , en lugar de
                <acronym>AND</acronym>
                .
            </para>

            <example id="zend.db.select.building.where.example-or">

                <title>Ejemplo del método orWhere()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   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);
]]></programlisting>

            </example>

            <para>
                <classname>Zend_Db_Select</classname>
                automáticamente pone
                paréntesis alrededor de cada expresión que especifique usando el
                método
                <methodname>where()</methodname>
                u
                <methodname>orWhere()</methodname>
                . Esto ayuda a asegurar
                que la precedencia del operador Booleano no cause resultados
                inesperados.
            </para>

            <example id="zend.db.select.building.where.example-parens">

                <title>Ejemplos de Expresiones Booleanas con paréntesis</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   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);
]]></programlisting>

            </example>

            <para>
                En el ejemplo anterior, los resultados deberían ser
                diferentes sin paréntesis, porque
                <acronym>AND</acronym>
                tiene precedencia más alta respecto a
                <acronym>OR</acronym>
                .
                <classname>Zend_Db_Select</classname>
                aplica el parentesis
                con un efecto tal que la expresión en sucesivas llamadas al
                método
                <methodname>where()</methodname>
                vincula de forma más
                fuerte el
                <acronym>AND</acronym>
                que combina las
                expresiones.
            </para>

        </sect3>

        <sect3 id="zend.db.select.building.group">

            <title>Agregando una cláusula GROUP BY</title>

            <para>
                En
                <acronym>SQL</acronym>
                , la cláusula
                <command>GROUP
                    BY</command>
                permite reducir el número de filas del
                resultado de una consulta a una fila por cada
                valor único
                encontrado en la(s) columna(s) nombrada(s) en la cláusula
                <command>GROUP BY</command>
                .
            </para>

            <para>
                En
                <classname>Zend_Db_Select</classname>
                , puede especificar
                la(s) columna(s) que usar para el cálculo de grupos de filas
                usando el método
                <methodname>group()</methodname>
                . El argumento
                de este método es una columna o un array de columnas que se
                usarán en
                la cláusula
                <command>GROUP BY</command>
                .
            </para>

            <example id="zend.db.select.building.group.example">

                <title>Ejemplo del método group()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   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');
]]></programlisting>

            </example>

            <para>
                Como el array de columnas del método
                <methodname>from()</methodname>
                , se puede usar correlación
                de nombres en el string de nombre de columna, y la
                columna será
                entrecomillada como un identificador, salvo que el string
                contenga
                paréntesis o sea un objeto de tipo
                <classname>Zend_Db_Expr</classname>
                .
            </para>

        </sect3>

        <sect3 id="zend.db.select.building.having">

            <title>Agregando una cláusula HAVING</title>

            <para>
                En
                <acronym>SQL</acronym>
                , la cláusula
                <constant>HAVING</constant>
                aplica una condición de
                restricción en grupos de filas. Es similar a una cláusula
                <constant>WHERE</constant>
                aplicando una condición de
                restricción a las filas. Pero las 2 cláusulas son
                diferentes
                porque las condiciones
                <constant>WHERE</constant>
                son
                aplicadas antes que definan los grupos, mientras que las
                condiciones
                <constant>HAVING</constant>
                son aplicadas
                después que los grupos son definidos.
            </para>

            <para>
                En
                <classname>Zend_Db_Select</classname>
                , puede especificar
                condiciones para restringir grupos usando el método
                <methodname>having()</methodname>
                . Su uso es similar al del
                método
                <methodname>where()</methodname>
                . El primer agumento es
                un string conteniendo una expresión
                <acronym>SQL</acronym>
                . El
                segundo argumento es un valor que es usado para reemplazar un
                parámetro marcador
                de posición en la expresión
                <acronym>SQL</acronym>
                . Las expresiones dadas en multiples
                invocaciones al método
                <methodname>having()</methodname>
                son
                combinadas usando el operador Booleano
                <methodname>AND</methodname>
                , o el operador
                <code>OR</code>
                si usa el método
                <methodname>orHaving()</methodname>
                .
            </para>

            <example id="zend.db.select.building.having.example">

                <title>Ejemplo del método having()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   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');
]]></programlisting>

            </example>

            <note>

                <para>
                    No se aplica entrecomillado a expresiones dadas al método
                    <methodname>having()</methodname>
                    u
                    <methodname>orHaving()</methodname>
                    . Si tiene nombres de
                    columnas que deban ser entrecomillados, deberá usar
                    <methodname>quoteIdentifier()</methodname>
                    para formar
                    el string de la condición.
                </para>

            </note>

        </sect3>

        <sect3 id="zend.db.select.building.order">

            <title>Agregar una cláusula ORDER BY</title>

            <para>
                En
                <acronym>SQL</acronym>
                , la cláusula
                <code>ORDER
                    BY</code>
                especifica una o más columnas o expresiones
                por el cual el resultado de la consulta
                será ordenado. Si
                multiples columnas son listadas, las columnas secundarias serán
                usadas para resolver relaciones; el orden de clasificación es
                determinado por
                columnas secundarias si la columna anterior
                contiene valores idénticos. El orden por
                defecto es del menor
                valor al mayor valor. Puede también ordenar de mayor a menor
                valor para una columna dada en la lista espeificando la palabra
                clave
                <constant>DESC</constant>
                después de la columna.
            </para>

            <para>
                En
                <classname>Zend_Db_Select</classname>
                , puede usar el
                método
                <methodname>order()</methodname>
                para especificar una
                columna o un array de columnas por el cual ordenar. Cada
                elemento del array es un string nombrando la columna.
                Opcionalmente con la palabra
                reservada
                <constant>ASC</constant>
                o
                <constant>DESC</constant>
                siguiendola, separada por un espacio.
            </para>

            <para>
                Como en el método
                <methodname>from()</methodname>
                y
                <methodname>group()</methodname>
                , los nombres de columnas
                son entrecomillados como identificadores, a menos que
                contengan
                paréntesis o sean un obheto de tipo
                <classname>Zend_Db_Expr</classname>
                .
            </para>

            <example id="zend.db.select.building.order.example">

                <title>Ejemplo del método order()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   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'));
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.limit">

            <title>Agregando una cláusula LIMIT</title>

            <para>
                Algunos
                <acronym>RDBMS</acronym>
                extienden una consulta
                <acronym>SQL</acronym>
                con una cláusula conocida como
                <constant>LIMIT</constant>
                .
                Esta cláusuala reduce el número de filas en el resultado a no
                más de un número
                especificado. También puede especificar saltar
                el número de filas antes de empezar la
                salida. Esta
                característica hace más fácil tomar un subconjunto de
                resultados, por
                ejemplo cuando mostramos los resultados de una
                consulta en páginas progresivas de
                salida.
            </para>

            <para>
                En
                <classname>Zend_Db_Select</classname>
                , puede usar el
                método
                <methodname>limit()</methodname>
                para especificar la
                cantidad de filas y el número de filas que saltar. El
                <emphasis>primer</emphasis>
                argumento es el método es el número de filas deseado. El
                <emphasis>segundo</emphasis>
                argument es el número de filas que saltar.
            </para>

            <example id="zend.db.select.building.limit.example">

                <title>Ejemplo del método limit()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p
//   LIMIT 10, 20
// Equivalente  a:
//   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(10, 20);
]]></programlisting>

            </example>

            <note>

                <para>
                    La sintaxis de
                    <constant>LIMIT</constant>
                    no está
                    soportada por todos los
                    <acronym>RDBMS</acronym>
                    brands. Algunos
                    <acronym>RDBMS</acronym>
                    requieren diferente sintaxis para soportar una funcionalidad
                    similar Cada clase
                    <classname>Zend_Db_Adapter_Abstract</classname>
                    incluye
                    un método para producir el
                    <acronym>SQL</acronym>
                    apropiado
                    para cada
                    <acronym>RDBMS</acronym>
                    .
                </para>

            </note>

            <para>
                Use el método
                <methodname>limitPage()</methodname>
                como un
                modo alternativo de especificar la cantidad de filas y el
                offset. Este método
                permite limitar el conjunto resultado a una
                serie de subconjuntos de tamaño fijo de
                filas del total del
                resultado de la consulta. En otras palabras, puede especificar
                el
                tamaño de una "página" de resultados, y el número ordinal de
                la página simple donde
                se espera que devuelva la consulta. El
                número de página es el primer argumento del
                método
                <methodname>limitPage()</methodname>
                , y la longitud de la
                página es el segundo argumento. Ambos son argumentos
                requeridos;
                no tienen valores por omisión.
            </para>

            <example id="zend.db.select.building.limit.example2">

                <title>Ejemplo del método limitPage()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   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);
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.distinct">

            <title>Agregar el modificador DISTINCT a la consulta</title>

            <para>
                El método
                <methodname>distinct()</methodname>
                permite agregar
                la palabra clave a la consulta
                <constant>DISTINCT</constant>
                a su consulta
                <acronym>SQL</acronym>
                .
            </para>

            <example id="zend.db.select.building.distinct.example">

                <title>Ejemplo del método distinct()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   SELECT DISTINCT p."product_name"
//   FROM "products" AS p

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

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.for-update">

            <title>Agregar el modificador FOR UPDATE</title>

            <para>
                El método
                <methodname>forUpdate()</methodname>
                permite
                agregar el modificador
                <code>FOR UPDATE</code>
                a su
                consulta
                <acronym>SQL</acronym>
                .
            </para>

            <example id="zend.db.select.building.for-update.example">

                <title>Example of forUpdate() method</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   SELECT FOR UPDATE p.*
//   FROM "products" AS p

$select = $db->select()
             ->forUpdate()
             ->from(array('p' => 'products'));
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.union">
            <title>Building a UNION Query</title>

            <para>
                You can build union queries with
                <classname>Zend_Db_Select</classname>
                by passing an array
                of
                <classname>Zend_Db_Select</classname>
                or SQL Query strings into the
                <methodname>union()</methodname>
                method. As second parameter you can pass the
                <constant>Zend_Db_Select::SQL_UNION</constant>
                or
                <constant>Zend_Db_Select::SQL_UNION_ALL</constant>
                constants to specify which type of union you
                want to perform.
            </para>

            <example id="zend.db.select.building.union.example">
                <title>Example of union() method</title>

                <programlisting language="php"><![CDATA[
$sql1 = $db->select();
$sql2 = "SELECT ...";

$select = $db->select()
    ->union(array($sql1, $sql2))
    ->order("id");
]]></programlisting>
            </example>
        </sect3>

    </sect2>

    <sect2 id="zend.db.select.execute">

        <title>Ejecutando consultas Select</title>

        <para>
            En esta sección se describe cómo ejecutar una consulta
            representada por un objeto
            <classname>Zend_Db_Select</classname>
            .
        </para>

        <sect3 id="zend.db.select.execute.query-adapter">

            <title>Ejecutando Consultas SelectExecuting desde el Adaptador de
                Base de Datos</title>

            <para>
                Puede ejecutar la consulta representada por el objeto
                <classname>Zend_Db_Select</classname>
                pasándolo como primer
                argumento al método
                <methodname>query()</methodname>
                de un
                objeto
                <classname>Zend_Db_Adapter_Abstract</classname>
                . Use
                objetos
                <classname>Zend_Db_Select</classname>
                en lugar de un
                string de consulta.
            </para>

            <para>
                El método
                <methodname>query()</methodname>
                devuelve un objeto
                de tipo
                <classname>Zend_Db_Statement</classname>
                o PDOStatement, dependiendo del tipo
                de adaptador.
            </para>

            <example id="zend.db.select.execute.query-adapter.example">

                <title>Ejemplo usando el método adaptador query() del Adaptador
                    de Base de datos</title>

                <programlisting language="php"><![CDATA[
$select = $db->select()
             ->from('products');

$stmt = $db->query($select);
$result = $stmt->fetchAll();
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.execute.query-select">

            <title>Ejecutando Consultas Select desde el Objeto</title>

            <para>
                Como alternativa al uso del método
                <methodname>query()</methodname>
                del objeto adaptador, puede
                usar el método
                <methodname>query()</methodname>
                del objeto
                <classname>Zend_Db_Select</classname>
                . Ambos métodos
                devuelven un objeto de tipo
                <classname>Zend_Db_Statement</classname>
                o PDOStatement,
                dependiendo del tipo de adaptador.
            </para>

            <example id="zend.db.select.execute.query-select.example">

                <title>Ejempo usando el método query() del objeto Select</title>

                <programlisting language="php"><![CDATA[
$select = $db->select()
             ->from('products');

$stmt = $select->query();
$result = $stmt->fetchAll();
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.execute.tostring">

            <title>
                Convertiendo un Objeto Select a un String
                <acronym>SQL</acronym>
            </title>

            <para>
                Si necesita acceder a una represantación en un string de la
                consulta
                <acronym>SQL</acronym>
                correspondiente al objeto
                <classname>Zend_Db_Select</classname>
                , use el método
                <methodname>__toString()</methodname>
                .
            </para>

            <example id="zend.db.select.execute.tostring.example">

                <title>Ejemplo del método __toString()</title>

                <programlisting language="php"><![CDATA[
$select = $db->select()
             ->from('products');

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

// La salida es el string:
//   SELECT * FROM "products"
]]></programlisting>

            </example>

        </sect3>

    </sect2>

    <sect2 id="zend.db.select.other">

        <title>Otros Métodos</title>

        <para>
            Esta sección describe otros métodos de
            <classname>Zend_Db_Select</classname>
            que no han sido cubiertos
            antes:
            <methodname>getPart()</methodname>
            y
            <methodname>reset()</methodname>
            .
        </para>

        <sect3 id="zend.db.select.other.get-part">

            <title>Obtener Partes de un Objeto Select</title>

            <para>
                El método
                <methodname>getPart()</methodname>
                devuelve una
                representación de una parte de su consulta
                <acronym>SQL</acronym>
                . Por ejemplo, puede usar este método
                para devolver un array de expresiones para la
                cláusula
                <constant>WHERE</constant>
                , o el array de columnas (o
                expresiones de columnas) que estan en la lista del
                <constant>SELECT</constant>
                , o los valores de la
                cantidad y comienzo para la cláusula
                <constant>LIMIT</constant>
                .
            </para>

            <para>
                El valor de retorno no es un string conteniendo un fragmento
                de la sintaxis
                <acronym>SQL</acronym>
                . El valor de retorno es
                una representación, típicamente un array con una estructura
                que
                contiene valores y expresiones. Cada parte de la consulta tiene
                una estructura
                diferente.
            </para>

            <para>
                El único argumento del método
                <methodname>getPart()</methodname>
                es un string que
                identifica qué parte del la consulta Select va a devolver. Por
                ejemplo, el string
                <code>'from'</code>
                identifica la
                parte del objeto Select que almacena la información de las
                tablas de la
                cláusula
                <constant>FROM</constant>
                , incluyendo
                uniones de tablas.
            </para>

            <para>
                La clase
                <classname>Zend_Db_Select</classname>
                define
                constantes que puedes usar para las partes de la consulta
                <acronym>SQL</acronym>
                . Puede usar estas definiciones de
                constantes, o los strings literales.
            </para>

            <table id="zend.db.select.other.get-part.table">

                <title>Constantes usedas por getPart() y reset()</title>

                <tgroup cols="2">
                    <thead>
                        <row>
                            <entry>Constante</entry>
                            <entry>Valor del String</entry>
                        </row>
                    </thead>

                    <tbody>
                        <row>
                            <entry>
                                <constant>Zend_Db_Select::DISTINCT</constant>
                            </entry>
                            <entry>
                                <code>'distinct'</code>
                            </entry>
                        </row>

                        <row>
                            <entry>
                                <constant>Zend_Db_Select::FOR_UPDATE</constant>
                            </entry>
                            <entry>
                                <code>'forupdate'</code>
                            </entry>
                        </row>

                        <row>
                            <entry>
                                <constant>Zend_Db_Select::COLUMNS</constant>
                            </entry>
                            <entry>
                                <code>'columns'</code>
                            </entry>
                        </row>

                        <row>
                            <entry>
                                <constant>Zend_Db_Select::FROM</constant>
                            </entry>
                            <entry>
                                <code>'from'</code>
                            </entry>
                        </row>

                        <row>
                            <entry>
                                <constant>Zend_Db_Select::WHERE</constant>
                            </entry>
                            <entry>
                                <code>'where'</code>
                            </entry>
                        </row>

                        <row>
                            <entry>
                                <constant>Zend_Db_Select::GROUP</constant>
                            </entry>
                            <entry>
                                <code>'group'</code>
                            </entry>
                        </row>

                        <row>
                            <entry>
                                <constant>Zend_Db_Select::HAVING</constant>
                            </entry>
                            <entry>
                                <code>'having'</code>
                            </entry>
                        </row>

                        <row>
                            <entry>
                                <constant>Zend_Db_Select::ORDER</constant>
                            </entry>
                            <entry>
                                <code>'order'</code>
                            </entry>
                        </row>

                        <row>
                            <entry>
                                <constant>Zend_Db_Select::LIMIT_COUNT</constant>
                            </entry>
                            <entry>
                                <code>'limitcount'</code>
                            </entry>
                        </row>

                        <row>
                            <entry>
                                <constant>Zend_Db_Select::LIMIT_OFFSET</constant>
                            </entry>
                            <entry>
                                <code>'limitoffset'</code>
                            </entry>
                        </row>
                    </tbody>
                </tgroup>
            </table>

            <example id="zend.db.select.other.get-part.example">

                <title>Ejemplo del método getPart()</title>

                <programlisting language="php"><![CDATA[
$select = $db->select()
             ->from('products')
             ->order('product_id');

// Puede especificar un string literal para especificar la parte
$orderData = $select->getPart( 'order' );

// Puede usar una constante para especificar la misma parte
$orderData = $select->getPart( Zend_Db_Select::ORDER );

// El valor de retorno puede ser una estructura en un array, no un string.
// Cada parte tiene distinta estructura.
print_r( $orderData );
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.other.reset">

            <title>Restableciendo Partes de un Objeto</title>

            <para>
                El método
                <methodname>reset()</methodname>
                permite limpiar
                una parte específica de la consulta
                <acronym>SQL</acronym>
                , o
                limpia todas las partes de la consulta
                <acronym>SQL</acronym>
                si
                omite el argumento.
            </para>

            <para>
                El argumento es opcional. Puede especificar la parte de la
                consulta que será
                limpiada, usando los mismos strings que usa el
                argumento del método
                <methodname>getPart()</methodname>
                . La
                parte de la consulta que especifique se reestablecerá a su
                estado por omisión.
            </para>

            <para>
                Si omite el parámetro,
                <methodname>reset()</methodname>
                cambia todas las partes de la consulta a su estado por omisión.
                Esto hace que el
                objeto
                <classname>Zend_Db_Select</classname>
                sea equivalente a crear
                un nuevo objeto, como si acabase de instanciarlo.
            </para>

            <example id="zend.db.select.other.reset.example">

                <title>Ejemplo del método reset()</title>

                <programlisting language="php"><![CDATA[
// Construya esta consulta:
//   SELECT p.*
//   FROM "products" AS p
//   ORDER BY "product_name"

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

// Requisito cambiado, en su lugar un orden diferente de columnas:
//   SELECT p.*
//   FROM "products" AS p
//   ORDER BY "product_id"

// Limpia una parte para poder redefinirla
$select->reset( Zend_Db_Select::ORDER );

// Y especificar una columna diferente
$select->order('product_id');

// Limpia todas las partes de la consulta
$select->reset();
]]></programlisting>

            </example>

        </sect3>

    </sect2>

</sect1>