query_sql.po

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

#: index.docbook:448
msgid ""
"To use stored procedures with Hibernate the procedures/functions have to "
"follow some rules. If they do not follow those rules they are not usable "
"with Hibernate. If you still want to use these procedures you have to "
"execute them via <literal>session.connection()</literal>. The rules are "
"different for each database, since database vendors have different stored "
"procedure semantics/syntax."
msgstr ""
"Para usar procedimientos almacenados con Hibernate los procedimientos tienen "
"que seguir algunas reglas. Si no siguen esas reglas no son usables por "
"Hibernate. Si a&#x00fa;n quisieras usar estos procedimientos tendr&#x00ed;as "
"que ejecutarlos por medio de <literal>session.connection()</literal>. Las "
"reglas son diferentes para cada base de datos, ya que los vendedores de base "
"de datos tienen diferentes sem&#x00e1;nticas/sint&#x00e1;xis de "
"procedimientos almacenados."

#: index.docbook:455
msgid ""
"Stored procedure queries can't be paged with <literal>setFirstResult()/"
"setMaxResults()</literal>."
msgstr ""
"Las consultas de procedimientos almacenados no pueden ser paginadas con "
"<literal>setFirstResult()/setMaxResults()</literal>."

#: index.docbook:458
msgid ""
"Recommended call form is standard SQL92: <literal>{ ? = call functionName"
"(&lt;parameters&gt;) }</literal> or <literal>{ ? = call procedureName(&lt;"
"parameters&gt;}</literal>. Native call syntax is not supported."
msgstr "Para Oracle se aplican las siguientes reglas:"

#: index.docbook:463
msgid "For Oracle the following rules apply:"
msgstr ""
"El procedimiento debe devolver un conjunto resultado. Esto se hace "
"devolviendo un <literal>SYS_REFCURSOR</literal> en Oracle 9 o 10. En Oracle "
"necesitas definir un tipo <literal>REF CURSOR</literal>."

#: index.docbook:467
msgid ""
"A function must return a result set. The first parameter of a procedure must "
"be an <literal>OUT</literal> that returns a result set. This is done by "
"using a <literal>SYS_REFCURSOR</literal> type in Oracle 9 or 10. In Oracle "
"you need to define a <literal>REF CURSOR</literal> type, see Oracle "
"literature."
msgstr ""
"La forma recomendada es <literal>{ ? = call procName(&lt;parameters&gt;) }</"
"literal> o <literal>{ ? = call procName }</literal> (esto es m&#x00e1;s una "
"regla de Oracle que una regla de Hibernate)."

#: index.docbook:476
msgid "For Sybase or MS SQL server the following rules apply:"
msgstr "Para Sybase o MS SQL server se aplican las siguientes reglas:"

#: index.docbook:480
msgid ""
"The procedure must return a result set. Note that since these servers can/"
"will return multiple result sets and update counts, Hibernate will iterate "
"the results and take the first result that is a result set as its return "
"value. Everything else will be discarded."
msgstr ""
"El procedimiento debe devolver un conjunto resultado. Nota que ya que estos "
"servidores pueden y devolver&#x00e1;n m&#x00fa;ltiples conjuntos resultados "
"y cuentas de actualizaci&#x00f3;n, Hibernate iterar&#x00e1; los resultados y "
"tomar&#x00e1; el primer resultado que sea un conjunto resultado como su "
"valor a devolver. Todo lo dem&#x00e1;s ser&#x00e1; descartado."

#: index.docbook:488
msgid ""
"If you can enable <literal>SET NOCOUNT ON</literal> in your procedure it "
"will probably be more efficient, but this is not a requirement."
msgstr ""
"Si habilitas <literal>SET NOCOUNT ON</literal> en tu procedimiento "
"ser&#x00e1; probablemente m&#x00e1;s eficiente, pero esto no es un "
"requerimiento."

#: index.docbook:498
msgid "Custom SQL for create, update and delete"
msgstr "SQL personalizado para crear, actualizar y borrar"

#: index.docbook:500
msgid ""
"Hibernate3 can use custom SQL statements for create, update, and delete "
"operations. The class and collection persisters in Hibernate already contain "
"a set of configuration time generated strings (insertsql, deletesql, "
"updatesql etc.). The mapping tags <literal>&lt;sql-insert&gt;</literal>, "
"<literal>&lt;sql-delete&gt;</literal>, and <literal>&lt;sql-update&gt;</"
"literal> override these strings:"
msgstr ""
"Hibernate3 puede usar sentencias SQL personalizadas para las operaciones de "
"crear, actualizar y borrar. Los persistidores de clases y colecciones en "
"Hibernate ya contienen un conjunto de cadenas generadas en tiempo de "
"configuraci&#x00f3;n (insertsql, deletesql, updatesql, etc.). Las etiquetas "
"de mapeo <literal>&lt;sql-insert&gt;</literal>, <literal>&lt;sql-delete&gt;</"
"literal>, y <literal>&lt;sql-update&gt;</literal> sobrescriben estas cadenas:"

