query_hql.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_hql.xml:5
#, no-c-format
msgid "HQL: The Hibernate Query Language"
msgstr "HQL: 하이버네이트 질의 언어(Hibernate Query Language)"

#. Tag: para
#: query_hql.xml:7
#, no-c-format
msgid ""
"Hibernate is equipped with an extremely powerful query language that (quite "
"intentionally) looks very much like SQL. But don't be fooled by the syntax; "
"HQL is fully object-oriented, understanding notions like inheritence, "
"polymorphism and association."
msgstr ""
"Hibernate는 (아주 의도적으로) SQL과 매우 흡사하게 보이는 극히 강력한 질의 언"
"어를 구비하고 있다. 그러나 그 구문에 의해 우롱당하지 말라; HQL은 상속, 다형"
"성 그리고 연관과 같은 개념들을 이해하여서, 전체적으로 객체 지향적이다."

#. Tag: title
#: query_hql.xml:14
#, no-c-format
msgid "Case Sensitivity"
msgstr "대소문자 구분"

#. Tag: para
#: query_hql.xml:16
#, no-c-format
msgid ""
"Queries are case-insensitive, except for names of Java classes and "
"properties. So <literal>SeLeCT</literal> is the same as <literal>sELEct</"
"literal> is the same as <literal>SELECT</literal> but <literal>org.hibernate."
"eg.FOO</literal> is not <literal>org.hibernate.eg.Foo</literal> and "
"<literal>foo.barSet</literal> is not <literal>foo.BARSET</literal>."
msgstr ""
"질의들은 Java 클래스들과 프로퍼티들의 이름들을 제외하면 대소문자를 구분하지 "
"않는다. 따라서 <literal>SeLeCT</literal>는 <literal>SELECT</literal>와 같고 "
"<literal>SELECT</literal>와도 같지만 <literal>org.hibernate.eg.FOO</literal>"
"는 <literal>org.hibernate.eg.Foo</literal>과 같지 않고 <literal>foo.barSet</"
"literal>은 <literal>foo.BARSET</literal>과 같지 않다."

#. Tag: para
#: query_hql.xml:27
#, no-c-format
msgid ""
"This manual uses lowercase HQL keywords. Some users find queries with "
"uppercase keywords more readable, but we find this convention ugly when "
"embedded in Java code."
msgstr ""
"이 매뉴얼은 소문자 HQL 키워드를 사용한다. 몇몇 사용자들은 보다 나은 가독성을 "
"위해 대문자 키워드들을 가진 질의들을 찾지만, 우리는 자바 코드 속에 삽입될 때 "
"이 컨벤션이 추하다는 점을 발견한다."

#. Tag: title
#: query_hql.xml:35
#, no-c-format
msgid "The from clause"
msgstr "from 절"

#. Tag: para
#: query_hql.xml:37
#, no-c-format
msgid "The simplest possible Hibernate query is of the form:"
msgstr "가장 간단한 가능한 Hibernate 질의는 다음 형식이다:"

#. Tag: programlisting
#: query_hql.xml:41
#, no-c-format
msgid "<![CDATA[from eg.Cat]]>"
msgstr ""

#. Tag: para
#: query_hql.xml:43
#, no-c-format
msgid ""
"which simply returns all instances of the class <literal>eg.Cat</literal>. "
"We don't usually need to qualify the class name, since <literal>auto-import</"
"literal> is the default. So we almost always just write:"
msgstr ""
"이것은 <literal>eg.Cat</literal> 클래스의 모든 인스턴스들을 간단하게 반환한"
"다. 우리는 대개 클래스 이름을 수식할 필요가 없다. 왜냐하면, <literal>auto-"
"import</literal>가 디폴트이기 때문이다. 따라서 우리는 대개 항상 단지 다음과 "
"같이 작성한다:"

#. Tag: programlisting
#: query_hql.xml:49
#, no-c-format
msgid "<![CDATA[from Cat]]>"
msgstr ""

