query_sql.po

hibernate 开源框架的代码 jar包希望大家能喜欢

"<![CDATA[List people = sess.getNamedQuery(\"persons\")\n"
"    .setString(\"namePattern\", namePattern)\n"
"    .setMaxResults(50)\n"
"    .list();]]>"
msgstr ""
"<![CDATA[List people = sess.getNamedQuery(\"persons\")\n"
"    .setString(\"namePattern\", namePattern)\n"
"    .setMaxResults(50)\n"
"    .list();]]>"

#: index.docbook:372
msgid ""
"The <literal>&lt;return-join&gt;</literal> and <literal>&lt;load-"
"collection&gt;</literal> elements are used to join associations and define "
"queries which initialize collections, respectively."
msgstr ""
"Los elementos <literal>&lt;return-join&gt;</literal> y <literal>&lt;load-"
"collection&gt;</literal> se usan para unir asociaciones y definir consultas "
"que inicialicen colecciones, respectivamente."

#: index.docbook:377
msgid ""
"<![CDATA[<sql-query name=\"personsWith\">\n"
"    <return alias=\"person\" class=\"eg.Person\"/>\n"
"    <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
"    SELECT person.NAME AS {person.name},\n"
"           person.AGE AS {person.age},\n"
"           person.SEX AS {person.sex},\n"
"           address.STREET AS {address.street},\n"
"           address.CITY AS {address.city},\n"
"           address.STATE AS {address.state},\n"
"           address.ZIP AS {address.zip}\n"
"    FROM PERSON person\n"
"    JOIN ADDRESS address\n"
"        ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
"    WHERE person.NAME LIKE :namePattern\n"
"</sql-query>]]>"
msgstr ""
"<![CDATA[<sql-query name=\"personsWith\">\n"
"    <return alias=\"person\" class=\"eg.Person\"/>\n"
"    <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
"    SELECT person.NAME AS {person.name},\n"
"           person.AGE AS {person.age},\n"
"           person.SEX AS {person.sex},\n"
"           address.STREET AS {address.street},\n"
"           address.CITY AS {address.city},\n"
"           address.STATE AS {address.state},\n"
"           address.ZIP AS {address.zip}\n"
"    FROM PERSON person \n"
"    JOIN ADDRESS address\n"
"            ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
"    WHERE person.NAME LIKE :namePattern\n"
"</sql-query>]]>"

#: index.docbook:379
msgid ""
"A named SQL query may return a scalar value. You must declare the column "
"alias and Hibernate type using the <literal>&lt;return-scalar&gt;</literal> "
"element:"
msgstr ""
"Una consulta SQL con nombre puede devolver un valor escalar. Debes "
"especificar el alias de columna y tipo Hibernate usando el elementp "
"<literal>&lt;return-scalar&gt;</literal>:"

#: index.docbook:383
msgid ""
"<![CDATA[<sql-query name=\"mySqlQuery\">\n"
"    <return-scalar column=\"name\" type=\"string\"/>\n"
"    <return-scalar column=\"age\" type=\"long\"/>\n"
"    SELECT p.NAME AS name,\n"
"           p.AGE AS age,\n"
"    FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
"</sql-query>]]>"
msgstr ""
"<![CDATA[<sql-query name=\"mySqlQuery\">\n"
"    <return-scalar column=\"name\" type=\"string\"/>\n"
"    <return-scalar column=\"age\" type=\"long\"/>\n"
"    SELECT p.NAME AS name,\n"
"           p.AGE AS age,\n"
"    FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
"</sql-query>]]>"

#: index.docbook:385
msgid ""
"You can externalize the resultset mapping informations in a <literal>&lt;"
"resultset&gt;</literal> element to either reuse them accross several named "
"queries or through the <literal>setResultSetMapping()</literal> API."
msgstr ""
"You can externalize the resultset mapping informations in a <literal>&lt;"
"resultset&gt;</literal> element to either reuse them accross several named "
"queries or through the <literal>setResultSetMapping()</literal> API."