#: index.docbook:508
msgid ""
"<![CDATA[<class name=\"Person\">\n"
"    <id name=\"id\">\n"
"        <generator class=\"increment\"/>\n"
"    </id>\n"
"    <property name=\"name\" not-null=\"true\"/>\n"
"    <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-"
"insert>\n"
"    <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
"    <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
"</class>]]>"
msgstr ""
"<![CDATA[<class name=\"Person\">\n"
"    <id name=\"id\">\n"
"        <generator class=\"increment\"/>\n"
"    </id>\n"
"    <property name=\"name\" not-null=\"true\"/>\n"
"    <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-"
"insert>\n"
"    <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
"    <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
"</class>]]>"

#: index.docbook:510
msgid ""
"The SQL is directly executed in your database, so you are free to use any "
"dialect you like. This will of course reduce the portability of your mapping "
"if you use database specific SQL."
msgstr ""
"El SQL se ejecuta directamente en tu base de datos, de modo que eres libre "
"de usar cualquier dialecto que quieras. Esto reducir&#x00e1;, por supuesto, "
"la portabilidad de tu mapeo si usas SQL espec&#x00ed;fico de la base de "
"datos."

#: index.docbook:514
msgid ""
"Stored procedures are supported if the <literal>callable</literal> attribute "
"is set:"
msgstr ""
"Los procedimientos almacenados son soportados si est&#x00e1; establecido el "
"atributo <literal>callable</literal>:"

#: index.docbook:517
msgid ""
"<![CDATA[<class name=\"Person\">\n"
"    <id name=\"id\">\n"
"        <generator class=\"increment\"/>\n"
"    </id>\n"
"    <property name=\"name\" not-null=\"true\"/>\n"
"    <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
"    <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
"    <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-"
"update>\n"
"</class>]]>"
msgstr ""
"<![CDATA[<class name=\"Person\">\n"
"    <id name=\"id\">\n"
"        <generator class=\"increment\"/>\n"
"    </id>\n"
"    <property name=\"name\" not-null=\"true\"/>\n"
"    <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
"    <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
"    <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-"
"update>\n"
"</class>]]>"

#: index.docbook:519
msgid ""
"The order of the positional parameters are currently vital, as they must be "
"in the same sequence as Hibernate expects them."
msgstr ""
"El orden de los par&#x00e1;metros posicionales son actualmente vitales, ya "
"que deben estar en la misma secuencia en que las espera Hibernate."

#: index.docbook:522
msgid ""
"You can see the expected order by enabling debug logging for the "
"<literal>org.hibernate.persister.entity</literal> level. With this level "
"enabled Hibernate will print out the static SQL that is used to create, "
"update, delete etc. entities. (To see the expected sequence, remember to not "
"include your custom SQL in the mapping files as that will override the "
"Hibernate generated static sql.)"
msgstr ""
"Puedes ver el orden esperado habilitando el registro de depuraci&#x00f3;n "
"para el nivel <literal>org.hibernate.persister.entity</literal>. Con este "
"nivel habilitado, Hibernate imprimir&#x00e1; el SQL est&#x00e1;tico que se "
"usa para crear, actualizar, borrar, etc. las entidades. (Para ver la "
"secuencia esperada, recuerda no incluir tu SQL personalizado en los ficheros "
"de mapeo ya que sobrescribir&#x00e1;n el sql est&#x00e1;tico generado por "
"Hibernate.)"

#: index.docbook:529
msgid ""
"The stored procedures are in most cases (read: better do it than not) "
"required to return the number of rows inserted/updated/deleted, as Hibernate "
"has some runtime checks for the success of the statement. Hibernate always "
"registers the first statement parameter as a numeric output parameter for "
"the CUD operations:"
msgstr ""
"Los procedimientos almacenados son, en la mayor&#x00ed;a de los casos "
"(l&#x00e9;ase, mejor hacerlo que no hacerlo), obligados a devolver el "
"n&#x00fa;mero de filas insertadas/actualizadas/borradas, ya que Hibernate "
"tiene algunas comprobaciones en tiempo de ejecuci&#x00f3;n del &#x00e9;xito "
"de la sentencia. Hibernate siempre registra el primer par&#x00e1;metro de la "
"sentencia como un par&#x00e1;metro de salida num&#x00e9;rico para las "
"operaciones CUD:"

#: index.docbook:535
msgid ""
"<![CDATA[CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN "
"VARCHAR2)\n"
"    RETURN NUMBER IS\n"
"BEGIN\n"
"\n"
"    update PERSON\n"
"    set\n"
"        NAME = uname,\n"
"    where\n"
"        ID = uid;\n"
"\n"
"    return SQL%ROWCOUNT;\n"
"\n"
"END updatePerson;]]>"
msgstr ""
"<![CDATA[CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN "
"VARCHAR2)\n"
"    RETURN NUMBER IS\n"
"BEGIN\n"
"\n"
"    update PERSON\n"
"    set\n"
"        NAME = uname,\n"
"    where\n"
"        ID = uid;\n"
"\n"
"    return SQL%ROWCOUNT;\n"
"\n"
"END updatePerson;]]>"

