query_sql.po

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

msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2007-10-25 07:47+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <[e-mail]>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#. Tag: title
#: query_sql.xml:5
#, no-c-format
msgid "Native SQL"
msgstr "Native SQL"

#. Tag: para
#: query_sql.xml:7
#, no-c-format
msgid ""
"You may also express queries in the native SQL dialect of your database. "
"This is useful if you want to utilize database specific features such as "
"query hints or the <literal>CONNECT</literal> keyword in Oracle. It also "
"provides a clean migration path from a direct SQL/JDBC based application to "
"Hibernate."
msgstr ""
"당신은 또한 당신의 데이터베이스의 native SQL dialect로 질의들을 표현할 수도 "
"있다. 당신이 오라클의 질의 힌트들 또는 <literal>CONNECT</literal> 키워드와 같"
"은 데이터베이스 지정적인 특징들을 활용하고자 원할 경우에 이것이 유용하다. 그"
"것은 또한 직접적인 SQL/JDBC 기반의 어플리케이션으로부터 Hibernate로의 보다 명"
"료한 이전 경로를 제공한다."

#. Tag: para
#: query_sql.xml:13
#, no-c-format
msgid ""
"Hibernate3 allows you to specify handwritten SQL (including stored "
"procedures) for all create, update, delete, and load operations."
msgstr ""
"Hibernate3은 또한 모든 create, update, delete, load 오퍼레이션들에 대해 (내"
"장 프로시저들을 포함하여) 손으로 작성된 SQL을 지정하는 것을 당신에게 허용해준"
"다."

#. Tag: title
#: query_sql.xml:17
#, no-c-format
msgid "Using a <literal>SQLQuery</literal>"
msgstr "<literal>SQLQuery</literal> 사용하기"

#. Tag: para
#: query_sql.xml:19
#, no-c-format
msgid ""
"Execution of native SQL queries is controlled via the <literal>SQLQuery</"
"literal> interface, which is obtained by calling <literal>Session."
"createSQLQuery()</literal>. The following describes how to use this API for "
"querying."
msgstr ""
"native SQL 질의들의 실행은 <literal>SQLQuery</literal> 인터페이스를 통해 제어"
"되며, 그것은 <literal>Session.createSQLQuery()</literal>을 호출하여 획득된"
"다. 다음은 이 API를 질의에 사용하는 방법을 설명한다."

#. Tag: title
#: query_sql.xml:25
#, no-c-format
msgid "Scalar queries"
msgstr "스칼라 질의들"

#. Tag: para
#: query_sql.xml:27
#, no-c-format
msgid "The most basic SQL query is to get a list of scalars (values)."
msgstr "가장 기본적인 SQL 질의는 스칼라들(값들)의 목록을 얻는 것이다."

#. Tag: programlisting
#: query_sql.xml:30
#, no-c-format
msgid ""
"<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").list();\n"
"sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").list();\n"
"]]>"
msgstr ""

#. Tag: para
#: query_sql.xml:32
#, no-c-format
msgid ""
"These will both return a List of Object arrays (Object[]) with scalar values "
"for each column in the CATS table. Hibernate will use ResultSetMetadata to "
"deduce the actual order and types of the returned scalar values."
msgstr ""
"이것들은 둘다 CATS 테이블 내에 있는 각각의 컬럼에 대한 스칼라 값들을 가진 "
"Object 배열들의 List를 반환할 것이다. Hibernate는 반환되는 스칼라 값들의 실"
"제 순서와 타입들을 도출하는데 ResultSetMetadata를 사용할 것이다."

#. Tag: para
#: query_sql.xml:37
#, no-c-format
msgid ""
"To avoid the overhead of using <literal>ResultSetMetadata</literal> or "
"simply to be more explicit in what is returned one can use <literal>addScalar"
"()</literal>."
msgstr ""
"<literal>ResultSetMetadata</literal> 사용의 오버헤드를 피하거나 간단하게는 반"
"환되는 것을 보다 명시적이게끔 하기 위해 우리는 <literal>addScalar()</literal>"
"를 사용할 수 있다."

#. Tag: programlisting
#: query_sql.xml:41
#, no-c-format
msgid ""
"<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
" .addScalar(\"ID\", Hibernate.LONG)\n"
" .addScalar(\"NAME\", Hibernate.STRING)\n"
" .addScalar(\"BIRTHDATE\", Hibernate.DATE)\n"
"]]>"
msgstr ""

#. Tag: para
#: query_sql.xml:43 query_sql.xml:89 query_sql.xml:170 query_sql.xml:321
#, no-c-format
msgid "This query specified:"
msgstr "이 질의는 다음을 지정했다:"

#. Tag: para
#: query_sql.xml:47 query_sql.xml:93 query_sql.xml:325
#, no-c-format
msgid "the SQL query string"
msgstr "SQL 질의 문자열"

#. Tag: para
#: query_sql.xml:51
#, no-c-format
msgid "the columns and types to return"
msgstr "반환할 컬럼들과 타입들"