#: index.docbook:390
msgid ""
"<![CDATA[<resultset name=\"personAddress\">\n"
"    <return alias=\"person\" class=\"eg.Person\"/>\n"
"    <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
"</resultset>\n"
"\n"
"<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
"    SELECT person.NAME AS {person.name},\n"
"           person.AGE AS {person.age},\n"
"           person.SEX AS {person.sex},\n"
"           address.STREET AS {address.street},\n"
"           address.CITY AS {address.city},\n"
"           address.STATE AS {address.state},\n"
"           address.ZIP AS {address.zip}\n"
"    FROM PERSON person\n"
"    JOIN ADDRESS address\n"
"        ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
"    WHERE person.NAME LIKE :namePattern\n"
"</sql-query>]]>"
msgstr ""
"<![CDATA[<resultset name=\"personAddress\">\n"
"                <return alias=\"person\" class=\"eg.Person\"/>\n"
"                <return-join alias=\"address\" property=\"person."
"mailingAddress\"/>\n"
"        </resultset>\n"
"        \n"
"        <sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
"                SELECT person.NAME AS {person.name},\n"
"                person.AGE AS {person.age},\n"
"                person.SEX AS {person.sex},\n"
"                address.STREET AS {address.street},\n"
"                address.CITY AS {address.city},\n"
"                address.STATE AS {address.state},\n"
"                address.ZIP AS {address.zip}\n"
"                FROM PERSON person\n"
"                JOIN ADDRESS address\n"
"                ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
"                WHERE person.NAME LIKE :namePattern\n"
"        </sql-query>]]>"

#: index.docbook:392
msgid ""
"You can alternatively use the resultset mapping information in your hbm "
"files directly in java code."
msgstr ""
"You can alternatively use the resultset mapping information in your hbm "
"files directly in java code."

#: index.docbook:395
msgid ""
"<![CDATA[List cats = sess.createSQLQuery(\n"
"        \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten."
"mother = cat.id\"\n"
"    )\n"
"    .setResultSetMapping(\"catAndKitten\")\n"
"    .list();]]>"
msgstr ""
"<![CDATA[List cats = sess.createSQLQuery(\n"
"                              \"select {cat.*}, {kitten.*} from cats cat, "
"cats kitten where kitten.mother = cat.id\"\n"
"                              )\n"
"                              .setResultSetMapping(\"catAndKitten\")\n"
"    .list();]]>"

#: index.docbook:398
msgid "Using return-property to explicitly specify column/alias names"
msgstr ""
"Usando return-property para especificar expl&#x00ed;citamente nombres de "
"columna/alias"

#: index.docbook:401
msgid ""
"With <literal>&lt;return-property&gt;</literal> you can explicitly tell "
"Hibernate what column aliases to use, instead of using the <literal>{}</"
"literal>-syntax to let Hibernate inject its own aliases."
msgstr ""
"Con <literal>&lt;return-property&gt;</literal> puedes decirle expl&#x00ed;"
"citamente a Hibernate qu&#x00e9; alias de columna usar, en vez de usar la "
"sint&#x00e1;xis <literal>{}</literal> para dejar que Hibernate inyecte sus "
"propios alias."

