query_sql.po

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

#: query_sql.xml:333
#, no-c-format
msgid ""
"The above query will return a list of <literal>CatDTO</literal> which has "
"been instantiated and injected the values of NAME and BIRTHNAME into its "
"corresponding properties or fields."
msgstr ""
"위의 질의는 초기화되어 있고 NAME과 BIRTHNAME의 값들을 <literal>CatDTO</"
"literal>의 대응하는 프로퍼티들과 필드들 속으로 주입시킨 <literal>CatDTO</"
"literal>의 리스트를 반환할 것이다."

#. Tag: title
#: query_sql.xml:340
#, no-c-format
msgid "Handling inheritance"
msgstr "상속 처리하기"

#. Tag: para
#: query_sql.xml:342
#, no-c-format
msgid ""
"Native sql queries which query for entities that is mapped as part of an "
"inheritance must include all properties for the baseclass and all it "
"subclasses."
msgstr ""
"상속의 부분으로서 매핑되는 엔티티들을 질의하는 native sql 질의들은 baseclass"
"의 모든 프로퍼티들을 포함해야 하고 그 모든 것이 서브클래스화 되어야 한다."

#. Tag: title
#: query_sql.xml:348
#, no-c-format
msgid "Parameters"
msgstr "파라미터들"

#. Tag: para
#: query_sql.xml:350
#, no-c-format
msgid "Native sql queries support positional as well as named parameters:"
msgstr ""
"Native sql 질의들은 위치 파라미터들 뿐만 아니라 명명된 파라미터들을 지원한다:"

#. Tag: programlisting
#: query_sql.xml:353
#, no-c-format
msgid ""
"<![CDATA[Query query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME "
"like ?\").addEntity(Cat.class);\n"
"List pusList = query.setString(0, \"Pus%\").list();\n"
"     \n"
"query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like :name\")."
"addEntity(Cat.class);\n"
"List pusList = query.setString(\"name\", \"Pus%\").list();          ]]>"
msgstr ""

#. Tag: title
#: query_sql.xml:361
#, no-c-format
msgid "Named SQL queries"
msgstr "명명된 SQL 질의들"

#. Tag: para
#: query_sql.xml:363
#, no-c-format
msgid ""
"Named SQL queries may be defined in the mapping document and called in "
"exactly the same way as a named HQL query. In this case, we do "
"<emphasis>not</emphasis> need to call <literal>addEntity()</literal>."
msgstr ""
"명명된 SQL 질의들은 HQL 질의와 동일한 방법으로 매핑 문서 속에 정의될 수 있고 "
"정확하게 호출될 수도 있다. 이 경우에, 우리는 <literal>addEntity()</literal> "
"호출을 필요로 하지 <emphasis>않는다</emphasis>."

#. Tag: programlisting
#: query_sql.xml:368
#, no-c-format
msgid ""
"<![CDATA[<sql-query name=\"persons\">\n"
"    <return alias=\"person\" class=\"eg.Person\"/>\n"
"    SELECT person.NAME AS {person.name},\n"
"           person.AGE AS {person.age},\n"
"           person.SEX AS {person.sex}\n"
"    FROM PERSON person\n"
"    WHERE person.NAME LIKE :namePattern\n"
"</sql-query>]]>"
msgstr ""

#. Tag: programlisting
#: query_sql.xml:370
#, no-c-format
msgid ""
"<![CDATA[List people = sess.getNamedQuery(\"persons\")\n"
"    .setString(\"namePattern\", namePattern)\n"
"    .setMaxResults(50)\n"
"    .list();]]>"
msgstr ""

#. Tag: para
#: query_sql.xml:372
#, no-c-format
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 ""
"<literal>&lt;return-join&gt;</literal> 요소와 <literal>&lt;load-"
"collection&gt;</literal> 요소는 연관들을 조인시키고 콜렉션들을 각각 초기화 시"
"키는 질의들을 정의하는데 사용된다."

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