#. Tag: para
#: query_sql.xml:55
#, no-c-format
msgid ""
"This will still return Object arrays, but now it will not use "
"<literal>ResultSetMetdata</literal> but will instead explicitly get the ID, "
"NAME and BIRTHDATE column as respectively a Long, String and a Short from "
"the underlying resultset. This also means that only these three columns will "
"be returned, even though the query is using <literal>*</literal> and could "
"return more than the three listed columns."
msgstr ""
"이것은 여전히 Object 배열들을 반환할 것이지만, 이제 그것은 "
"<literal>ResultSetMetdata</literal>를 사용하지 않을 것이고 대신에 기반 결과셋"
"으로부터 ID, NAME 그리고 BIRTHDATE 컬럼을 각각 Long, String 그리고 Short 타입"
"으로 반환할 것이다. 심지어 그 질의가 <literal>*</literal>를 사용하고 세 개의 "
"열거된 컬럼들 보다 더 많은 것을 반환할 수 있을지라도, 이것은 또한 오직 이들 "
"세 개의 컬럼들 만이 반환될 것임을 의미한다."

#. Tag: para
#: query_sql.xml:63
#, no-c-format
msgid ""
"It is possible to leave out the type information for all or some of the "
"scalars."
msgstr "스칼라들 중 몇몇 또는 전부에 대한 타입 정보를 남겨두는 것이 가능하다."

#. Tag: programlisting
#: query_sql.xml:66
#, no-c-format
msgid ""
"<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
" .addScalar(\"ID\", Hibernate.LONG)\n"
" .addScalar(\"NAME\")\n"
" .addScalar(\"BIRTHDATE\")\n"
"]]>"
msgstr ""

#. Tag: para
#: query_sql.xml:68
#, no-c-format
msgid ""
"This is essentially the same query as before, but now "
"<literal>ResultSetMetaData</literal> is used to decide the type of NAME and "
"BIRTHDATE where as the type of ID is explicitly specified."
msgstr ""
"이것은 본질적으로 앞의 것과 동일한 질의이지만, 이제 "
"<literal>ResultSetMetaData</literal>는 ID의 타입이 명시적으로 지정되어 있으므"
"로 NAME과 BIRTHDATE의 타입을 결정하는데 사용된다."

#. Tag: para
#: query_sql.xml:72
#, no-c-format
msgid ""
"How the java.sql.Types returned from ResultSetMetaData is mapped to "
"Hibernate types is controlled by the Dialect. If a specific type is not "
"mapped or does not result in the expected type it is possible to customize "
"it via calls to <literal>registerHibernateType</literal> in the Dialect."
msgstr ""
"java.sql.Types returned from ResultSetMetaData이 Hibernate 타입들로 매핑되는 "
"방법은 Dialect에 의해 제어된다. 만일 특정 타입이 매핑되지 않거나 예상되는 타"
"입으로 귀결되지 않을 경우에 Dialect 내에 있는 "
"<literal>registerHibernateType</literal>에 대한 호출들을 통해 그것을 맞춤화 "
"시키는 것이 가능하다."

#. Tag: title
#: query_sql.xml:80
#, no-c-format
msgid "Entity queries"
msgstr "Entity 질의들"

#. Tag: para
#: query_sql.xml:82
#, no-c-format
msgid ""
"The above queries were all about returning scalar values, basically "
"returning the \"raw\" values from the resultset. The following shows how to "
"get entity objects from a native sql query via <literal>addEntity()</"
"literal>."
msgstr ""
"위의 질의들은 스칼라 값들을 반환하는 것, 결과셋들로부터 \"원래의\" 값들을 기"
"본적으로 반환하는 것에 대한 전부였다. 다음은 <literal>addEntity()</literal>"
"를 통해 native sql 질의로부터 엔티티 객체들을 얻는 방법을 보여준다."