#: index.docbook:406
msgid ""
"<![CDATA[<sql-query name=\"mySqlQuery\">\n"
"    <return alias=\"person\" class=\"eg.Person\">\n"
"        <return-property name=\"name\" column=\"myName\"/>\n"
"        <return-property name=\"age\" column=\"myAge\"/>\n"
"        <return-property name=\"sex\" column=\"mySex\"/>\n"
"    </return>\n"
"    SELECT person.NAME AS myName,\n"
"           person.AGE AS myAge,\n"
"           person.SEX AS mySex,\n"
"    FROM PERSON person WHERE person.NAME LIKE :name\n"
"</sql-query>\n"
"]]>"
msgstr ""
"<![CDATA[<sql-query name=\"mySqlQuery\">\n"
"    <return alias=\"person\" class=\"eg.Person\">\n"
"        <return-property name=\"name\" column=\"myName\"/>\n"
"        <return-property name=\"age\" column=\"myAge\"/>\n"
"        <return-property name=\"sex\" column=\"mySex\"/>\n"
"    </return>\n"
"    SELECT person.NAME AS myName,\n"
"           person.AGE AS myAge,\n"
"           person.SEX AS mySex,\n"
"    FROM PERSON person WHERE person.NAME LIKE :name\n"
"</sql-query>\n"
"]]>"

#: index.docbook:408
msgid ""
"<literal>&lt;return-property&gt;</literal> also works with multiple columns. "
"This solves a limitation with the <literal>{}</literal>-syntax which can not "
"allow fine grained control of multi-column properties."
msgstr ""
"<literal>&lt;return-property&gt;</literal> tambi&#x00e9;n trabaja con "
"m&#x00fa;ltiples columnas. Esto resuelve una limitaci&#x00f3;n de la "
"sint&#x00e1;xis <literal>{}</literal>, la cual no puede permitir un control "
"fino de propiedades multi-columna."

#: index.docbook:413
msgid ""
"<![CDATA[<sql-query name=\"organizationCurrentEmployments\">\n"
"    <return alias=\"emp\" class=\"Employment\">\n"
"        <return-property name=\"salary\">\n"
"            <return-column name=\"VALUE\"/>\n"
"            <return-column name=\"CURRENCY\"/>\n"
"        </return-property>\n"
"        <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
"    </return>\n"
"        SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
"        STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
"        REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
"        FROM EMPLOYMENT\n"
"        WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
"        ORDER BY STARTDATE ASC\n"
"</sql-query>]]>"
msgstr ""
"<![CDATA[<sql-query name=\"organizationCurrentEmployments\">\n"
"    <return alias=\"emp\" class=\"Employment\">            \n"
"        <return-property name=\"salary\"> \n"
"            <return-column name=\"VALUE\"/>\n"
"            <return-column name=\"CURRENCY\"/>            \n"
"        </return-property>\n"
"        <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
"    </return>\n"
"        SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer}, \n"
"        STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
"        REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
"        FROM EMPLOYMENT\n"
"        WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
"        ORDER BY STARTDATE ASC\n"
"</sql-query>]]>"

#: index.docbook:415
msgid ""
"Notice that in this example we used <literal>&lt;return-property&gt;</"
"literal> in combination with the <literal>{}</literal>-syntax for injection. "
"Allowing users to choose how they want to refer column and properties."
msgstr ""
"Nota que en este ejemplo hemos usado <literal>&lt;return-property&gt;</"
"literal> en combinaci&#x00f3;n con la sint&#x00e1;xis <literal>{}</literal> "
"para inyecci&#x00f3;n, permitiendo a los usuarios elejir c&#x00f3;mo quieren "
"referirse a las columnas y propiedades."

#: index.docbook:420
msgid ""
"If your mapping has a discriminator you must use <literal>&lt;return-"
"discriminator&gt;</literal> to specify the discriminator column."
msgstr ""
"Si tu mapeo tiene un discriminador debes usar <literal>&lt;return-"
"discriminator&gt;</literal> para especificar la columna discriminadora."

#: index.docbook:426
msgid "Using stored procedures for querying"
msgstr "Usando procedimientos almacenados para consultar"

#: index.docbook:428
msgid ""
"Hibernate 3 introduces support for queries via stored procedures and "
"functions. Most of the following documentation is equivalent for both. The "
"stored procedure/function must return a resultset as the first out-parameter "
"to be able to work with Hibernate. An example of such a stored function in "
"Oracle 9 and higher is as follows:"
msgstr ""
"Hibernate3 introduce soporte para consultas v&#x00ed;a procedimientos "
"almacenados. Los procedimientos almacenados deben devolver un conjunto "
"resultado como el primer par&#x00e1;metro de salida para ser capaces de "
"funcionar con Hibernate. Un ejemplo de uno procedimiento almacenado en "
"Oracle 9 o superior es as&#x00ed;:"