#: index.docbook:539
msgid "Custom SQL for loading"
msgstr "SQL personalizado para carga"

#: index.docbook:541
msgid "You may also declare your own SQL (or HQL) queries for entity loading:"
msgstr ""
"Puedes tambi&#x00e9;n declarar tu propias consultas SQL (o HQL) para cargar "
"entidades:"

#: index.docbook:544
msgid ""
"<![CDATA[<sql-query name=\"person\">\n"
"    <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
"    SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
"    FROM PERSON\n"
"    WHERE ID=?\n"
"    FOR UPDATE\n"
"</sql-query>]]>"
msgstr ""
"<![CDATA[<sql-query name=\"person\">\n"
"    <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
"    SELECT NAME AS {pers.name}, ID AS {pers.id} \n"
"    FROM PERSON \n"
"    WHERE ID=? \n"
"    FOR UPDATE\n"
"</sql-query>]]>"

#: index.docbook:546
msgid ""
"This is just a named query declaration, as discussed earlier. You may "
"reference this named query in a class mapping:"
msgstr ""
"Esto es s&#x00f3;lo una declaraci&#x00f3;n de consulta con nombrem como se "
"ha discutido anteriormente. Puedes hacer referencia a esta consulta con "
"nombre en un mapeo de clase:"

#: index.docbook:549
msgid ""
"<![CDATA[<class name=\"Person\">\n"
"    <id name=\"id\">\n"
"        <generator class=\"increment\"/>\n"
"    </id>\n"
"    <property name=\"name\" not-null=\"true\"/>\n"
"    <loader query-ref=\"person\"/>\n"
"</class>]]>"
msgstr ""
"<![CDATA[<class name=\"Person\">\n"
"    <id name=\"id\">\n"
"        <generator class=\"increment\"/>\n"
"    </id>\n"
"    <property name=\"name\" not-null=\"true\"/>\n"
"    <loader query-ref=\"person\"/>\n"
"</class>]]>"

#: index.docbook:551
msgid "This even works with stored procedures."
msgstr "Esto incluso funciona con procedimientos almacenados."

#: index.docbook:553
msgid "You may even define a query for collection loading:"
msgstr "Puedes incluso definit una consulta para la carga de colecciones:"

#: index.docbook:555
msgid ""
"<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
"    <key/>\n"
"    <one-to-many class=\"Employment\"/>\n"
"    <loader query-ref=\"employments\"/>\n"
"</set>]]>"
msgstr ""
"<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
"    <key/>\n"
"    <one-to-many class=\"Employment\"/>\n"
"    <loader query-ref=\"employments\"/>\n"
"</set>]]>"

#: index.docbook:557
msgid ""
"<![CDATA[<sql-query name=\"employments\">\n"
"    <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
"    SELECT {emp.*}\n"
"    FROM EMPLOYMENT emp\n"
"    WHERE EMPLOYER = :id\n"
"    ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
"</sql-query>]]>"
msgstr ""
"<![CDATA[<sql-query name=\"employments\">\n"
"    <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
"    SELECT {emp.*}\n"
"    FROM EMPLOYMENT emp\n"
"    WHERE EMPLOYER = :id\n"
"    ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
"</sql-query>]]>"

#: index.docbook:559
msgid ""
"You could even define an entity loader that loads a collection by join "
"fetching:"
msgstr ""
"Podr&#x00ed;as incluso definir un cargador de entidades que cargue una "
"colecci&#x00f3;n por recuperaci&#x00f3;n por uni&#x00f3;n (join fetching):"

#: index.docbook:562
msgid ""
"<![CDATA[<sql-query name=\"person\">\n"
"    <return alias=\"pers\" class=\"Person\"/>\n"
"    <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
"    SELECT NAME AS {pers.*}, {emp.*}\n"
"    FROM PERSON pers\n"
"    LEFT OUTER JOIN EMPLOYMENT emp\n"
"        ON pers.ID = emp.PERSON_ID\n"
"    WHERE ID=?\n"
"</sql-query>]]>"
msgstr ""
"<![CDATA[<sql-query name=\"person\">\n"
"    <return alias=\"pers\" class=\"Person\"/>\n"
"    <return-join alias=\"emp\" property=\"pers.employments\"/> \n"
"    SELECT NAME AS {pers.*}, {emp.*}\n"
"    FROM PERSON pers\n"
"    LEFT OUTER JOIN EMPLOYMENT emp \n"
"        ON pers.ID = emp.PERSON_ID\n"
"    WHERE ID=?\n"
"</sql-query>]]>"

msgid "ROLES_OF_TRANSLATORS"
msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"

msgid "CREDIT_FOR_TRANSLATORS"
msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"