#. Tag: para
#: query_sql.xml:379
#, no-c-format
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 ""
"명명된 SQL 질의는 스칼라 값을 반환할수도 있다. 당신은 <literal>&lt;return-"
"scalar&gt;</literal> 요소를 사용하여 컬럼 alias와 Hibernate 타입을 선언해야 "
"한다:"

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

#. Tag: para
#: query_sql.xml:385
#, no-c-format
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 ""
"당신은 여러 개의 명명된 질의들을 가로질러 재사용하거나 "
"<literal>setResultSetMapping()</literal> API를 통해 결과셋 매핑정보들을 재사"
"용하기 위해 <literal>&lt;resultset&gt;</literal> 요소 속에 결과셋 매핑 정보들"
"을 구체화 시킬 수 있다."

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

#. Tag: para
#: query_sql.xml:392
#, no-c-format
msgid ""
"You can alternatively use the resultset mapping information in your hbm "
"files directly in java code."
msgstr ""
"다른방법으로 당신은 당신의 hbm 파일들 내에 직접 자바 코드로 된 결과셋 매핑 정"
"보를 사용할 수 있다."

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

#. Tag: title
#: query_sql.xml:398
#, no-c-format
msgid "Using return-property to explicitly specify column/alias names"
msgstr "명시적으로 column/alias 이름들을 지정하는데 return-property 사용하기"

#. Tag: para
#: query_sql.xml:401
#, 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 ""
"Hibernate로 하여금 그것 자신의 alias들을 끼워넣도록 하기 위해 <literal>{}</"
"literal>-구문을 사용하는 것 대신에, <literal>&lt;return-property&gt;</"
"literal>로서 당신은 사용할 컬럼 alias들이 무엇인지를 Hibernate에게 명시적으"
"로 알려줄 수 있다."

#. Tag: programlisting
#: query_sql.xml:406
#, 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:408
#, 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 ""
"<literal>&lt;return-property&gt;</literal>는 또한 다중 컬럼들에 대해 동작한"
"다. 이것은 다중-컬럼 프로퍼티들에 대한 fine grained 제어를 허용할 수 없는 "
"<literal>{}</literal>-구문을 가진 제약을 해결해준다."

#. Tag: programlisting
#: query_sql.xml:413
#, 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:415
#, 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 ""
"이 예제에서 우리는 끼워넣기(injection)를 위해 <literal>{}</literal>-구문과 함"
"께 <literal>&lt;return-property&gt;</literal>를 사용했음을 주목하라. 사용자들"
"이 컬럼과 프로퍼티들을 참조하고자 원하는 방법을 선택하는 것을 사용자들에게 허"
"용해줌으로써."

#. Tag: para
#: query_sql.xml:420
#, 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 ""
"만일 당신의 매핑이 한 개의 판별자(discriminator )를 가질 경우 당신은 판별자 "
"컬럼을 지정하는데 <literal>&lt;return-discriminator&gt;</literal>를 사용해야 "
"한다."

#. Tag: title
#: query_sql.xml:426
#, no-c-format
msgid "Using stored procedures for querying"
msgstr "질의를 위한 내장 프로시저 사용하기"

#. Tag: para
#: query_sql.xml:428
#, 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 ""
"Hibernate 3은 내장 프로시저들과 함수들을 통한 질의 지원을 도입한다. 대부분의 "
"다음 문서는 양자 모두에 동일하게 적용된다. 내장 프로시저/함수는 Hibernate와 "
"동작하는 것이 가능하도록 첫 번째 out-파라미터로서 한 개의 결과셋을 반환해야 "
"한다. Oracle9 이상의 버전에서 그런 내장 프로시저에 대한 예제는 다음과 같다:"

#. Tag: programlisting
#: query_sql.xml:434
#, 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:436
#, no-c-format
msgid "To use this query in Hibernate you need to map it via a named query."
msgstr ""
"Hibernate에서 이 질의를 사용하기 위해 당신은 하나의 명명된 질의(a named "
"query)를 통해 그것을 매핑할 필요가 있다."

#. Tag: programlisting
#: query_sql.xml:439
#, 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"