#: index.docbook:434
msgid ""
"<![CDATA[CREATE OR REPLACE FUNCTION selectAllEmployments\n"
"    RETURN SYS_REFCURSOR\n"
"AS\n"
"    st_cursor SYS_REFCURSOR;\n"
"BEGIN\n"
"    OPEN st_cursor FOR\n"
" SELECT EMPLOYEE, EMPLOYER,\n"
" STARTDATE, ENDDATE,\n"
" REGIONCODE, EID, VALUE, CURRENCY\n"
" FROM EMPLOYMENT;\n"
"      RETURN  st_cursor;\n"
" END;]]>"
msgstr ""
"<![CDATA[CREATE OR REPLACE FUNCTION selectAllEmployments \n"
"    RETURN SYS_REFCURSOR \n"
"AS \n"
"    st_cursor SYS_REFCURSOR; \n"
"BEGIN \n"
"    OPEN st_cursor FOR \n"
" SELECT EMPLOYEE, EMPLOYER, \n"
" STARTDATE, ENDDATE, \n"
" REGIONCODE, EID, VALUE, CURRENCY \n"
" FROM EMPLOYMENT; \n"
"      RETURN  st_cursor; \n"
" END;]]>"

#: index.docbook:436
msgid "To use this query in Hibernate you need to map it via a named query."
msgstr ""
"Para usar esta consulta en Hibernate necesitas mapearla por medio de una "
"consulta con nombre."

#: index.docbook:439
msgid ""
"<![CDATA[<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
"    <return alias=\"emp\" class=\"Employment\">\n"
"        <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
"        <return-property name=\"employer\" column=\"EMPLOYER\"/>\n"
"        <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
"        <return-property name=\"endDate\" column=\"ENDDATE\"/>\n"
"        <return-property name=\"regionCode\" column=\"REGIONCODE\"/>\n"
"        <return-property name=\"id\" column=\"EID\"/>\n"
"        <return-property name=\"salary\">\n"
"            <return-column name=\"VALUE\"/>\n"
"            <return-column name=\"CURRENCY\"/>\n"
"        </return-property>\n"
"    </return>\n"
"    { ? = call selectAllEmployments() }\n"
"</sql-query>]]>"
msgstr ""
"<![CDATA[<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
"    <return alias=\"emp\" class=\"Employment\">\n"
"        <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
"        <return-property name=\"employer\" column=\"EMPLOYER\"/"
">            \n"
"        <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
"        <return-property name=\"endDate\" column=\"ENDDATE\"/>            \n"
"        <return-property name=\"regionCode\" column=\"REGIONCODE\"/"
">            \n"
"        <return-property name=\"id\" column=\"EID\"/"
">                        \n"
"        <return-property name=\"salary\"> \n"
"            <return-column name=\"VALUE\"/>\n"
"            <return-column name=\"CURRENCY\"/>            \n"
"        </return-property>\n"
"    </return>\n"
"    { ? = call selectAllEmployments() }\n"
"</sql-query>]]>"

#: index.docbook:441
msgid ""
"Notice stored procedures currently only return scalars and entities. "
"<literal>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</"
"literal> are not supported."
msgstr ""
"Nota que los procedimientos almacenados s&#x00f3;lo devuelven escalares y "
"entidades. No est&#x00e1;n soportados <literal>&lt;return-join&gt;</literal> "
"y <literal>&lt;load-collection&gt;</literal>."

#: index.docbook:446
msgid "Rules/limitations for using stored procedures"
msgstr "Reglas/limitaciones para usar procedimientos almacenados"