Hibernate example source code file (query_hql.po)

This example Hibernate source code file (query_hql.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

a, for, hibernate, hql, hql, java, sql, sql, tag, tag, the, the, this, you

The Hibernate query_hql.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 "HQL: The Hibernate Query Language"
msgstr "HQL: 하이버네이트 질의 언어(Hibernate Query Language)"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Hibernate uses a powerful query language (HQL) that is similar in appearance "
"to SQL. Compared with SQL, however, HQL is fully object-oriented and "
"understands notions like inheritance, polymorphism and association."
msgstr ""
"Hibernate는 (아주 의도적으로) SQL과 매우 흡사하게 보이는 극히 강력한 질의 언"
"어를 구비하고 있다. 그러나 그 구문에 의해 우롱당하지 말라; HQL은 상속, 다형"
"성 그리고 연관과 같은 개념들을 이해하여서, 전체적으로 객체 지향적이다."

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

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

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

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

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"This returns all instances of the class <literal>eg.Cat. You do "
"not usually need to qualify the class name, since <literal>auto-import 클래스의 모든 인스턴스들을 간단하게 반환한"
"다. 우리는 대개 클래스 이름을 수식할 필요가 없다. 왜냐하면, <literal>auto-"
"import</literal>가 디폴트이기 때문이다. 따라서 우리는 대개 항상 단지 다음과 "
"같이 작성한다:"

#. Tag: para
#, no-c-format
msgid ""
"In order to refer to the <literal>Cat in other parts of the query, "
"you will need to assign an <emphasis>alias. For example:"
msgstr ""

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

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

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

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

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

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

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>inner join"
msgstr "또는 <literal>List로서,"

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>left outer join"
msgstr "<literal>full join (대개 유용하지 않음)"

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>right outer join"
msgstr "right outer join"

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

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

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

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>fetch construct cannot be used in queries called "
"using <literal>iterate() (though scroll() can "
"be used). <literal>Fetch should be used together with "
"<literal>setMaxResults() or setFirstResult(), "
"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 would expect. <literal>Fetch should also not be used "
"together with impromptu <literal>with 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 "
"can produce unexpected results for bag mappings, so user discretion is "
"advised when formulating queries in this case. Finally, note that "
"<literal>full join fetch and right join fetch "
"are not meaningful."
msgstr ""
"(비록 <literal>scroll()이 사용될 수 있을지라도) fetchiterate()를 사용하여 호출되는 질의들 내"
"에 사용될 수 없음을 노트하라. 이들 오퍼레이션들이 결과 행들에 기초하고 있기 "
"때문에 <literal>fetch는 setMaxResults() 또는 "
"<literal>setFirstResult()과 함께 사용되지 말아야 하며, 그것들(결과 "
"행들)은 대개 각각의 eager 콜렉션 페칭에 대해 중복들을 포함하므로 많은 행들이 "
"당신이 기대하는 것이 아니다. <literal>fetch는 특별한 용도의 "
"<literal>with 조건과도 함께 사용될 수 없다.한 개의 질의 내에 하나 "
"이상의 콜렉션을 조인 페칭시켜 카티젼 곱을 생성시키는 것이 가능한데, 이 경우"
"에 주의하라. 다중 콜렉션 role들을 조인 페칭시키는 것은 또한 때때로 bag 매핑들"
"에 대해 예기치 않은 결과들을 가져다주기 때문에, 당신이 이 경우에 당신의 질의"
"들을 처방하는 방법에 대해 주의하라. 마지막으로 <literal>full join fetchright join fetch는 의미가 없다."

#. Tag: para
#, fuzzy, 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 in the first query immediately using <literal>fetch all "
"properties</literal>."
msgstr ""
"만일 당신이 (바이트코드 방편으로) property-레벨 lazy 페칭을 사용할 경우, "
"Hibernate로 하여금 <literal>fetch all properties를 사용하여 (첫 번"
"째 질의에서) lazy 프로퍼티들을 즉시 페치하도록 강제시키는 것이 가능하다."

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

#. Tag: para
#, no-c-format
msgid ""
"HQL supports two forms of association joining: <literal>implicit "
"and <literal>explicit."
msgstr ""
"HQL은 두 가지 형식의 연관 조인을 지원한다: <literal>암묵적 그리고 "
"<literal>명시적."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The queries shown in the previous section all use the <literal>explicit 형식을 사용한다. 이것은 권장되는 형식이다."

#. Tag: para
#, no-c-format
msgid ""
"The <literal>implicit form does not use the join keyword. Instead, "
"the associations are \"dereferenced\" using dot-notation. <literal>implicitimplicit 형식은 join 키워드를 사용하지 않는다. 대신에, 연"
"관들은 dot(.) 표기를 사용하여 \"dot-참조된다(dereferenced)\". <literal>함축적"
"인</literal> 조인들은 임의의 HQL 절들내에 나타날 수 있다. 함축적인 may be used to "
"reference the identifier property of an entity <emphasis>provided that the "
"entity does not define a non-identifier property named id</emphasis>."
msgstr ""
"<emphasis>엔티티가 id로 명명된 비식별자 속성을 정의하지 않는다고 가정하면id가 엔티티의 식별자 속성을 "
"참조하는데 사용될 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"If the entity defines a named identifier property, you can use that property "
"name."
msgstr ""
"만일 그 엔티티가 명명된 식별자 속성을 정의하는 경우, 당신은 그 속성 이름을 사"
"용할 수도 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"References to composite identifier properties follow the same naming rules. "
"If the entity has a non-identifier property named id, the composite "
"identifier property can only be referenced by its defined named. Otherwise, "
"the special <literal>id property can be used to reference the "
"identifier property."
msgstr ""
"composite 식별자 속성들에 대한 참조들은 동일한 네이밍 규칙들을 따른다. 만일 "
"그 엔티티가 id로 명명된 비식별자를 갖고 있을 경우, composite 속성은 오직 그것"
"의 정의된 명명에 의해 참조될 수 있다; 그밖의 경우 특별한 <literal>id always "
"referred to the identifier property regardless of its actual name. A "
"ramification of that decision was that non-identifier properties named "
"<literal>id could never be referenced in Hibernate queries."
msgstr ""
"노트: 이것은 버전 3.2.2에서 시작될 때 현격하게 변경되었다. 이전 버전들에서, "
"<literal>id는 항상 그것의 실제 이름에 관계없"
"이 식별자 속성을 참조했다. 그 결정의 분기점은 <literal>id로 명명된 "
"비식별자 속성들이 Hibernate 질의들 내에서 결코 참조될 수 없었다는 점이었다."

#. Tag: title
#, no-c-format
msgid "The select clause"
msgstr "select 절"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>select clause picks which objects and properties to "
"return in the query result set. Consider the following:"
msgstr ""
"<literal>select 절은 질의 결과 셋 속에 반환할 객체들과 프로퍼티들"
"이 어느 것인지를 골라 내도록 강제한다. 다음을 검토하자:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The query will select <literal>mates of other Cat들의 mate들을 select 할 "
"것이다. 실제로 당신은 이 질의들을 다음과 같이 보다 축약형으로 표현할수도 있"
"다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Queries can return properties of any value type including properties of "
"component type:"
msgstr ""
"질의들은 컴포넌트 타입의 프로퍼티들을 포함하는 임의의 값 타입의 프로퍼티들을 "
"반환할 수도 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Queries can return multiple objects and/or properties as an array of type "
"<literal>Object[]:"
msgstr ""
"<literal>Family 클래스가 적당한 생성자를 갖고 있음을 가정하면, 질의"
"들은 여러 객체들 그리고/또는 프로퍼티들을 <literal>Object[] 타입의 "
"배열로서,"

#. Tag: para
#, fuzzy, no-c-format
msgid "Or as a <literal>List:"
msgstr "또는 <literal>List로서,"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Or - assuming that the class <literal>Family has an appropriate "
"constructor - as an actual typesafe Java object:"
msgstr "반환할 수도 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You can assign aliases to selected expressions using <literal>as:"
msgstr ""
"당신은 <literal>as를 사용하여 select되는 표현식들에 alias들을 할당"
"할 수 있다:"

#. Tag: para
#, no-c-format
msgid ""
"This is most useful when used together with <literal>select new map과 함께 사용될 때 가장 유용하다:"

#. Tag: para
#, no-c-format
msgid ""
"This query returns a <literal>Map from aliases to selected values."
msgstr ""
"이 질의는 select된 값들에 대한 alias로부터 한 개의 <literal>Map을 "
"반환한다."

#. Tag: title
#, no-c-format
msgid "Aggregate functions"
msgstr "집계 함수들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"HQL queries can even return the results of aggregate functions on properties:"
msgstr ""
"HQL 질의들은 프로퍼티들에 대한 집계(aggregate) 함수들의 결과들을 반환할수도 "
"있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid "The supported aggregate functions are:"
msgstr "지원되는 집계 함수들은 다음과 같다"

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>avg(...), sum(...), min(...), max(...)"
msgstr "avg(...), sum(...), min(...), max(...)"

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>count(*)"
msgstr "또는 <literal>List로서,"

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>count(...), count(distinct ...), count(all...)"
msgstr "count(...), count(distinct ...), count(all...)"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You can use arithmetic operators, concatenation, and recognized SQL "
"functions in the select clause:"
msgstr ""
"당신은 select 절 속에 산술 연산자들, 연결 연산자, 그리고 인지된 SQL 함수들을 "
"사용할 수 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>distinct and all keywords can be "
"used and have the same semantics as in SQL."
msgstr ""
"<literal>distinct 키워드와 all all가 사용될 수 "
"있고 SQL의 경우와 동일한 의미를 갖는다."

#. Tag: title
#, no-c-format
msgid "Polymorphic queries"
msgstr "Polymorphic(다형성) 질의들"

#. Tag: para
#, no-c-format
msgid "A query like:"
msgstr "다음과 같은 질의:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"returns instances not only of <literal>Cat, but also of subclasses "
"like <literal>DomesticCat. Hibernate queries can name "
"<emphasis>any Java class or interface in the from의 인스턴스들 뿐만 아니라, 또한 "
"<literal>DomesticCat과 같은 서브클래스들 또한 반환한다. Hibernate "
"질의들은 <literal>from 절 내에 임의의 자바 클"
"래스나 인터페이스를 명명할 수 있다. 질의는 그 클래스를 확장하거나 그 인터페이"
"스를 구현하는 모든 영속 클래스들의 인스턴스들을 반환할 것이다. 다음 질의는 모"
"든 영속 객체들을 반환할 것이다:"

#. Tag: para
#, no-c-format
msgid ""
"The interface <literal>Named might be implemented by various "
"persistent classes:"
msgstr ""
"인터페이스 <literal>Named는 여러 가지 영속 클래스들에 의해 구현될 "
"수도 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"These last two queries will require more than one SQL <literal>SELECTorder by clause does not "
"correctly order the whole result set. It also means you cannot call these "
"queries using <literal>Query.scroll()."
msgstr ""
"이들 마지막 두 개의 질의들은 하나 이상의 SQL <literal>SELECT를 필요"
"로 할 것임을 노트하라. 이것은 <literal>order by 절이 정확하게 전체 "
"결과 셋을 순서지우지 않음을 의미한다.(그것은 또한 당신이 <literal>Query."
"scroll()</literal>을 사용하여 이들 질의들을 호출할 수 없음을 의미한다)."

#. Tag: title
#, no-c-format
msgid "The where clause"
msgstr "where 절"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>where clause allows you to refine the list of "
"instances returned. If no alias exists, you can refer to properties by name:"
msgstr ""
"<literal>where 절은 반환된 인스턴스들의 목록을 제한시키는 것을 당신"
"에게 허용해준다. 만일 alias가 존재하지 않을 경우, 당신은 이름에 의해 프로퍼티"
"들을 참조할 수도 있다:"

#. Tag: para
#, no-c-format
msgid "If there is an alias, use a qualified property name:"
msgstr ""
"만일 한 개의 alias가 존재할 경우, 하나의 수식어가 붙은 프로퍼티 이름을 사용하"
"라:"

#. Tag: para
#, fuzzy, no-c-format
msgid "This returns instances of <literal>Cat named 'Fritz'."
msgstr "는 'Fritz'로 명명된 <literal>Cat의 인스턴스들을 반환한다."

#. Tag: para
#, no-c-format
msgid "The following query:"
msgstr ""

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"returns all instances of <literal>Foo with an instance of "
"<literal>bar with a date property equal to the "
"<literal>startDate property of the Foo. "
"Compound path expressions make the <literal>where clause extremely "
"powerful. Consider the following:"
msgstr ""
"는 <literal>Foo의 startDate 프로퍼티와 동일한 "
"<literal>date 프로퍼티를 가진 bar의 인스턴스가 "
"존재하는 <literal>Foo의 모든 인스턴스를 반환할 것이다. 합성 경로 표"
"현식들은 <literal>where 절을 매우 강력하게 만들어준다. 다음을 검토"
"하자:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"This query translates to an SQL query with a table (inner) join. For example:"
msgstr ""
"이 질의는 테이블 (inner) join을 가진 SQL 질의로 번역된다. 만일 당신이 다음과 "
"같은 어떤 것을 작성했다면"

#. Tag: para
#, fuzzy, no-c-format
msgid "would result in a query that would require four table joins in SQL."
msgstr ""
"당신은 SQL에서 네 개의 테이블 join들을 필요로 하는 하나의 질의로 끝낼 것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>= operator can be used to compare not only "
"properties, but also instances:"
msgstr ""
"<literal>= 연산자는 프로퍼티들 뿐만 아니라 또한 인스턴스들을 비교하"
"는데 사용될 수 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The special property (lowercase) <literal>id can be used to "
"reference the unique identifier of an object. See <xref linkend=\"queryhql-"
"identifier-property\" /> for more information."
msgstr ""
"특별한 프로퍼티(소문자) <literal>id는 객체의 유일 식별자를 참조하는"
"데 사용될 수 있다. 추가 정보는 <xref linkend=\"queryhql-identifier-property"
"\"/>를 보라."

#. Tag: para
#, fuzzy, no-c-format
msgid "The second query is efficient and does not require a table join."
msgstr "두 번째 질의가 효율적이다. 테이블 join이 필요 없다!"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Properties of composite identifiers can also be used. Consider the following "
"example where <literal>Person has composite identifiers consisting "
"of <literal>country and medicareNumber:"
msgstr ""
"composite(합성) 식별자들의 프로퍼티들이 또한 사용될 수 있다. "
"<literal>Person이 country와 "
"<literal>medicareNumber로 구성된 composite 식별자를 갖는다고 가정하"
"자. 식별자 속성들을 참조하는 것과 관련된 추가 정보는 다시 <xref linkend="
"\"queryhql-identifier-property\"/>를 보라."

#. Tag: para
#, fuzzy, no-c-format
msgid "Once again, the second query does not require a table join."
msgstr "다시 한번, 두 번째 질의는 테이블 join을 필요로 하지 않는다."

#. Tag: para
#, no-c-format
msgid ""
"See <xref linkend=\"queryhql-identifier-property\" /> for more information "
"regarding referencing identifier properties)"
msgstr ""

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The special property <literal>class accesses the discriminator "
"value of an instance in the case of polymorphic persistence. A Java class "
"name embedded in the where clause will be translated to its discriminator "
"value."
msgstr ""
"마찬가지로, 특별한 프로퍼티 <literal>class는 다형적인 영속성"
"(polymorphic persistence)의 경우에 인스턴스의 판별자(discriminator) 값에 액세"
"스한다. where 절 속에 삽입된 Java 클래스 이름은 그것의 판별자(discriminator) "
"값으로 변환될 것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You can also use components or composite user types, or properties of said "
"component types. See <xref linkend=\"queryhql-components\" /> for more "
"information."
msgstr ""
"당신은 또한 컴포넌트들 또는 composite 사용자 타입들, 또는 명명된 컴포넌트 타"
"입들의 속성들을 사용할 수도 있다. 상세한 것은 <xref linkend=\"queryhql-"
"components\"/>를 보라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"An \"any\" type has the special properties <literal>id and "
"<literal>class that allows you to express a join in the following "
"way (where <literal>AuditLog.item is a property mapped with "
"<literal><any>):"
msgstr ""
"\"임의의\" 타입은 다음 방법으로 join을 표현하는 것을 우리에게 허용해주는, 특"
"별한 프로퍼티들 <literal>id와 class를 갖는다(여"
"기서 <literal>AuditLog.item은 <any>로 매핑"
"된 프로퍼티이다)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>log.item.class and payment.class "
"would refer to the values of completely different database columns in the "
"above query."
msgstr ""
"<literal>log.item.class와 payment.class는 위의 "
"질의 내에서 완전히 다른 데이터베이스 컬럼들의 값들을 참조할 것임을 노트하라."

#. Tag: title
#, no-c-format
msgid "Expressions"
msgstr "표현식들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Expressions used in the <literal>where clause include the "
"following:"
msgstr ""
"<literal>where 절 속에 허용되는 표현식들은 당신이 SQL로 작성할 수 "
"있는 대부분의 종류의 것들을 포함한다:"

#. Tag: para
#, fuzzy, no-c-format
msgid "mathematical operators: <literal>+, -, *, /"
msgstr "산술 연산자들 <literal>+, -, *, /"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"binary comparison operators: <literal>=, >=, <=, <>, !=, like"

#. Tag: para
#, no-c-format
msgid "logical operations <literal>and, or, not"
msgstr "논리 연산들 <literal>and, or, not"

#. Tag: para
#, fuzzy, no-c-format
msgid "Parentheses <literal>( ) that indicates grouping"
msgstr "그룹핑을 나타내는 괄호들 <literal>( ), indicating grouping"

#. Tag: para
#, no-c-format
msgid ""
"<literal>in, not in, betweenis null, is not null, "
"<literal>is empty, is not empty, "
"<literal>member of and not member of"
msgstr ""
"<literal>in, not in, betweenis null, is not null, "
"<literal>is empty, is not empty, "
"<literal>member of and not member of"

#. Tag: para
#, no-c-format
msgid ""
"\"Simple\" case, <literal>case ... when ... then ... else ... end, "
"and \"searched\" case, <literal>case when ... then ... else ... end"
msgstr ""
"\"간단한\" 경우, <literal>case ... when ... then ... else ... end, "
"그리고 \"검색인\" 경우, <literal>case when ... then ... else ... end or concat(...,...)"
"</literal>"
msgstr ""
"문자열 연결 <literal>...||... or concat(...,...)"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>current_date(), current_time(), and "
"<literal>current_timestamp()"
msgstr ""
"<literal>current_date(), current_time(), "
"<literal>current_timestamp()"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>second(...), minute(...), hour"
"(...)</literal>, day(...), month(...), "
"and <literal>year(...)"
msgstr ""
"<literal>second(...), minute(...), hour"
"(...)</literal>, day(...), month(...), "
"<literal>year(...),"

#. Tag: para
#, no-c-format
msgid ""
"Any function or operator defined by EJB-QL 3.0: <literal>substring(), trim"
"(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()"
"</literal>"
msgstr ""
"EJB-QL 3.0에 의해 정의된 임의의 함수 또는 오퍼레이터: <literal>substring(), "
"trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), "
"mod()</literal>"

#. Tag: para
#, no-c-format
msgid "<literal>coalesce() and nullif()"
msgstr "<literal>coalesce() 그리고 nullif()"

#. Tag: para
#, no-c-format
msgid ""
"<literal>str() for converting numeric or temporal values to a "
"readable string"
msgstr ""
"numeric 값들이나 temporal 값들을 가독성 있는 문자열로 변환시키는 <literal>str"
"()</literal>"

#. Tag: para
#, no-c-format
msgid ""
"<literal>cast(... as ...), where the second argument is the name "
"of a Hibernate type, and <literal>extract(... from ...) if ANSI "
"<literal>cast() and extract() is supported by "
"the underlying database"
msgstr ""
"<literal>cast(... as ...), 여기서 두번 째 아규먼트는 Hibernate 타입"
"의 이름이고, ANSI <literal>cast()와 extract()가 "
"기반 데이터베이스에 의해 지원될 경우에는 <literal>extract(... from ...) function, that applies to aliases of a "
"joined indexed collection"
msgstr ""
"조인된 인덱싱된 콜렉션의 alias들에 적용되는, HQL <literal>index() "
"함수"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"HQL functions that take collection-valued path expressions: <literal>size(), "
"minelement(), maxelement(), minindex(), maxindex()</literal>, along with the "
"special <literal>elements() and indices "
"functions that can be quantified using <literal>some, all, exists, any, in와 indices 함수들과 함께 "
"<literal>size(), minelement(), maxelement(), minindex(), maxindex(), "
"<literal>trunc(), rtrim(), and sin(), trunc(), rtrim()sin()과 같이 임의의 데이터베이스 지원 SQL 스칼"
"라 함수"

#. Tag: para
#, no-c-format
msgid "JDBC-style positional parameters <literal>?"
msgstr "JDBC-스타일 위치 파라미터들 <literal>?"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"named parameters <literal>:name, :start_date, "
"and <literal>:x1"
msgstr ""
"명명된 파라미터들 <literal>:name, :start_date, "
"<literal>:x1"

#. Tag: para
#, no-c-format
msgid ""
"SQL literals <literal>'foo', 69, 6.66E"
"+2</literal>, '1970-01-01 10:00:01.0'"
msgstr ""
"SQL 리터럴들 <literal>'foo', 69, 6.66E"
"+2</literal>, '1970-01-01 10:00:01.0'"

#. Tag: para
#, no-c-format
msgid ""
"Java <literal>public static final constants eg.Color."
"TABBY</literal>"
msgstr ""
"Java <literal>public static final 상수들. eg.Color.TABBY and between can be used as follows:"
msgstr ""
"<literal>in 과 between은 다음과 같이 사용될 수 "
"있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid "The negated forms can be written as follows:"
msgstr "그리고 부정형들은 다음과 같이 작성될 수 있다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Similarly, <literal>is null and is not null can "
"be used to test for null values."
msgstr ""
"마찬가지로, <literal>is null과 is not null은 "
"null 값들을 테스트하는데 사용될 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Booleans can be easily used in expressions by declaring HQL query "
"substitutions in Hibernate configuration:"
msgstr ""
"Boolean들은 Hibernate 구성 내에 HQL 질의 치환들을 선언함으로써 표현식들 내에 "
"쉽게 사용될 수 있다:"

#. Tag: para
#, no-c-format
msgid ""
"This will replace the keywords <literal>true and false1 and 0 in "
"the translated SQL from this HQL:"
msgstr ""
"이것은 키워드 <literal>true와 false 키워드들을 "
"이 HQL로부터 번역된 SQL에서 리터럴 <literal>1과 0 or the special size() function."
msgstr ""
"당신은 특별한 프로퍼티 <literal>size로서 또는 특별한 size"
"()</literal> 함수로서 콜렉션의 사이즈를 테스트할 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"For indexed collections, you can refer to the minimum and maximum indices "
"using <literal>minindex and maxindex functions. "
"Similarly, you can refer to the minimum and maximum elements of a collection "
"of basic type using the <literal>minelement and "
"<literal>maxelement functions. For example:"
msgstr ""
"인덱싱된 콜렉션들에 대해, 당신은<literal>minindex와 "
"<literal>maxindex 함수들을 사용하여 최소 인덱스과 최대 인덱스를 참"
"조할 수 있다. 유사하게 당신은 <literal>minelement와 "
"<literal>maxelement 함수를 사용하여 기본 타입을 가진 콜렉션의 최소 "
"요소 및 최대 요소를 참조할 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The SQL functions <literal>any, some, all, exists, in are "
"supported when passed the element or index set of a collection "
"(<literal>elements and indices functions) or "
"the result of a subquery (see below):"
msgstr ""
"SQL 함수들 <literal>any, some, all, exists, in은 콜렉션의 요소 또"
"는 인덱스 세트(<literal>elements 함수와 indices "
"함수), 또는 서브질의의 결과를 전달했을 때 지원된다(아래를 보라)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Note that these constructs - <literal>size, elementsindices, minindex, "
"<literal>maxindex, minelement, "
"<literal>maxelement - can only be used in the where clause in "
"Hibernate3."
msgstr ""
"이들 구조체들-<literal>size, elements, "
"<literal>indices, minindex, maxindexminelement, maxelement-는 "
"Hibernate3에서 where 절 내에서만 사용될 것임을 노트하라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Elements of indexed collections (arrays, lists, and maps) can be referred to "
"by index in a where clause only:"
msgstr ""
"인덱싱 된 콜렉션들의 요소들(배열들, 리스트들, map들)은 인덱스에 의해 참조될 "
"수 있다(where 절 안에서만):"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The expression inside <literal>[] can even be an arithmetic "
"expression:"
msgstr "<literal>[] 내부의 표현식은 산술 표현실일 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"HQL also provides the built-in <literal>index() function for "
"elements of a one-to-many association or collection of values."
msgstr ""
"HQL은 또한 one-to-many 연관 또는 값들을 가진 콜렉션의 요소들에 대해 미리 만들"
"어진 <literal>index() 함수를 제공한다."

#. Tag: para
#, fuzzy, no-c-format
msgid "Scalar SQL functions supported by the underlying database can be used:"
msgstr "기본 데이터베이스에 의해 제공되는 Scalar SQL 함수들이 사용될 수도 있다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Consider how much longer and less readable the following query would be in "
"SQL:"
msgstr ""
"당신이 아직 이 모든 것을 납득하지 못한다면, SQL 내에서 다음 질의가 가독성이 "
"얼마나 많고 적은지를 생각해보라:"

#. Tag: para
#, no-c-format
msgid "<emphasis>Hint: something like"
msgstr "<emphasis>힌트 : 다음과 같은 어떤 것"

#. Tag: title
#, no-c-format
msgid "The order by clause"
msgstr "order by 절"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The list returned by a query can be ordered by any property of a returned "
"class or components:"
msgstr ""
"질의에 의해 반환된 리스트는 반환된 클래스 또는 컴포넌트들의 프로퍼티에 의해 "
"순서(ordering)지워질 수 있다:"

#. Tag: para
#, no-c-format
msgid ""
"The optional <literal>asc or desc indicate "
"ascending or descending order respectively."
msgstr ""
"<literal>asc 옵션 또는 desc 옵션은 각각 오름차"
"순 또는 내림차순 정렬을 나타낸다."

#. Tag: title
#, no-c-format
msgid "The group by clause"
msgstr "group by 절"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A query that returns aggregate values can be grouped by any property of a "
"returned class or components:"
msgstr ""
"aggregate 값들을 반환하는 질의는 반환된 클래스나 컴포넌트들의 프로퍼티에 의"
"해 그룹지워질 수 있다:"

#. Tag: para
#, no-c-format
msgid "A <literal>having clause is also allowed."
msgstr "또한 <literal>having 절이 허용된다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"SQL functions and aggregate functions are allowed in the <literal>havingorder by clauses if they are supported by "
"the underlying database (i.e., not in MySQL)."
msgstr ""
"SQL 함수들과 집계 함수들이 기본 데이터베이스에 의해 지원될 경우(예를 들어 "
"MySQL은 지원되지 않는다) <literal>having 절과 order by clause nor the order bycat are non-"
"aggregated. You have to list all non-aggregated properties explicitly."
msgstr ""
"<literal>group by 절도 order by 절 어느 것도 산"
"술 표현식들을 포함할 수 없다는 점을 노트하라. 또한 Hibernate는 현재 그룹지워"
"진 엔티티를 확장하지 않아서 만일 <literal>cat의 모든 속성들이 집계"
"되지 않을 경우에 당신이 <literal>group by cat을 쓸수 없음을 노트하"
"라. 당신은 명시적으로 모든 집계되지 않는 속성들을 리스트해야 한다."

#. Tag: title
#, no-c-format
msgid "Subqueries"
msgstr "서브질의들"

#. Tag: para
#, no-c-format
msgid ""
"For databases that support subselects, Hibernate supports subqueries within "
"queries. A subquery must be surrounded by parentheses (often by an SQL "
"aggregate function call). Even correlated subqueries (subqueries that refer "
"to an alias in the outer query) are allowed."
msgstr ""
"subselect들을 지원하는 데이터베이스들의 경우, Hibernate는 질의들 내에 서브질"
"의들을 지원한다. 서브질의는 괄호로 묶여져야 한다(자주 SQL 집계함수 호출에 의"
"해). 심지어 서로 상관된 서브질의들(외부 질의 내에서 alias를 참조하는 서브질의"
"들)이 허용된다."

#. Tag: para
#, fuzzy, no-c-format
msgid "Note that HQL subqueries can occur only in the select or where clauses."
msgstr ""
"HQL 서브질의들이 select 절 또는 where 절 내에서만 일어날 수 있음을 노트하라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Note that subqueries can also utilize <literal>row value constructor for more "
"information."
msgstr ""
"서브질의들은 또한 <literal>row value constructor 구문을 활용할 수 "
"있다. 상세한 것은 <xref linkend=\"queryhql-tuple\"/>를 보라."

#. Tag: title
#, no-c-format
msgid "HQL examples"
msgstr "HQL 예제들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Hibernate queries can be quite powerful and complex. In fact, the power of "
"the query language is one of Hibernate's main strengths. The following "
"example queries are similar to queries that have been used on recent "
"projects. Please note that most queries you will write will be much simpler "
"than the following examples."
msgstr ""
"Hibernate 질의들은 매우 강력하고 복잡할 수 있다. 사실, 질의 언어의 힘은 "
"Hibernate의 주요 판매 포인트들 중 하나이다. 다음은 내가 최근의 프로젝트에서 "
"사용했던 질의들과 매우 유사한 몇몇 예제 질의들이다. 당신이 작성하게 될 대부분"
"의 질의들은 이것들보다 훨씬 간단하다는 점을 노트하라!"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The following query returns the order id, number of items, the given minimum "
"total value and the total value of the order for all unpaid orders for a "
"particular customer. The results are ordered by total value. In determining "
"the prices, it uses the current catalog. The resulting SQL query, against "
"the <literal>ORDER, ORDER_LINE, "
"<literal>PRODUCT, CATALOG and PRICE, ORDER_LINEPRODUCT, CATALOG, "
"<literal>PRICE 테이블들에 대한 네 개의 inner 조인들과 한 개의(상관"
"지워지지 않은) subselect를 갖고 있다."

#. Tag: para
#, no-c-format
msgid ""
"What a monster! Actually, in real life, I'm not very keen on subqueries, so "
"my query was really more like this:"
msgstr ""
"괴물 같은 것! 실제로 실 생활에서, 나는 서브질의들을 매우 좋아하지 않아서, 나"
"의 질의는 실제로 다음과 같았다:"

#. Tag: para
#, no-c-format
msgid ""
"The next query counts the number of payments in each status, excluding all "
"payments in the <literal>AWAITING_APPROVAL status where the most "
"recent status change was made by the current user. It translates to an SQL "
"query with two inner joins and a correlated subselect against the "
"<literal>PAYMENT, PAYMENT_STATUS and "
"<literal>PAYMENT_STATUS_CHANGE tables."
msgstr ""
"다음 질의는 현재 사용자에 의해 가장 최근의 상태 변경이 행해졌던 "
"<literal>AWAITING_APPROVAL 상태에 있는 모든 지불들을 제외한, 각각"
"의 상태에 있는 지불들의 개수를 카운트 한다. 그것은 <literal>PAYMENTPAYMENT_STATUS, PAYMENT_STATUS_CHANGE collection was mapped as a list, "
"instead of a set, the query would have been much simpler to write."
msgstr ""
"만일 내가 <literal>statusChanges 콜렉션을 set가 아닌 list로 매핑했"
"다면, 그 질의는 작성하기가 훨씬 더 간단했을 것이다."

#. Tag: para
#, no-c-format
msgid ""
"The next query uses the MS SQL Server <literal>isNull() function "
"to return all the accounts and unpaid payments for the organization to which "
"the current user belongs. It translates to an SQL query with three inner "
"joins, an outer join and a subselect against the <literal>ACCOUNT, "
"<literal>PAYMENT, PAYMENT_STATUS, "
"<literal>ACCOUNT_TYPE, ORGANIZATION and "
"<literal>ORG_USER tables."
msgstr ""
"다음 질의는 현재의 사용자가 속해 있는 조직의 모든 계정들과 지불되지 않은 지불"
"들을 반환하는데 MS SQL Server <literal>isNull() 함수를 사용한다. 그"
"것은 <literal>ACCOUNT, PAYMENT, "
"<literal>PAYMENT_STATUS, ACCOUNT_TYPE, "
"<literal>ORGANIZATION, ORG_USER 테이블들에 대한 "
"세 개의 inner 조인들, 하나의 outer 조인, 그리고 하나의 subselect를 가진 한 개"
"의 SQL 질의로 번역된다."

#. Tag: para
#, no-c-format
msgid ""
"For some databases, we would need to do away with the (correlated) subselect."
msgstr ""
"몇몇 데이터베이스들의 경우, 우리는 (상관관계 지워진) subselect를 없앨 필요가 "
"있을 것이다."

#. Tag: title
#, no-c-format
msgid "Bulk update and delete"
msgstr "대량 update와 delete"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"HQL now supports <literal>update, delete and "
"<literal>insert ... select ... statements. See , delete 그리고 "
"<literal>insert ... select ... 문장들을 지원한다. 상세한 것은 "
"<xref linkend=\"batch-direct\"/>를 보라."

#. Tag: title
#, no-c-format
msgid "Tips & Tricks"
msgstr "팁들 & 트릭들"

#. Tag: para
#, fuzzy, no-c-format
msgid "You can count the number of query results without returning them:"
msgstr ""
"당신은 실제로 질의 결과들을 반환하지 않고서 그것들(질의 결과들)의 개수를 카운"
"트할 수 있다:"

#. Tag: para
#, no-c-format
msgid "To order a result by the size of a collection, use the following query:"
msgstr ""
"콜렉션의 크기에 따라 결과를 순서(ordering)지우려면, 다음 질의를 사용하라:"

#. Tag: para
#, no-c-format
msgid ""
"If your database supports subselects, you can place a condition upon "
"selection size in the where clause of your query:"
msgstr ""
"만일 당신의 데이터베이스가 subselect들을 지원할 경우, 당신은 당신의 질의의 "
"where 절 내에 selection 사이즈에 대한 조건을 위치지울 수 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid "If your database does not support subselects, use the following query:"
msgstr ""
"만일 당신의 데이터베이스가 subselect를 지원하지 않을 경우, 다음 질의를 사용하"
"라:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"As this solution cannot return a <literal>User with zero messages "
"because of the inner join, the following form is also useful:"
msgstr ""
"이 해결책이 inner 조인 때문에 0개의 메시지를 가진 <literal>User를 "
"반환할 수 없으므로, 다음 형식이 또한 유용하다:"

#. Tag: para
#, no-c-format
msgid "Properties of a JavaBean can be bound to named query parameters:"
msgstr ""
"하나의 JavaBean의 프로퍼티들은 명명된 질의 파라미터들에 바인드될 수 있다:"

#. Tag: para
#, no-c-format
msgid ""
"Collections are pageable by using the <literal>Query interface "
"with a filter:"
msgstr ""
"콜렉션들은 필터를 가진 <literal>Query 인터페이스를 사용하여 쪼매김"
"하는 것이 가능하다:"

#. Tag: para
#, fuzzy, no-c-format
msgid "Collection elements can be ordered or grouped using a query filter:"
msgstr ""
"콜렉션 요소들은 질의 필터를 사용하여 순서(ordering)지워지거나 그룹지워질 수 "
"도 있다:"

#. Tag: para
#, no-c-format
msgid "You can find the size of a collection without initializing it:"
msgstr "당신은 콜렉션을 초기화 하지 않고서 그것(콜렉션)의 크기를 찾을 수 있다:"

#. Tag: title
#, no-c-format
msgid "Components"
msgstr "컴포넌트들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Components can be used similarly to the simple value types that are used in "
"HQL queries. They can appear in the <literal>select clause as "
"follows:"
msgstr ""
"컴포넌트들은 단지 간단한 값 유형들이 HQL 질의들 내에 사용될 수 있는 모든 방법"
"으로 사용될 수 있다. 그것들은 <literal>select 절 내에 나타날 수 있"
"다."

#. Tag: para
#, no-c-format
msgid ""
"where the Person's name property is a component. Components can also be used "
"in the <literal>where clause:"
msgstr ""
"여기서 Person의 name 속성은 컴포넌트이다. 컴포넌트들은 또한 <literal>where clause:"
msgstr "컴포넌트들은 또한 <literal>order by 절 내에 사용될 수 있다:"

#. Tag: para
#, no-c-format
msgid ""
"Another common use of components is in <link linkend=\"queryhql-tuple\">row "
"value constructors</link>."
msgstr ""
"컴포넌트들에 대한 또 다른 공통적인 사용은 <xref linkend=\"queryhql-tuple"
"\">row value constructors</xref>에 있다."

#. Tag: title
#, no-c-format
msgid "Row value constructor syntax"
msgstr "Row value constructor 구문"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"HQL supports the use of ANSI SQL <literal>row value constructor "
"syntax, sometimes referred to AS <literal>tuple syntax, even "
"though the underlying database may not support that notion. Here, we are "
"generally referring to multi-valued comparisons, typically associated with "
"components. Consider an entity Person which defines a name component:"
msgstr ""
"HQL은 ANSI SQL <literal>row value constructor 구문(종종 "
"<literal>tuple 구문이라 명명된다)의 사용을 지원한다. 비록 데이터베"
"이스가 그 개념을 지원하지 않을지라도 그러하다. 여기서 우리는 전형적으로 컴포"
"넌트들과 연관되어 있는 다중-값 비교들을 일반적으로 언급하고 있다. name 컴포넌"
"트를 정의하는 Person 엔티티를 검토하자:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"That is valid syntax although it is a little verbose. You can make this more "
"concise by using <literal>row value constructor syntax:"
msgstr ""
"비록 약간 장황스럽지만 그것은 유효한 구문이다. 이것을 약간 더 간결하게 만들"
"고 <literal>row value constructor 구문을 사용하는 것이 좋다:"

#. Tag: para
#, no-c-format
msgid ""
"It can also be useful to specify this in the <literal>select "
"clause:"
msgstr ""
"<literal>select절 내에 이것을 지정하는 것이 또한 유용할 수 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Using <literal>row value constructor syntax can also be beneficial "
"when using subqueries that need to compare against multiple values:"
msgstr ""
"<literal>row value constructor 구문을 사용하는 또 다른 경우는 다중 "
"값들에 대해 비교할 필요가 있는 서브 질의들을 사용할 때이다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"One thing to consider when deciding if you want to use this syntax, is that "
"the query will be dependent upon the ordering of the component sub-"
"properties in the metadata."
msgstr ""
"만일 당신이 이 구문을 사용하고자 원할 경우에 고려해야 할 한 가지는 질의가 메"
"타데이터 내에 있는 컴포넌트 서브-속성들의 순서에 종속될 것이라는 점이다."

#~ msgid "inner join"
#~ msgstr "inner join"

#~ msgid "left outer join"
#~ msgstr "left outer join"

#~ msgid "count(*)"
#~ msgstr "count(*)"

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

#~ msgid "or as an actual typesafe Java object,"
#~ msgstr "또는 실제 typesafe 자바 객체로서,"