Hibernate example source code file (query_sql.po)

This example Hibernate source code file (query_sql.po) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Hibernate tags/keywords

cat, hibernate, hibernate, id, name, oracle, sql, sql, tag, tag, the, the, this, you

The Hibernate query_sql.po source code

msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-02-04T04:51:22\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You can 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 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 키워드와 같"
"은 데이터베이스 지정적인 특징들을 활용하고자 원할 경우에 이것이 유용하다. 그"
"것은 또한 직접적인 SQL/JDBC 기반의 어플리케이션으로부터 Hibernate로의 보다 명"
"료한 이전 경로를 제공한다."

#. Tag: para
#, fuzzy, 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
#, no-c-format
msgid "Using a <literal>SQLQuery"
msgstr "<literal>SQLQuery 사용하기"

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

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

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

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

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

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

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"This will return Object arrays, but now it will not use "
"<literal>ResultSetMetadata 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>* and could "
"return more than the three listed columns."
msgstr ""
"이것은 여전히 Object 배열들을 반환할 것이지만, 이제 그것은 "
"<literal>ResultSetMetdata를 사용하지 않을 것이고 대신에 기반 결과셋"
"으로부터 ID, NAME 그리고 BIRTHDATE 컬럼을 각각 Long, String 그리고 Short 타입"
"으로 반환할 것이다. 심지어 그 질의가 <literal>*를 사용하고 세 개의 "
"열거된 컬럼들 보다 더 많은 것을 반환할 수 있을지라도, 이것은 또한 오직 이들 "
"세 개의 컬럼들 만이 반환될 것임을 의미한다."

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

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

#. Tag: para
#, fuzzy, 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 in the Dialect."
msgstr ""
"java.sql.Types returned from ResultSetMetaData이 Hibernate 타입들로 매핑되는 "
"방법은 Dialect에 의해 제어된다. 만일 특정 타입이 매핑되지 않거나 예상되는 타"
"입으로 귀결되지 않을 경우에 Dialect 내에 있는 "
"<literal>registerHibernateType에 대한 호출들을 통해 그것을 맞춤화 "
"시키는 것이 가능하다."

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

#. Tag: para
#, 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()"
"를 통해 native sql 질의로부터 엔티티 객체들을 얻는 방법을 보여준다."

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

#. Tag: para
#, 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
#, no-c-format
msgid ""
"If the entity is mapped with a <literal>many-to-one 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 Dog:"
msgstr ""
"만일 그 엔티티가 또 다른 엔티티에 대해 <literal>many-to-one로 매핑"
"되어 있다면 또한 native 질의를 실행할 때 이것을 반환하는 것이 필수적고, 그 밖"
"의 경우 데이터베이스 지정적인 \"컬럼이 발견되지 않았습니다\" 오류가 일어날 것"
"이다. 추가적인 컬럼은 * 표기를 사용할 자동적으로 반환될 것이지만, 우리는 다"
"음 <literal>Dog에 대한 many-to-one 예제에서처럼 "
"명시적인 것을 더 선호한다:"

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

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

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"In this example, the returned <literal>Cat's will have their "
"<literal>dog property fully initialized without any extra "
"roundtrip to the database. Notice that you added an 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>CatDog instead."
msgstr ""
"이 예제에서 반환되는 <literal>Cat들은 데이터베이스에 대한 임의의 특"
"별한 라운드크립 없이 전체적으로 초기화된 그것들의 <literal>dog 프로"
"퍼티를 갖는다. 우리가 join의 대상 프로퍼티 경로를 지정하는 것을 가능하도록 하"
"기 위해 하나의 alias 이름(\"cat\")을 추가했음을 주지하라. 대신에 예를 들어 "
"<literal>Cat이 Dog에 대해 one-to-many를 가질 경"
"우, 콜렉션들에 대해 동일한 eager joining을 행하는 것이 가능하다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"At this stage you are reaching the limits of what is possible with native "
"queries, without starting to enhance the sql queries to make them usable in "
"Hibernate. Problems can 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
#, no-c-format
msgid "Returning multiple entities"
msgstr "여러 개의 엔티티들을 반환하기"