#. Tag: para
#: query_hql.xml:51
#, no-c-format
msgid ""
"Most of the time, you will need to assign an <emphasis>alias</emphasis>, "
"since you will want to refer to the <literal>Cat</literal> in other parts of "
"the query."
msgstr ""
"대개 당신은 한 개의 <emphasis>alias</emphasis>를 할당할 필요가 있을 것이다. "
"왜냐하면 당신은 질의의 다른 부분들에서 <literal>Cat</literal>을 참조하고자 원"
"할 것이기 때문이다."

#. Tag: programlisting
#: query_hql.xml:57 query_hql.xml:372
#, no-c-format
msgid "<![CDATA[from Cat as cat]]>"
msgstr ""

#. Tag: para
#: query_hql.xml:59
#, no-c-format
msgid ""
"This query assigns the alias <literal>cat</literal> to <literal>Cat</"
"literal> instances, so we could use that alias later in the query. The "
"<literal>as</literal> keyword is optional; we could also write:"
msgstr ""
"이 질의는 alias <literal>cat</literal>을 <literal>Cat</literal> 인스턴스들에 "
"할당하여서, 우리는 나중에 질의 속에서 그 alias를 사용할 수 있을 것이다. "
"<literal>as</literal> 키워드는 옵션이다; 우리는 또한 다음과 같이 작성할 수 있"
"다:"

#. Tag: programlisting
#: query_hql.xml:65
#, no-c-format
msgid "<![CDATA[from Cat cat]]>"
msgstr ""

#. Tag: para
#: query_hql.xml:67
#, no-c-format
msgid ""
"Multiple classes may appear, resulting in a cartesian product or \"cross\" "
"join."
msgstr ""
"여러 개의 클래스들은 cartesian product(카티젼 곱) 또는 \"크로스\" 조인으로 귀"
"결되어 나타날 수도 있다."

#. Tag: programlisting
#: query_hql.xml:71
#, no-c-format
msgid "<![CDATA[from Formula, Parameter]]>"
msgstr ""

#. Tag: programlisting
#: query_hql.xml:72
#, no-c-format
msgid "<![CDATA[from Formula as form, Parameter as param]]>"
msgstr ""

#. Tag: para
#: query_hql.xml:74
#, no-c-format
msgid ""
"It is considered good practice to name query aliases using an initial "
"lowercase, consistent with Java naming standards for local variables (eg. "
"<literal>domesticCat</literal>)."
msgstr ""
"로컬 변수들에 대한 Java 네이밍 표준들과 일치되게, 첫 소문자를 사용하여 질의 "
"alias들을 명명하는 것은 좋은 습관으로 간주된다 (예를 들면 "
"<literal>domesticCat</literal>)."

#. Tag: title
#: query_hql.xml:83
#, no-c-format
msgid "Associations and joins"
msgstr "연관들과 조인들"

#. Tag: para
#: query_hql.xml:85
#, no-c-format
msgid ""
"We may also assign aliases to associated entities, or even to elements of a "
"collection of values, using a <literal>join</literal>."
msgstr ""
"우리는 또한 <literal>join</literal>을 사용하여 , 연관된 엔티티들에 또는 값들"
"을 가진 콜렉션의 요소들에도 alias들을 할당할 수도 있다."

#. Tag: programlisting
#: query_hql.xml:90
#, no-c-format
msgid ""
"<![CDATA[from Cat as cat\n"
"    inner join cat.mate as mate\n"
"    left outer join cat.kittens as kitten]]>"
msgstr ""

#. Tag: programlisting
#: query_hql.xml:92
#, no-c-format
msgid "<![CDATA[from Cat as cat left join cat.mate.kittens as kittens]]>"
msgstr ""

#. Tag: programlisting
#: query_hql.xml:94
#, no-c-format
msgid "<![CDATA[from Formula form full join form.parameter param]]>"
msgstr ""

#. Tag: para
#: query_hql.xml:96
#, no-c-format
msgid "The supported join types are borrowed from ANSI SQL"
msgstr "지원되는 join 타입들은 ANSI SQL로부터 빌려왔다"