#. Tag: programlisting
#: query_sql.xml:87
#, no-c-format
msgid ""
"<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").addEntity(Cat.class);\n"
"sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").addEntity(Cat."
"class);\n"
"]]>"
msgstr ""

#. Tag: para
#: query_sql.xml:97
#, no-c-format
msgid "the entity returned by the query"
msgstr "그 질의에 의해 반환되는 엔티티"

#. Tag: para
#: query_sql.xml:101
#, no-c-format
msgid ""
"Assuming that Cat is mapped as a class with the columns ID, NAME and "
"BIRTHDATE the above queries will both return a List where each element is a "
"Cat entity."
msgstr ""
"Cat이 컬럼 ID, NAME 그리고 BIRTHDATE로서 매핑된다고 가정하면, 위의 질의들은 "
"둘다 각각의 요소가 하나의 Cat 엔티티인 하나의 List를 반환할 것이다."

#. Tag: para
#: query_sql.xml:105
#, no-c-format
msgid ""
"If the entity is mapped with a <literal>many-to-one</literal> to another "
"entity it is required to also return this when performing the native query, "
"otherwise a database specific \"column not found\" error will occur. The "
"additional columns will automatically be returned when using the * notation, "
"but we prefer to be explicit as in the following example for a <literal>many-"
"to-one</literal> to a <literal>Dog</literal>:"
msgstr ""
"만일 그 엔티티가 또 다른 엔티티에 대해 <literal>many-to-one</literal>로 매핑"
"되어 있다면 또한 native 질의를 실행할 때 이것을 반환하는 것이 필수적고, 그 밖"
"의 경우 데이터베이스 지정적인 \"컬럼이 발견되지 않았습니다\" 오류가 일어날 것"
"이다. 추가적인 컬럼은 * 표기를 사용할 자동적으로 반환될 것이지만, 우리는 다"
"음 <literal>Dog</literal>에 대한 <literal>many-to-one</literal> 예제에서처럼 "
"명시적인 것을 더 선호한다:"

#. Tag: programlisting
#: query_sql.xml:113
#, no-c-format
msgid ""
"<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS"
"\").addEntity(Cat.class);\n"
"]]>"
msgstr ""

#. Tag: para
#: query_sql.xml:115
#, no-c-format
msgid "This will allow cat.getDog() to function properly."
msgstr "이것은 cat.getDog()이 고유하게 기능하는 것을 허용한다."

#. Tag: title
#: query_sql.xml:119
#, no-c-format
msgid "Handling associations and collections"
msgstr "연관들과 콜렉션들을 처리하기"

#. Tag: para
#: query_sql.xml:121
#, no-c-format
msgid ""
"It is possible to eagerly join in the <literal>Dog</literal> to avoid the "
"possible extra roundtrip for initializing the proxy. This is done via the "
"<literal>addJoin()</literal> method, which allows you to join in an "
"association or collection."
msgstr ""
"프락시를 초기화 시킴에 있어 가능한 특별한 라운드트립을 피하기 위해서 "
"<literal>Dog</literal>에서 eagerly join시키는 것이 간으하다. 이것은 "
"<literal>addJoin()</literal> 메소드를 통해 행해지는데, 그것은 연관이나 콜렉"
"션 내에서 조인시키는 것을 당신에게 허용해준다."

#. Tag: programlisting
#: query_sql.xml:126
#, no-c-format
msgid ""
"<![CDATA[sess.createSQLQuery(\"SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, "
"D_NAME FROM CATS c, DOGS d WHERE c.DOG_ID = d.D_ID\")\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addJoin(\"cat.dog\");\n"
"]]>"
msgstr ""

#. Tag: para
#: query_sql.xml:128
#, no-c-format
msgid ""
"In this example the returned <literal>Cat</literal>'s will have their "
"<literal>dog</literal> property fully initialized without any extra "
"roundtrip to the database. Notice that we added a alias name (\"cat\") to be "
"able to specify the target property path of the join. It is possible to do "
"the same eager joining for collections, e.g. if the <literal>Cat</literal> "
"had a one-to-many to <literal>Dog</literal> instead."
msgstr ""
"이 예제에서 반환되는 <literal>Cat</literal>들은 데이터베이스에 대한 임의의 특"
"별한 라운드크립 없이 전체적으로 초기화된 그것들의 <literal>dog</literal> 프로"
"퍼티를 갖는다. 우리가 join의 대상 프로퍼티 경로를 지정하는 것을 가능하도록 하"
"기 위해 하나의 alias 이름(\"cat\")을 추가했음을 주지하라. 대신에 예를 들어 "
"<literal>Cat</literal>이 <literal>Dog</literal>에 대해 one-to-many를 가질 경"
"우, 콜렉션들에 대해 동일한 eager joining을 행하는 것이 가능하다."

#. Tag: programlisting
#: query_sql.xml:136
#, no-c-format
msgid ""
"<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, "
"CAT_ID FROM CATS c, DOGS d WHERE c.ID = d.CAT_ID\")\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addJoin(\"cat.dogs\");\n"
"]]>"
msgstr ""

#. Tag: para
#: query_sql.xml:138
#, no-c-format
msgid ""
"At this stage we are reaching the limits of what is possible with native "
"queries without starting to enhance the sql queries to make them usable in "
"Hibernate; the problems starts to arise when returning multiple entities of "
"the same type or when the default alias/column names are not enough."
msgstr ""
"이 단계에서 우리는 Hibernate에서 native 질의들을 사용가능하도록 만들기 위해 "
"sql 질의들을 강화시키지는 것을 시작하지 않고서도 native 질의들로서 가능한 것"
"의 한계에 도달하고 있다; 문제점들은 동일한 타입의 여러 엔티티들을 반환할 때 "
"또는 디폴트 alias/column 이름들이 충분하지 않을 때 발생하기 시작한다."

#. Tag: title
#: query_sql.xml:146
#, no-c-format
msgid "Returning multiple entities"
msgstr "여러 개의 엔티티들을 반환하기"

#. Tag: para
#: query_sql.xml:148
#, no-c-format
msgid ""
"Until now the result set column names are assumed to be the same as the "
"column names specified in the mapping document. This can be problematic for "
"SQL queries which join multiple tables, since the same column names may "
"appear in more than one table."
msgstr ""