#. Tag: para
#, fuzzy, 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 that join multiple tables, since the same column names can "
"appear in more than one table."
msgstr ""
"지금까지 결과 셋 컬럼 이름들은 매핑 문서 내에 지정된 컬럼 이름들과 동일하다"
"고 가정되어 있다. 동일한 컬럼이 하나 이상의 테이블 내에서 나타날 수 있기 때문"
"에, 이것은 여러 개의 테이블들을 조인시키는 SQL 질의들에 대해 문제가 될 수 있"
"다."

#. Tag: para
#, no-c-format
msgid ""
"Column alias injection is needed in the following query (which most likely "
"will fail):"
msgstr "컬럼 alias 주입은 다음 질의(아마 실패할 것이다)에서 필요하다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The query was intended to return two Cat instances per row: a cat and its "
"mother. The query will, however, fail because there is a conflict of names; "
"the instances are mapped to the same column names. Also, on some databases "
"the returned column aliases will most likely be on the form \"c.ID\", \"c."
"NAME\", etc. which are not equal to the columns specified in the mappings "
"(\"ID\" and \"NAME\")."
msgstr ""
"이 질의의 목적은 단위 행 당 두 개의 Cat 인스턴스들, 하나의 cat 그리고 그것의 "
"mother를 반환하는 것이다. 왜냐하면 그것들이 동일한 컬럼 이름들로 매핑되어 있"
"기 때문에 이것은 실패할 것이고 데이베이스 상에서 반환된 컬럼 alias들은 아마 "
"매핑들 내에 지정된 컬럼들(\"ID\" 와 \"NAME\")과 같지 않은 \"c.ID\", \"c.NAME"
"\" 등의 형식일 것이다."

#. Tag: para
#, no-c-format
msgid "The following form is not vulnerable to column name duplication:"
msgstr "다음 형식은 컬럼 이름 중복 취약점을 갖지 않는다:"

#. Tag: para
#, no-c-format
msgid ""
"the SQL query string, with placeholders for Hibernate to inject column "
"aliases"
msgstr ""
"컬럼 alias들을 주입하기 위한 Hibernate용 placeholder들을 가진 SQL 질의 문자열"

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The {cat.*} and {mother.*} notation used above is a shorthand for \"all "
"properties\". Alternatively, you can list the columns explicitly, but even "
"in this case Hibernate injects the SQL column aliases for each property. The "
"placeholder for a column alias is just the property name qualified by the "
"table alias. In the following example, you retrieve Cats and their mothers "
"from a different table (cat_log) to the one declared in the mapping "
"metadata. You can even use the property aliases in the where clause."
msgstr ""
"위에 사용된 {cat.*} 과 {mother.*} 표기는 \"모든 프로퍼티들\"에 대한 생략이"
"다. 다른 방법으로 당신은 컬럼들을 명시적으로 열거할 수도 있지만, 이 경우에 우"
"리는 Hibernate로 하여금 SQL 컬럼 alias들을 각각의 컬럼에 주입시키도록 강제한"
"다. 컬럼 alias를 위한 placeholder는 단지 그 테이블 alias에 의해 수식된 프로퍼"
"티 이름이다. 다음 예제에서, 우리는 다른 테이블(cat_log)로부터 매핑 메타데이"
"터 내에 선언된 것으로의 Cat들과 그것들의 mother들을 검색한다. 우리는 우리가 "
"좋다면 심지어 where 절 내에 프로퍼티 alias를 사용할 수도 있음을 주지하라."

#. Tag: title
#, no-c-format
msgid "Alias and property references"
msgstr "alias 참조와 프로퍼티 참조"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"In most cases the above alias injection is needed. For queries relating to "
"more complex mappings, like composite properties, inheritance "
"discriminators, collections etc., you can use specific aliases that allow "
"Hibernate to inject the proper aliases."
msgstr ""
"대부분의 경우에 위의 alias 주입이 필요하지만, composite 프로퍼티들, 상속 판별"
"자들 (inheritance discriminators), 콜렉션 등과 같은 보다 복잡한 매핑들과 관련"
"된 질의들의 경우에는 고유한 alias들을 주입시키는 것을 Hibernate에게 허용하는"
"데 사용될 몇몇 특별한 alias들이 존재한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The following table shows the different ways you can use the alias "
"injection. Please note that the alias names in the result are simply "
"examples; each alias will have a unique and probably different name when "
"used."
msgstr ""
"다음 테이블은 alias 주입을 사용하는 다른 가능성들을 보여준다. 노트: 결과 내"
"에 있는 alias 이름들이 예제이며, 각각의 alias는 사용될 때 하나의 유일한 이름"
"과 아마 다른 이름을 가질 것이다."