#. Tag: literal
#: query_hql.xml:103
#, no-c-format
msgid "inner join"
msgstr "inner join"

#. Tag: literal
#: query_hql.xml:108
#, no-c-format
msgid "left outer join"
msgstr "left outer join"

#. Tag: literal
#: query_hql.xml:113
#, no-c-format
msgid "right outer join"
msgstr "right outer join"

#. Tag: para
#: query_hql.xml:117
#, no-c-format
msgid "<literal>full join</literal> (not usually useful)"
msgstr "<literal>full join</literal> (대개 유용하지 않음)"

#. Tag: para
#: query_hql.xml:123
#, no-c-format
msgid ""
"The <literal>inner join</literal>, <literal>left outer join</literal> and "
"<literal>right outer join</literal> constructs may be abbreviated."
msgstr ""
"<literal>inner join</literal>, <literal>left outer join</literal>, 그리고 "
"<literal>right outer join</literal> 구조체들이 약칭될 수 있다."

#. Tag: programlisting
#: query_hql.xml:128
#, no-c-format
msgid ""
"<![CDATA[from Cat as cat\n"
"    join cat.mate as mate\n"
"    left join cat.kittens as kitten]]>"
msgstr ""

#. Tag: para
#: query_hql.xml:130
#, no-c-format
msgid ""
"You may supply extra join conditions using the HQL <literal>with</literal> "
"keyword."
msgstr ""
"당신은 HQL <literal>with</literal> 키워드를 사용하여 특별한 조인 조건들을 제"
"공할 수 있다."

#. Tag: programlisting
#: query_hql.xml:135
#, no-c-format
msgid ""
"<![CDATA[from Cat as cat\n"
"    left join cat.kittens as kitten\n"
"        with kitten.bodyWeight > 10.0]]>"
msgstr ""

#. Tag: para
#: query_hql.xml:137
#, no-c-format
msgid ""
"In addition, a \"fetch\" join allows associations or collections of values "
"to be initialized along with their parent objects, using a single select. "
"This is particularly useful in the case of a collection. It effectively "
"overrides the outer join and lazy declarations of the mapping file for "
"associations and collections. See <xref linkend=\"performance-fetching\"/> "
"for more information."
msgstr ""
"게다가, \"fetch\" join은 값들을 가진 콜렉션들이나 연관관계들이 한 개의 select"
"를 사용하여, 그것들의 부모 객체들에 따라 초기화 되는 것을 허용해준다. 이것은 "
"콜렉션의 경우에 특히 유용하다. 그것은 연관관계들과 콜렉션들에 대한 매핑 파일"
"의 outer join과 lazy 선언들을 효율적으로 오버라이드 시킨다. 추가 정보는 "
"<xref linkend=\"performance-fetching\"/>을 보라."

#. Tag: programlisting
#: query_hql.xml:145
#, no-c-format
msgid ""
"<![CDATA[from Cat as cat\n"
"    inner join fetch cat.mate\n"
"    left join fetch cat.kittens]]>"
msgstr ""

#. Tag: para
#: query_hql.xml:147
#, no-c-format
msgid ""
"A fetch join does not usually need to assign an alias, because the "
"associated objects should not be used in the <literal>where</literal> clause "
"(or any other clause). Also, the associated objects are not returned "
"directly in the query results. Instead, they may be accessed via the parent "
"object. The only reason we might need an alias is if we are recursively join "
"fetching a further collection:"
msgstr ""
"fetch join은 대개 alias를 할당할 필요가 없다. 왜냐하면, 연관된 객체들이 "
"<literal>where</literal> 절(또는 어떤 다른 절) 속에 사용되지 않을 것이기 때문"
"이다. 또한 연관된 객체들은 질의 결과들 속에 직접 반환되지 않는다. 대신 그것들"
"은 부모 객체를 통해 접근될 수 있다. 우리가 alias를 필요로 할 수 있는 유일한 "
"이유는 더 많은 콜렉션들을 재귀적으로 조인 페칭시키는 경우이다:"

