query_sql.pot

hibernate-distribution-3.3.1.GA-dist.zip源码

#, no-c-format
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 ""

#. Tag: programlisting
#: query_sql.xml:430
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:432
#, no-c-format
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 ""

#. Tag: programlisting
#: query_sql.xml:437
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:439
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:444
#, no-c-format
msgid "If your mapping has a discriminator you must use <literal>&lt;return-discriminator&gt;</literal> to specify the discriminator column."
msgstr ""

#. Tag: title
#: query_sql.xml:450
#, no-c-format
msgid "Using stored procedures for querying"
msgstr ""

#. Tag: para
#: query_sql.xml:452
#, no-c-format
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 ""

#. Tag: programlisting
#: query_sql.xml:458
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:460
#, no-c-format
msgid "To use this query in Hibernate you need to map it via a named query."
msgstr ""

#. Tag: programlisting
#: query_sql.xml:463
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:465
#, no-c-format
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 ""

#. Tag: title
#: query_sql.xml:470
#, no-c-format
msgid "Rules/limitations for using stored procedures"
msgstr ""

#. Tag: para
#: query_sql.xml:472
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:479
#, no-c-format
msgid "Stored procedure queries can't be paged with <literal>setFirstResult()/setMaxResults()</literal>."
msgstr ""

#. Tag: para
#: query_sql.xml:482
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:487
#, no-c-format
msgid "For Oracle the following rules apply:"
msgstr ""

#. Tag: para
#: query_sql.xml:491
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:500
#, no-c-format
msgid "For Sybase or MS SQL server the following rules apply:"
msgstr ""

#. Tag: para
#: query_sql.xml:504
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:512
#, no-c-format
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 ""

#. Tag: title
#: query_sql.xml:522
#, no-c-format
msgid "Custom SQL for create, update and delete"
msgstr ""

#. Tag: para
#: query_sql.xml:524
#, no-c-format
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 ""

#. Tag: programlisting
#: query_sql.xml:532
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:534
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:538
#, no-c-format
msgid "Stored procedures are supported if the <literal>callable</literal> attribute is set:"
msgstr ""

#. Tag: programlisting
#: query_sql.xml:541
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:543
#, no-c-format
msgid "The order of the positional parameters are currently vital, as they must be in the same sequence as Hibernate expects them."
msgstr ""

#. Tag: para
#: query_sql.xml:546
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:553
#, no-c-format
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 ""

#. Tag: programlisting
#: query_sql.xml:559
#, no-c-format
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 ""

#. Tag: title
#: query_sql.xml:563
#, no-c-format
msgid "Custom SQL for loading"
msgstr ""

#. Tag: para
#: query_sql.xml:565
#, no-c-format
msgid "You may also declare your own SQL (or HQL) queries for entity loading:"
msgstr ""

#. Tag: programlisting
#: query_sql.xml:568
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:570
#, no-c-format
msgid "This is just a named query declaration, as discussed earlier. You may reference this named query in a class mapping:"
msgstr ""

#. Tag: programlisting
#: query_sql.xml:573
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:575
#, no-c-format
msgid "This even works with stored procedures."
msgstr ""

#. Tag: para
#: query_sql.xml:577
#, no-c-format
msgid "You may even define a query for collection loading:"
msgstr ""

#. Tag: programlisting
#: query_sql.xml:579
#, no-c-format
msgid ""
      "<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
      "    <key/>\n"
      "    <one-to-many class=\"Employment\"/>\n"
      "    <loader query-ref=\"employments\"/>\n"
      "</set>]]>"
msgstr ""

#. Tag: programlisting
#: query_sql.xml:581
#, no-c-format
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 ""

#. Tag: para
#: query_sql.xml:583
#, no-c-format
msgid "You could even define an entity loader that loads a collection by join fetching:"
msgstr ""

#. Tag: programlisting
#: query_sql.xml:586
#, no-c-format
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 ""