#. Tag: title
#, no-c-format
msgid "Alias injection names"
msgstr "alias 주입 이름들"

#. Tag: entry
#, no-c-format
msgid "Description"
msgstr "설명"

#. Tag: entry
#, no-c-format
msgid "Syntax"
msgstr "구문"

#. Tag: entry
#, no-c-format
msgid "Example"
msgstr "예제"

#. Tag: entry
#, no-c-format
msgid "A simple property"
msgstr "간단한 프로퍼티"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>{[aliasname].[propertyname]"
msgstr "{[aliasname].[propertyname]"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>A_NAME as {item.name}"
msgstr "A_NAME as {item.name}"

#. Tag: entry
#, no-c-format
msgid "A composite property"
msgstr "composite 프로퍼티"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>{[aliasname].[componentname].[propertyname]}"
msgstr "{[aliasname].[componentname].[propertyname]}"

#. Tag: entry
#, fuzzy, no-c-format
msgid ""
"<literal>CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
msgstr "{[aliasname].class}"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>DISC as {item.class}"
msgstr "DISC as {item.class}"

#. Tag: entry
#, no-c-format
msgid "All properties of an entity"
msgstr "엔티티의 모든 프로퍼티들"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>{[aliasname].*}"
msgstr "{[aliasname].*}"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>{item.*}"
msgstr "<literal>SQLQuery 사용하기"

#. Tag: entry
#, no-c-format
msgid "A collection key"
msgstr "콜렉션 키"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>{[aliasname].key}"
msgstr "{[aliasname].key}"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>ORGID as {coll.key}"
msgstr "ORGID as {coll.key}"

#. Tag: entry
#, no-c-format
msgid "The id of an collection"
msgstr "콜렉션의 id"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>{[aliasname].id}"
msgstr "{[aliasname].id}"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>EMPID as {coll.id}"
msgstr "EMPID as {coll.id}"

#. Tag: entry
#, no-c-format
msgid "The element of an collection"
msgstr "콜렉션의 요소"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>{[aliasname].element}"
msgstr "{[aliasname].element}"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>XID as {coll.element}"
msgstr "XID as {coll.element}"

#. Tag: entry
#, fuzzy, no-c-format
msgid "property of the element in the collection"
msgstr "콜렉션 내에 있는 요소의 프로퍼티"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>{[aliasname].element.[propertyname]}"
msgstr "{[aliasname].element.[propertyname]}"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>NAME as {coll.element.name}"
msgstr "NAME as {coll.element.name}"

#. Tag: entry
#, no-c-format
msgid "All properties of the element in the collection"
msgstr "콜렉션 내에 있는 요소의 모든 프로퍼티들"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>{[aliasname].element.*}"
msgstr "{[aliasname].element.*}"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>{coll.element.*}"
msgstr "{coll.element.*}"

#. Tag: entry
#, no-c-format
msgid "All properties of the the collection"
msgstr "콜렉션의 모든 프로퍼티들"

#. Tag: entry
#, fuzzy, no-c-format
msgid "<literal>{coll.*}"
msgstr "<literal>SQLQuery 사용하기"

#. Tag: title
#, no-c-format
msgid "Returning non-managed entities"
msgstr "non-managed 엔티티들을 반환하기"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"It is possible to apply a ResultTransformer to native SQL queries, allowing "
"it to return non-managed entities."
msgstr ""
"native sql 질의에 ResultTransformer를 적용하는 것이 가능하다. 예를 들어 non-"
"managed 엔티티들을 반환하기 위해 ResultTransformer를 허용하는 것."

#. Tag: para
#, no-c-format
msgid "a result transformer"
msgstr "결과 변환자(transformer)"

#. Tag: para
#, no-c-format
msgid ""
"The above query will return a list of <literal>CatDTO which has "
"been instantiated and injected the values of NAME and BIRTHNAME into its "
"corresponding properties or fields."
msgstr ""
"위의 질의는 초기화되어 있고 NAME과 BIRTHNAME의 값들을 <literal>CatDTOCatDTO need to call addEntity()."
msgstr ""
"명명된 SQL 질의들은 HQL 질의와 동일한 방법으로 매핑 문서 속에 정의될 수 있고 "
"정확하게 호출될 수도 있다. 이 경우에, 우리는 <literal>addEntity() "
"호출을 필요로 하지 <emphasis>않는다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal><return-join> element is use to join "
"associations and the <literal><load-collection> element is "
"used to define queries which initialize collections,"
msgstr ""
"<literal><return-join> 요소와 <load-"
"collection></literal> 요소는 연관들을 조인시키고 콜렉션들을 각각 초기화 시"
"키는 질의들을 정의하는데 사용된다."

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You can externalize the resultset mapping information in a <literal><"
"resultset></literal> element which will allow you to either reuse them "
"across several named queries or through the <literal>setResultSetMapping() API를 통해 결과셋 매핑정보들을 재사"
"용하기 위해 <literal><resultset> 요소 속에 결과셋 매핑 정보들"
"을 구체화 시킬 수 있다."

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

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You can explicitly tell Hibernate what column aliases to use with "
"<literal><return-property>, instead of using the {}"
"</literal>-syntax to let Hibernate inject its own aliases.For example:"
msgstr ""
"Hibernate로 하여금 그것 자신의 alias들을 끼워넣도록 하기 위해 <literal>{}<return-property> also works with multiple columns. "
"This solves a limitation with the <literal>{}-syntax which cannot "
"allow fine grained control of multi-column properties."
msgstr ""
"<literal><return-property>는 또한 다중 컬럼들에 대해 동작한"
"다. 이것은 다중-컬럼 프로퍼티들에 대한 fine grained 제어를 허용할 수 없는 "
"<literal>{}-구문을 가진 제약을 해결해준다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"In this example <literal><return-property> was used in "
"combination with the <literal>{}-syntax for injection. This allows "
"users to choose how they want to refer column and properties."
msgstr ""
"이 예제에서 우리는 끼워넣기(injection)를 위해 <literal>{}-구문과 함"
"께 <literal><return-property>를 사용했음을 주목하라. 사용자들"
"이 컬럼과 프로퍼티들을 참조하고자 원하는 방법을 선택하는 것을 사용자들에게 허"
"용해줌으로써."

#. Tag: para
#, no-c-format
msgid ""
"If your mapping has a discriminator you must use <literal><return-"
"discriminator></literal> to specify the discriminator column."
msgstr ""
"만일 당신의 매핑이 한 개의 판별자(discriminator )를 가질 경우 당신은 판별자 "
"컬럼을 지정하는데 <literal><return-discriminator>를 사용해야 "
"한다."

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Hibernate3 provides 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: para
#, 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: para
#, fuzzy, no-c-format
msgid ""
"Stored procedures currently only return scalars and entities. <literal><"
"return-join></literal> and <load-collection> are "
"not supported."
msgstr ""
"내장 프로시저들은 현재 스칼라들과 엔티티들 만을 반환함을 주목하라. "
"<literal><return-join>ê³¼ <load-collection>. The rules are "
"different for each database, since database vendors have different stored "
"procedure semantics/syntax."
msgstr ""
"Hibernate에서 내장 프로시저들을 사용하기 위해서 프로시저들/함수들은 다음 몇"
"몇 규칙들을 따라야 한다. 만일 그것들이 그들 규칙들을 따르지 않을 경우 그것들"
"은 Hibernate와 함께 사용 불가능하다. 만일 당신이 여전히 이들 프로시저들을 사"
"용하고자 원할 경우, 당신은 <literal>session.connection()을 통해 그"
"것들을 실행시켜야 한다. 데이터베이스 벤더들이 다른 내장 프로시저 의미론/구문"
"을 갖고 있기 때문에, 규칙들은 각각의 데이터베이스에 따라 차이가 난다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Stored procedure queries cannot be paged with <literal>setFirstResult()/"
"setMaxResults()</literal>."
msgstr ""
"내장 프로시저 질의들은 <literal>setFirstResult()/setMaxResults()로"
"서 쪽매김 될 수 없다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The recommended call form is standard SQL92: <literal>{ ? = call functionName"
"(<parameters>) }</literal> or { ? = call procedureName(<"
"parameters>}</literal>. Native call syntax is not supported."
msgstr ""
"권장되는 호출 형식은 표준 SQL92이다: <literal>{ ? = call functionName(<"
"parameters>) }</literal> 또는 { ? = call procedureName(<"
"parameters>}</literal>. Native 호출 구문은 지원되지 않는다."

#. Tag: para
#, no-c-format
msgid "For Oracle the following rules apply:"
msgstr "Oracle의 경우 다음 규칙들이 적용된다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A function must return a result set. The first parameter of a procedure must "
"be an <literal>OUT that returns a result set. This is done by "
"using a <literal>SYS_REFCURSOR type in Oracle 9 or 10. In Oracle "
"you need to define a <literal>REF CURSOR type. See Oracle "
"literature for further information."
msgstr ""
"하나의 함수는 하나의 결과 셋을 반환해야 한다. 프로시저의 첫 번째 파라미터는 "
"하나의 결과 셋을 반환하는 하나의 <literal>OUT이어야 한다. 이것은 "
"Oracle 9 또는 10에서 하나의 <literal>SYS_REFCURSOR를 사용하여 행해"
"진다. Oracle에서 당신은 <literal>REF CURSOR 타입을 정의할 필요가 있"
"는데, Oracle 보고서를 보라."

#. Tag: para
#, no-c-format
msgid "For Sybase or MS SQL server the following rules apply:"
msgstr "Sybase 또는 MS SQL server의 경우 다음 규칙들이 적용된다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The procedure must return a result set. Note that since these servers can "
"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 ""
"프로시저는 한 개의 결과 셋을 반환해야 한다. 이들 서버들이 여러 개의 결과셋들"
"과 업데이트 카운트들을 반환 할수 있다/할 것이이므로, Hibernate는 결과들을 반"
"복 순환할 것이고 그것의 반환 값으로서 하나의 결과 셋인 첫 번째 결과를 취할 것"
"이다. 그 밖의 모든 것은 폐기될 것이다."

#. Tag: para
#, no-c-format
msgid ""
"If you can enable <literal>SET NOCOUNT ON in your procedure it "
"will probably be more efficient, but this is not a requirement."
msgstr ""
"만일 당신이 당신의 프로시저 내에 <literal>SET NOCOUNT ON을 이용 가"
"능하게 할 수 있다면 그것은 아마 보다 효율적이게 될 것이지만 이것은 필요 조건"
"이 아니다."

#. Tag: title
#, no-c-format
msgid "Custom SQL for create, update and delete"
msgstr "create, update 그리고 delete를 위한 맞춤형 SQL"

#. Tag: para
#, no-c-format
msgid ""
"Hibernate3 can use custom SQL for create, update, and delete operations. The "
"SQL can be overridden at the statement level or inidividual column level. "
"This section describes statement overrides. For columns, see <xref linkend="
"\"mapping-column-read-and-write\" />."
msgstr ""

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The class and collection persisters in Hibernate already contain a set of "
"configuration time generated strings (insertsql, deletesql, updatesql etc.). "
"The mapping tags <literal><sql-insert>, <sql-"
"delete></literal>, and <sql-update> override "
"these strings:"
msgstr ""
"Hibernate3는 create, update, delete 오퍼레이션들을 위한 맞춤형 문장들을 사용"
"할 수 있다. Hibernate에서 클래스와 콜렉션 영속자들은 구성 시에 생성된 문자열"
"들의 집합(insertsql, deletesql, updatesql 등)을 이미 포함하고 있다. "
"<literal><sql-insert>, <sql-delete><sql-update> 매핑 태그들은 이들 문자열들"
"을 오버라이드 시킨다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The SQL is directly executed in your database, so you can use any dialect "
"you like. This will reduce the portability of your mapping if you use "
"database specific SQL."
msgstr ""
"SQL이 당신의 데이터베이스 내에서 직접 실행되어서, 당신이 좋아하는 임의의 "
"dialect를 사용하는 것이 자유롭다. 만일 당신이 데이터베이스 지정적인 SQL을 사"
"용할 경우 이것은 물론 당신의 매핑의 이식성을 감소시킬 것이다."

#. Tag: para
#, no-c-format
msgid ""
"Stored procedures are supported if the <literal>callable attribute "
"is set:"
msgstr ""
"만일 <literal>callable 속성이 설정되면 내장 프로시저들이 지원된다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The order of the positional parameters is vital, as they must be in the same "
"sequence as Hibernate expects them."
msgstr ""
"위치 파라미터들은 Hibernate가 그것들을 기대하는 것과 같은 순서가 되어야 하므"
"로, 위치 파라미터들의 순서는 현재 절대적으로 중요하다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You can view the expected order by enabling debug logging for the "
"<literal>org.hibernate.persister.entity level. With this level "
"enabled, Hibernate will print out the static SQL that is used to create, "
"update, delete etc. entities. To view the expected sequence, do not include "
"your custom SQL in the mapping files, as this will override the Hibernate "
"generated static SQL."
msgstr ""
"당신은 <literal>org.hiberate.persister.entity 레벨로 디버그 로깅을 "
"사용 가능하게 함으로써 예상된 순서를 볼 수 있다. 이 레벨을 이용 가능하게 하"
"면 Hibernate는 엔티티들을 생성시키고, 업데이트하고, 삭제하는데 사용되는 정적"
"인 SQL을 출력할 것이다. (예상되는 결과를 보려면, Hibernate 생성된 정적인 sql"
"을 오버라이드 시키게 매핑 파일들 속에 당신의 맞춤형 SQL을 포함시키지 않도록 "
"염두에 두라.)"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The stored procedures are in most cases required to return the number of "
"rows inserted, updated and 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 ""
"Hibernate가 문장의 성공을 위해 몇몇 실행 시 체크들을 행하므로, 내장 프로시저"
"들은 대부분의 경우들(읽기:다른 경우들 보다 그것을 더 잘 행한다)에서 insert되"
"고/업데이트되고/삭제된 행들의 개수를 반환하는데 필요하다. Hibernate는 항상 "
"CUD 오퍼레이션들에 대한 숫자 출력 파라미터로서 첫 번째 문장 파라미터를 등록시"
"킨다:"

#. Tag: title
#, no-c-format
msgid "Custom SQL for loading"
msgstr "로딩을 위한 맞춤형 SQL"

#. Tag: para
#, no-c-format
msgid ""
"You can also declare your own SQL (or HQL) queries for entity loading. As "
"with inserts, updates, and deletes, this can be done at the individual "
"column level as described in <xref linkend=\"mapping-column-read-and-write"
"\" /> or at the statement level. Here is an example of a statement level "
"override:"
msgstr ""

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"This is just a named query declaration, as discussed earlier. You can "
"reference this named query in a class mapping:"
msgstr ""
"이것은 앞서 논의했듯이 단지 명명된 질의 선언이다. 당신은 class 매핑 속에 이 "
"명명된 질의를 참조할 수 있다:"

#. Tag: para
#, no-c-format
msgid "This even works with stored procedures."
msgstr "이것은 심지어 내장 프로시저들에 동작한다."

#. Tag: para
#, fuzzy, no-c-format
msgid "You can even define a query for collection loading:"
msgstr "당신은 콜렉션 로딩을 위한 한 개의 질의를 정의할 수도 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You can also define an entity loader that loads a collection by join "
"fetching:"
msgstr ""
"당신은 심지어 조인 페칭에 의해 하나의 콜렉션을 로드시키는 하나의 엔티티를 정"
"의할 수 있다:"

#~ msgid "{item.*}"
#~ msgstr "{item.*}"

#~ msgid "{coll.*}"
#~ msgstr "{coll.*}"

#, fuzzy
#~ msgid ""
#~ "You can also declare your own SQL (or HQL) queries for entity loading:"
#~ msgstr ""
#~ "당신은 또한 엔티티 로딩을 위한 당신 자신의 SQL (또는 HQL)을 선언할 수도 있"
#~ "다:"