#. Tag: programlisting
#: query_hql.xml:155
#, no-c-format
msgid ""
"<![CDATA[from Cat as cat\n"
"    inner join fetch cat.mate\n"
"    left join fetch cat.kittens child\n"
"    left join fetch child.kittens]]>"
msgstr ""

#. Tag: para
#: query_hql.xml:157
#, no-c-format
msgid ""
"Note that the <literal>fetch</literal> construct may not be used in queries "
"called using <literal>iterate()</literal> (though <literal>scroll()</"
"literal> can be used). Nor should <literal>fetch</literal> be used together "
"with <literal>setMaxResults()</literal> or <literal>setFirstResult()</"
"literal> as these operations are based on the result rows, which usually "
"contain duplicates for eager collection fetching, hence, the number of rows "
"is not what you'd expect. Nor may <literal>fetch</literal> be used together "
"with an ad hoc <literal>with</literal> condition. It is possible to create a "
"cartesian product by join fetching more than one collection in a query, so "
"take care in this case. Join fetching multiple collection roles also "
"sometimes gives unexpected results for bag mappings, so be careful about how "
"you formulate your queries in this case. Finally, note that <literal>full "
"join fetch</literal> and <literal>right join fetch</literal> are not "
"meaningful."
msgstr ""
"(비록 <literal>scroll()</literal>이 사용될 수 있을지라도) <literal>fetch</"
"literal> 구조체는 <literal>iterate()</literal>를 사용하여 호출되는 질의들 내"
"에 사용될 수 없음을 노트하라. 이들 오퍼레이션들이 결과 행들에 기초하고 있기 "
"때문에 <literal>fetch</literal>는 <literal>setMaxResults()</literal> 또는 "
"<literal>setFirstResult()</literal>과 함께 사용되지 말아야 하며, 그것들(결과 "
"행들)은 대개 각각의 eager 콜렉션 페칭에 대해 중복들을 포함하므로 많은 행들이 "
"당신이 기대하는 것이 아니다. <literal>fetch</literal>는 특별한 용도의 "
"<literal>with</literal> 조건과도 함께 사용될 수 없다.한 개의 질의 내에 하나 "
"이상의 콜렉션을 조인 페칭시켜 카티젼 곱을 생성시키는 것이 가능한데, 이 경우"
"에 주의하라. 다중 콜렉션 role들을 조인 페칭시키는 것은 또한 때때로 bag 매핑들"
"에 대해 예기치 않은 결과들을 가져다주기 때문에, 당신이 이 경우에 당신의 질의"
"들을 처방하는 방법에 대해 주의하라. 마지막으로 <literal>full join fetch</"
"literal>와 <literal>right join fetch</literal>는 의미가 없다."

#. Tag: para
#: query_hql.xml:172
#, no-c-format
msgid ""
"If you are using property-level lazy fetching (with bytecode "
"instrumentation), it is possible to force Hibernate to fetch the lazy "
"properties immediately (in the first query) using <literal>fetch all "
"properties</literal>."
msgstr ""
"만일 당신이 (바이트코드 방편으로) property-레벨 lazy 페칭을 사용할 경우, "
"Hibernate로 하여금 <literal>fetch all properties</literal>를 사용하여 (첫 번"
"째 질의에서) lazy 프로퍼티들을 즉시 페치하도록 강제시키는 것이 가능하다."

#. Tag: programlisting
#: query_hql.xml:178
#, no-c-format
msgid "<![CDATA[from Document fetch all properties order by name]]>"
msgstr ""

#. Tag: programlisting
#: query_hql.xml:179
#, no-c-format
msgid ""
"<![CDATA[from Document doc fetch all properties where lower(doc.name) like '%"
"cats%']]>"
msgstr ""

#. Tag: title
#: query_hql.xml:184
#, no-c-format
msgid "Forms of join syntax"
msgstr "join 구문의 형식들"