Hibernate example source code file (basic_mapping.po)

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

for, hibernate, hibernate, it, java, package, sql, sql, tag, tag, the, the, this, version

The Hibernate basic_mapping.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:21\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 "Basic O/R Mapping"
msgstr "기본 O/R 매핑"

#. Tag: title
#, no-c-format
msgid "Mapping declaration"
msgstr "매핑 선언"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Object/relational mappings are usually defined in an XML document. The "
"mapping document is designed to be readable and hand-editable. The mapping "
"language is Java-centric, meaning that mappings are constructed around "
"persistent class declarations and not table declarations."
msgstr ""
"객체/관계형 매핑들은 대개 XML 문서 내에 정의된다. 매핑 문서는 가독성이 있고 "
"수작업 편집이 가능하도록 설계되어 있다. 매핑 언어는 매핑들이 테이블 선언들이 "
"아닌, 영속 클래스 선언들로 생성된다는 의미에서 자바 중심적이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Please note that even though many Hibernate users choose to write the XML by "
"hand, a number of tools exist to generate the mapping document. These "
"include XDoclet, Middlegen and AndroMDA."
msgstr ""
"심지어 많은 Hibernate 사용자들이 수작업으로 XML을 작성하고자 선택할지라도, "
"XDoclet, Middlegen, 그리고 AndroMDA를 포함하는, 매핑 문서를 생성시키는 많은 "
"도구들이 존재한다는 점을 노트하라."

#. Tag: para
#, fuzzy, no-c-format
msgid "Here is an example mapping:"
msgstr "예제 매핑으로 시작하자:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"We will now discuss the content of the mapping document. We will only "
"describe, however, the document elements and attributes that are used by "
"Hibernate at runtime. The mapping document also contains some extra optional "
"attributes and elements that affect the database schemas exported by the "
"schema export tool (for example, the <literal> not-null attribute)."
msgstr ""
"우리는 이제 매핑 문서의 내용을 논의할 것이다. 우리는 Hibernate에 의해 실행 시"
"에 사용되는 문서 요소들과 속성들 만을 설명할 것이다. 매핑 문서는 또한 스키마 "
"내보내기 도구에 의해 내보내진 데이터베이스 스키마에 영향을 주는 어떤 특별한 "
"옵션 속성들과 요소들을 포함한다. (예를 들어 <literal>not-null 속"
"성.)"

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"All XML mappings should declare the doctype shown. The actual DTD can be "
"found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/"
"hibernate </literal>, or in hibernate3.jar. Hibernate "
"will always look for the DTD in its classpath first. If you experience "
"lookups of the DTD using an Internet connection, check the DTD declaration "
"against the contents of your classpath."
msgstr ""
"모든 XML 매핑들은 doctype이 보이게 선언해야 한다. 실제 DTD는 위의 URL에서, "
"<literal>hibernate-x.x.x/src/org/hibernate 디렉토리 내에서 또는 "
"<literal>hibernate3.jar 내에서 찾을 수 있다. Hibernate는 항상 첫 번"
"째로 그것의 classpath 속에서 DTD를 찾게 될 것이다. 만일 당신이 인터넷 연결을 "
"사용하는 DTD에 대한 룩업들을 겪게 될 경우, 당신의 classpath의 컨텐츠에 대해 "
"당신의 DTD 선언을 체크하라."

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Hibernate will first attempt to resolve DTDs in its classpath. It does this "
"is by registering a custom <literal>org.xml.sax.EntityResolver "
"implementation with the SAXReader it uses to read in the xml files. This "
"custom <literal>EntityResolver recognizes two different systemId "
"namespaces:"
msgstr ""
"앞서 언급했듯이, Hibernate는 먼저 그것의 classpath에서 DTD들을 해석하려고 시"
"도할 것이다. Hibernate가 이것을 행하는 방법은 그것이 xml 파일들을 읽어들이는"
"데 사용하는 SAXReader에 맞춤형 <literal>org.xml.sax.EntityResolver "
"구현을 등록하는 것이다. 이 맞춤형 <literal>EntityResolver는 두 개"
"의 다른 systemId namespace들을 인지해낸다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"a <literal>hibernate namespace is recognized whenever the resolver "
"encounters a systemId starting with <literal>http://hibernate.sourceforge."
"net/</literal>. The resolver attempts to resolve these entities via the "
"classloader which loaded the Hibernate classes."
msgstr ""
"<literal>hibernate namespace는 resolver가 http://"
"hibernate.sourceforge.net/</literal>로 시작하는 하나의 systemId와 만날때마다 "
"인지된다; resolver는 Hibernate 클래스들을 로드시켰던 클래스로더를 통해 이들 "
"엔티티들을 해석하려고 시도한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"a <literal>user namespace is recognized whenever the resolver "
"encounters a systemId using a <literal>classpath:// URL protocol. "
"The resolver will attempt to resolve these entities via (1) the current "
"thread context classloader and (2) the classloader which loaded the "
"Hibernate classes."
msgstr ""
"<literal>user namespace는 resolver가 classpath:// is a resource in the your."
"domain</literal> package and contains a custom ."
msgstr ""
"여기서 <literal>types.xml은 your.domain 패키지 "
"내에 있는 리소스이고 맞춤형 <xref linkend=\"mapping-types-custom\">typedef "
"and <literal>catalog attributes specify that tables referred to in "
"this mapping belong to the named schema and/or catalog. If they are "
"specified, tablenames will be qualified by the given schema and catalog "
"names. If they are missing, tablenames will be unqualified. The "
"<literal>default-cascade attribute specifies what cascade style "
"should be assumed for properties and collections that do not specify a "
"<literal>cascade attribute. By default, the auto-import 속성과 "
"<literal>catalog 속성은 이 매핑 내에서 참조된 테이블들이 명명된 "
"schema 와/또는 catalog에 속한다는 점을 지정한다. 만일 지정될 경우, 테이블 이"
"름들은 주어진 schema 이름과 catalog 이름에 의해 한정(수식)될 것이다. 누락될 "
"경우, 테이블 이름들은 한정되지((수식어가 붙지) 않을 것이다. <literal>default-"
"cascade</literal> 속성은 cascade 속성을 지정하지 않은 프로"
"퍼티들과 콜렉션들에 대해 전제될 <literal>cascade 스타일이 무엇인지"
"를 지정한다. <literal>auto-import 속성은 디폴트로 우리가 질의 언어 "
"속에서 수식어가 붙지 않은(unqualified) 클래스 이름들을 사용하게 할 것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>schema (optional): the name of a database schema."
msgstr "<literal>schema (옵션): 데이터베이스 스키마의 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>catalog (optional): the name of a database catalog."
msgstr "<literal>catalog (옵션): 데이터베이스 카다록의 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>default-cascade (optional - defaults to none (옵션 - 디폴트는 none (optional - defaults to property."
msgstr ""
"<literal>default-access (옵션 - 디폴트는 property에 대한 맞춤형 구현일 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>default-lazy (optional - defaults to truelazy "
"attributes of class and collection mappings."
msgstr ""
"<literal>default-lazy (옵션 - 디폴트는 true): "
"class 및 collection 매핑들의 지정되지 않은 <literal>lazy 속성들에 "
"대한 디폴트 값."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>auto-import (optional - defaults to true (옵션 - 디폴트는 true): 우"
"리가 질의 언어 내에 (이 매핑에서 클래스들에 대해) 수식어가 붙지 않은 클래스 "
"이름들을 사용할 수 있는지를 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>package (optional): specifies a package prefix to use for "
"unqualified class names in the mapping document."
msgstr ""
"<literal>package (옵션): 매핑 문서 내에서 수식어가 붙지 않은 클래"
"스 이름들에 대해 가정할 패키지 접두어를 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"If you have two persistent classes with the same unqualified name, you "
"should set <literal>auto-import=\"false\". An exception will "
"result if you attempt to assign two classes to the same \"imported\" name."
msgstr ""
"만일 당신이 동일한 (수식어가 붙지 않은) 이름을 가진 두 개의 영속 클래스들을 "
"갖고 있다면, 당신은 <literal>auto-import=\"false\"를 설정해야 한"
"다. 만일 당신이 두 개의 클래스들에 동일한 \"imported\" 이름을 할당하려고 시도"
"할 경우에 Hibernate는 예외상황을 던질 것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>hibernate-mapping element allows you to nest several "
"persistent <literal><class> mappings, as shown above. It is, "
"however, good practice (and expected by some tools) to map only a single "
"persistent class, or a single class hierarchy, in one mapping file and name "
"it after the persistent superclass. For example, <literal>Cat.hbm.xmlDog.hbm.xml, or if using inheritance, "
"<literal>Animal.hbm.xml."
msgstr ""
"위에 보여진 것처럼 <literal>hibernate-mapping 요소는 몇몇 영속 "
"<literal><class> 매핑들을 내부에 포함하는 것을 허용해준다는 "
"점을 노트하라. 하지만 한 개의 매핑 파일 속에 한 개의 영속 클래스(또는 한 개"
"의 클래스 계층구조) 만을 매핑하고 영속 서브 클래스 뒤에 그것을 명명하는 것이 "
"좋은 연습이다 (그리고 몇몇 도구들에 의해 기대된다). 예를 들면 <literal>Cat."
"hbm.xml</literal>, Dog.hbm.xml 또는 상속을 사용할 경우에"
"는 <literal>Animal.hbm.xml."

#. Tag: title
#, fuzzy, no-c-format
msgid "Class"
msgstr "class"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You can declare a persistent class using the <literal>class "
"element. For example:"
msgstr ""
"당신은 <literal>class 요소를 사용하여 영속 클래스를 선언할 수도 있"
"다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>name (optional): the fully qualified Java class name of "
"the persistent class or interface. If this attribute is missing, it is "
"assumed that the mapping is for a non-POJO entity."
msgstr ""
"<literal>name (옵션): 영속 클래스(또는 인터페이스)의 전체 수식어가 "
"붙은 Java 클래스 이름. 만일 이 속성이 누락될 경우, 매핑이 non-POJO 엔티티라"
"고 가정된다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>table (optional - defaults to the unqualified class "
"name): the name of its database table."
msgstr ""
"<literal>table (옵션 - 디폴트는 수식어가 붙지 않은 클래스명): 그것"
"의 데이터베이스 테이블의 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>discriminator-value (optional - defaults to the class "
"name): a value that distinguishes individual subclasses that is used for "
"polymorphic behavior. Acceptable values include <literal>null and "
"<literal>not null."
msgstr ""
"<literal>discriminator-value (옵션 - 디폴트는 클래스 이름): 다형성"
"(polymorphic) 특징에 사용되는, 개별 서브 클래스들를 구별짓는 값. 허용가능한 "
"값들은<literal>null과 not null을 포함한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>mutable (optional - defaults to true): "
"specifies that instances of the class are (not) mutable."
msgstr ""
"<literal>mutable (옵션 - 디폴트는 true): 클래스"
"들의 인스턴스들이 가변적인지를 (가변적이지 않은지를) 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>schema (optional): overrides the schema name specified by "
"the root <literal><hibernate-mapping> element."
msgstr ""
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>schema (옵션): 루트 <hibernate-mapping> (옵션): 루트 <hibernate-mapping> (optional): overrides the catalog name specified "
"by the root <literal><hibernate-mapping> element."
msgstr ""
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>catalog (옵션): 루트 <hibernate-mapping> (옵션): 루트 <hibernate-mapping> (optional): specifies an interface to use for lazy "
"initializing proxies. You can specify the name of the class itself."
msgstr ""
"<literal>proxy (옵션): lazy initializing proxy들에 사용할 인터페이"
"스를 지정한다. 당신은 클래스 그 자체의 이름을 지정할 수 도 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>dynamic-update (optional - defaults to falseUPDATE SQL should be generated "
"at runtime and can contain only those columns whose values have changed."
msgstr ""
"<literal>dynamic-update (옵션 - 디폴트는 falseUPDATE SQL이 실행 시에 생성되고 그들 컬럼들의 "
"값들이 변경된 그들 컬럼들 만을 포함할 것인지를 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>dynamic-insert (optional - defaults to falseINSERT SQL should be generated "
"at runtime and contain only the columns whose values are not null."
msgstr ""
"<literal>dynamic-insert (옵션 - 디폴트는 falseINSERT이 실행 시에 생성되고 그들 컬럼들"
"의 값이 null이 아닌 컬럼들 만을 포함할 것인지를 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>select-before-update (optional - defaults to "
"<literal>false): specifies that Hibernate should neverUPDATE unless it is certain that "
"an object is actually modified. Only when a transient object has been "
"associated with a new session using <literal>update(), will "
"Hibernate perform an extra SQL <literal>SELECT to determine if an "
"<literal>UPDATE is actually required."
msgstr ""
"<literal>select-before-update (옵션 - 디폴트는 false를 결코 실행하지 않을 것임을 지"
"정한다. 어떤 경우들에서(실제로 transient 객체가 <literal>update()"
"를 사용하여 새로운 session에 연관되었을 때에만), 이것은 하나의 "
"<literal>UPDATE가 실제로 필요한 경우인지 여부를 결정하기 위해 "
"Hibernate는 특별한 SQL <literal>SELECT를 실행할 것임을 의미한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>polymorphism (optional - defaults to implicit (옵션 - 디폴트는 implicit (optional): specifies an arbitrary SQL "
"<literal>WHERE condition to be used when retrieving objects of "
"this class."
msgstr ""
"<literal>where (옵션) 이 클래스의 객체들을 검색할 때 사용될 임의적"
"인 SQL <literal>WHERE 조건을 지정한다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>persister (optional): specifies a custom "
"<literal>ClassPersister."
msgstr ""
"<literal>persister (옵션): 맞춤형 ClassPersister"
"를 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>batch-size (optional - defaults to 1): "
"specifies a \"batch size\" for fetching instances of this class by "
"identifier."
msgstr ""
"<literal>batch-size (옵션 - 디폴트는 1) 식별자"
"에 의해 이 클래스의 인스턴스들을 페치시키는 \"배치 사이즈\"를 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>optimistic-lock (optional - defaults to version (옵션 - 디폴트는 version (optional): lazy fetching can be disabled by setting "
"<literal>lazy=\"false\"."
msgstr ""
"<literal>lazy (옵션): lazy=\"false\"를 설정함으"
"로써 Lazy fetching이 전체적으로 사용불가능하게 될 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>entity-name (optional - defaults to the class name): "
"Hibernate3 allows a class to be mapped multiple times, potentially to "
"different tables. It also allows entity mappings that are represented by "
"Maps or XML at the Java level. In these cases, you should provide an "
"explicit arbitrary name for the entity. See <xref linkend=\"persistent-"
"classes-dynamicmodels\" /> and <xref linkend=\"xml\" /> for more information."
msgstr ""
"<literal>entity-name(옵션, 디폴트는 클래스 이름): Hibernate3는 하나"
"의 클래스가 (잠정적으로 다른 테이블들로) 여러번 매핑되는 것을 허용해주고, "
"Java 레벨에서 Map 또는 XML에 의해 표현 되는 엔티티 매핑들을 허용한다. 이들 경"
"우들에서, 당신은 그 엔티티에 대한 명시적인 임의의 이름을 제공해야 한다. "
"<literal>entity-name (옵션): Hibernate3는 하나의 클래스가 (잠정적으"
"로 다른 테이블들로) 여러 번 매핑되는 것을 허용하며, 자바 레벨에서 Map들 또는 "
"XML에 의해 표현되는 엔티티 매핑들을 허용한다. 이들 경우들에서, 당신은 그 엔티"
"티들에 대한 명시적인 임의의 이름을 제공해야 한다. 추가 정보는 <xref linkend="
"\"persistent-classes-dynamicmodels\"/>과 <xref linkend=\"xml\"/>을 보라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>check (optional): an SQL expression used to generate a "
"multi-row <emphasis>check constraint for automatic schema "
"generation."
msgstr ""
"<literal>check (옵션): 자동적인 스키마 생성을 위한 다중-행 "
"<emphasis>check constraint를 생성시키는데 사용되는 SQL 표현식."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>rowid (optional): Hibernate can use ROWIDs on databases. "
"On Oracle, for example, Hibernate can use the <literal>rowid extra "
"column for fast updates once this option has been set to <literal>rowid (옵션): Hibernate는 지원되는 데이터베이스들, 예를 들"
"어 Oracle 상에서 이른바 ROWID들을 사용할 수 있고, Hibernate는 당신이 이 옵션"
"을 <literal>rowid로 설정하는 경우에 빠른 업데이트를 위한 특별한 "
"<literal>rowid 컬럼을 사용할 수 있다. ROWID는 구현 상세이고 저장된 "
"튜플(tuple)의 물리적이니 위치를 표현한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>subselect (optional): maps an immutable and read-only "
"entity to a database subselect. This is useful if you want to have a view "
"instead of a base table. See below for more information."
msgstr ""
"<literal>subselect (옵션): 불변의 읽기 전용 엔티티를 데이터베이스 "
"subselect로 매핑시킨다. 당신이 기본 테이블 대신에 뷰를 갖고자 원할 경우에 유"
"용하지만, 사용을 자제하라. 추가 정보는 아래를 보라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>abstract (optional): is used to mark abstract "
"superclasses in <literal><union-subclass> hierarchies."
msgstr ""
"<literal>abstract (옵션): <union-subclass>static."
msgstr ""
"명명된 영속 클래스가 인터페이스가 되는 것은 완전히 수용가능하다. 그런 다음 당"
"신은 <literal><subclass> 요소를 사용하여 그 인터페이스에 대"
"한 구현 클래스들을 선언할 것이다. 당신은 임의의 <emphasis>static "
"inner 클래스를 영속화 시킬 수 있다. 당신은 표준 형식, 예를 들어 <literal>eg."
"Foo$Bar</literal>를 사용하여 클래스 이름을 지정해야 한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Immutable classes, <literal>mutable=\"false\", cannot be updated "
"or deleted by the application. This allows Hibernate to make some minor "
"performance optimizations."
msgstr ""
"불변의 클래스, <literal>mutable=\"false\"는 어플리케이션에 의해 업"
"데이트되지 않을 것이거나 삭제되지 않을 것이다. 이것은 Hibernate로 하여금 어"
"떤 마이너 퍼포먼스 최적화를 행하게끔 허용해준다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The optional <literal>proxy attribute enables lazy initialization "
"of persistent instances of the class. Hibernate will initially return CGLIB "
"proxies that implement the named interface. The persistent object will load "
"when a method of the proxy is invoked. See \"Initializing collections and "
"proxies\" below."
msgstr ""
"선택적인 <literal>proxy 속성은 그 클래스의 영속 인스턴스들에 대한 "
"lazy 초기화를 가능하게 해준다. Hibernate는 명명된 인터페이스를 구현하는 "
"CGLIB 프락시들을 초기에 반환할 것이다. 실제 영속 객체는 프락시의 메소드가 호"
"출될 때 로드될 것이다. 아래 \"Lazy 초기화를 위한 프락시들\"을 보라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<emphasis>Implicit polymorphism means that instances of the class "
"will be returned by a query that names any superclass or implemented "
"interface or class, and that instances of any subclass of the class will be "
"returned by a query that names the class itself. <emphasis>Explicit<subclass> or "
"<literal><joined-subclass>. For most purposes, the default "
"<literal>polymorphism=\"implicit\" is appropriate. Explicit "
"polymorphism is useful when two different classes are mapped to the same "
"table This allows a \"lightweight\" class that contains a subset of the "
"table columns."
msgstr ""
"<emphasis>Implicit 다형성은 클래스의 인스턴스들이 어떤 서브클래스"
"나 구현된 인터페이스 또는 클래스를 명명하는 질의에 의해 반환될 것임을 의미하"
"고 그 클래스의 어떤 서브클래스에 대한 인스턴스들이 그 클래스 자체를 명명하는 "
"질의에 의해 반환될 것임을 의미한다. <emphasis>Explicit 다형성은 클"
"래스 인스턴스들이 그 클래스를 명시적으로 명명하는 질의들에 의해서만 반환될 것"
"임을 의미고 그 클래스를 명명하는 질의들이 이 <literal><class><subclass> 또는 <"
"joined-subclass></literal>로 매핑된 서브 클래스들의 인스턴스들 만을 반환하"
"게 될 것임을 의미한다. 대부분의 용도로, 디폴트인 <literal>polymorphism="
"\"implicit\"</literal>가 적절하다.두 개의 다른 클래스들이 동일한 테이블로 매"
"핑될 때 Explicit 다형성이 유용하다(이것은 테이블 컬럼들의 서브셋을 포함하는 "
"\"경량급\" 클래스를 허용한다)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>persister attribute lets you customize the "
"persistence strategy used for the class. You can, for example, specify your "
"own subclass of <literal>org.hibernate.persister.EntityPersister, "
"or you can even provide a completely new implementation of the interface "
"<literal>org.hibernate.persister.ClassPersister that implements, "
"for example, persistence via stored procedure calls, serialization to flat "
"files or LDAP. See <literal>org.hibernate.test.CustomPersister for "
"a simple example of \"persistence\" to a <literal>Hashtable."
msgstr ""
"<literal>persister 속성은 클래스에 사용되는 영속화 방도를 당신이 커"
"스트마이징 할 수 있도록 해준다. 예를 들어 당신은 <literal>org.hibernate."
"persister.EntityPersister</literal>에 대한 당신 자신의 서브클래스를 지정할 수"
"도 있거나 당신은 심지어 예를 들어 플랫 파일들이나 LDAP로의 직렬화,내장 프로시"
"저 호출들을 통해 영속화를 구현하는 인터페이스 <literal>org.hibernate."
"persister.ClassPersister</literal>에 대한 완전히 새로운 구현을 제공할 수도 있"
"다. (<literal>Hashtable로의 \"영속성\"에 관한) 간단한 예제는 "
"<literal>org.hibernate.test.CustomPersister를 보라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>dynamic-update and dynamic-insert "
"settings are not inherited by subclasses, so they can also be specified on "
"the <literal><subclass> or <joined-subclass> 설정과 dynamic-insert 설"
"정은 서브클래스들에 의해 상속되지 않고 따라서 또한 <literal><subclass>"
"</literal> 또는 <joined-subclass> 요소들 상에 지정"
"될 수도 있음을 노트하라. 이들 설정들은 몇몇 경우들에서 퍼포먼스를 증가시키지"
"만 다른 경우들에서는 퍼포먼스를 실제로 감소시킬 수도 있다. 적절하게 사용하라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Use of <literal>select-before-update will usually decrease "
"performance. It is useful to prevent a database update trigger being called "
"unnecessarily if you reattach a graph of detached instances to a "
"<literal>Session."
msgstr ""
"<literal>select-before-update 사용은 대개 퍼포먼스를 감소시킬 것이"
"다. 당신이 detached 인스턴스들의 그래프를 <literal>Session에 다시 "
"첨부할 경우에 그것은 데이터베이스 업데이트 트리거가 불필요하게 호출되는 것을 "
"방지하는데 매우 유용하다."

#. Tag: para
#, no-c-format
msgid ""
"If you enable <literal>dynamic-update, you will have a choice of "
"optimistic locking strategies:"
msgstr ""
"<literal>dynamic-update를 사용가능하게 할 경우, 당신은 다음 "
"optimistic 잠금 전략들을 선택하게 될 것이다:"

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>version: check the version/timestamp columns"
msgstr "<literal>version은 version/timestamp 컬럼들을 체크한다"

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>all: check all columns"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>dirty: check the changed columns, allowing some "
"concurrent updates"
msgstr ""
"<literal>dirty는 몇몇 동시성 업데이트들을 허용하여, 변경된 컬럼들"
"을 체크한다"

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>none: do not use optimistic locking"
msgstr "<literal>none은 optimistic 잠금을 사용하지 않는다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"It is <emphasis>strongly recommended that you use version/"
"timestamp columns for optimistic locking with Hibernate. This strategy "
"optimizes performance and correctly handles modifications made to detached "
"instances (i.e. when <literal>Session.merge() is used)."
msgstr ""
"우리는 당신이 Hibernate에서 optimistic 잠금을 위해 version/timestamp 컬럼들"
"을 사용할 것을 <emphasis>매우 강력하게 권장한다. 이것은 퍼포먼스"
"에 대해 최적의 방도이고 detached 인스턴스들에 대해 행해진 변경들을 정확하게 "
"핸들링하는 유일한 방도이다(예를 들어 <literal>Session.merge()가 사"
"용될 때)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"There is no difference between a view and a base table for a Hibernate "
"mapping. This is transparent at the database level, although some DBMS do "
"not support views properly, especially with updates. Sometimes you want to "
"use a view, but you cannot create one in the database (i.e. with a legacy "
"schema). In this case, you can map an immutable and read-only entity to a "
"given SQL subselect expression:"
msgstr ""
"Hibernate 매핑의 경우에 베이스 테이블과 뷰 사이에 차이점이 존재하지 않는다. "
"왜냐하면 이것이 데이터베이스 레벨에서는 투명하다고 기대되기 때문이다(몇몇 "
"DBMS는 뷰를 고유하게 지원하지 않고 특히 뷰 업데이트를 지원하지 않음을 노트하"
"라). 때때로 당신이 뷰를 사용하고자 원하지만, (예를 들어 리거시 스키마로) 데이"
"터베이스 속에 뷰를 생성시킬 수 없다. 이 경우에, 당신은 불변의 읽기 전용 엔티"
"티를 주어진 SQL subselect 표현식으로 매핑시킬 수 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Declare the tables to synchronize this entity with, ensuring that auto-flush "
"happens correctly and that queries against the derived entity do not return "
"stale data. The <literal><subselect> is available both as an "
"attribute and a nested mapping element."
msgstr ""
"auto-flush가 정확하게 발생하도록 하고, 그리고 파생된 엔티티에 대한 질의들이 "
"쓸효성 없는 데이터를 반환하지 않도록 함으로써, 이 엔티티와 동기화 될 테이블"
"을 선언하라. <literal><subselect>는 속성과 내포된 매핑 요소 "
"양자로서 이용 가능하다."

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

#. Tag: para
#, no-c-format
msgid ""
"Mapped classes <emphasis>must declare the primary key column of "
"the database table. Most classes will also have a JavaBeans-style property "
"holding the unique identifier of an instance. The <literal><id> 요소"
"는 그 프로퍼티로부터 프라이머리 키 컬럼으로의 매핑을 정의한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>name (optional): the name of the identifier property."
msgstr "<literal>name (옵션): 식별자 프로퍼티의 이름."

#. Tag: para
#, no-c-format
msgid ""
"<literal>type (optional): a name that indicates the Hibernate type."
msgstr "<literal>type (옵션): Hibernate 타입을 나타내는 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>column (optional - defaults to the property name): the "
"name of the primary key column."
msgstr ""
"<literal>column (옵션 - 디폴트는 프로퍼티 이름): 프라이머리 키 컬럼"
"의 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>unsaved-value (optional - defaults to a \"sensible\" "
"value): an identifier property value that indicates an instance is newly "
"instantiated (unsaved), distinguishing it from detached instances that were "
"saved or loaded in a previous session."
msgstr ""
"<literal>unsaved-value (옵션 - 디폴트는 \"sensible\" 값): 이전 세션"
"에서 저장되었거나 로드되었던 detached(분리된) 인스턴스들로부터 그것을 구분지"
"우도록, 인스턴스가 새로이 초기화되어 있음(저장되어 있지 않음)을 나타내는 식별"
"자 프로퍼티 값."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>access (optional - defaults to property (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 액세스하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 액세스하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근 하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 액세스하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도."

#. Tag: para
#, no-c-format
msgid ""
"If the <literal>name attribute is missing, it is assumed that the "
"class has no identifier property."
msgstr ""
"<literal>name 속성이 누락되면, 클래스는 식별자 프로퍼티를 갖지 않는"
"다고 가정된다."

#. Tag: para
#, no-c-format
msgid ""
"The <literal>unsaved-value attribute is almost never needed in "
"Hibernate3."
msgstr ""
"<literal>unsaved-value 속성은 Hibernate3에서는 거의 필요하지 않다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"There is an alternative <literal><composite-id> declaration "
"that allows access to legacy data with composite keys. Its use is strongly "
"discouraged for anything else."
msgstr ""
"composite 키들로서 리거시 데이터에 액세스하는 것을 허용해주는 대체적인 "
"<literal><composite-id> 선언이 존재한다. 우리는 그 밖의 어떤"
"것에 대한 그것의 사용에 대해 강력하게 반대한다."

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

#. Tag: para
#, no-c-format
msgid ""
"The optional <literal><generator> child element names a Java "
"class used to generate unique identifiers for instances of the persistent "
"class. If any parameters are required to configure or initialize the "
"generator instance, they are passed using the <literal><param> 자식 요소는 영속 클래스의 인스"
"턴스들에 대한 유일 식별자들을 생성시키는데 사용되는 자바 클래스를 명명한다. "
"만일 임의의 파라미터들이 생성기 인스턴스를 구성하거나 초기화 시키는데 필요할 "
"경우, 그것들은 <literal><param> 요소 를 사용하여 전달된다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"All generators implement the interface <literal>org.hibernate.id."
"IdentifierGenerator</literal>. This is a very simple interface. Some "
"applications can choose to provide their own specialized implementations, "
"however, Hibernate provides a range of built-in implementations. The "
"shortcut names for the built-in generators are as follows:"
msgstr ""
"모든 생성기들은 <literal>org.hibernate.id.IdentifierGenerator 인터"
"페이스를 구현한다. 이것은 매우 간단한 인터페이스이다; 몇몇 어플리케이션들은 "
"그것들 자신의 특화된 구현들을 제공하도록 선택할 수 있다. 하지만 Hibernate는 "
"미리 빈드된 구현들의 영역들을 제공한다. 빌드-인 생성기(generator)들에 대한 단"
"축 이름들이 존재한다: <placeholder-1/>"

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>increment"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, no-c-format
msgid ""
"generates identifiers of type <literal>long, shortint that are unique only when no other "
"process is inserting data into the same table. <emphasis>Do not use in a "
"cluster.</emphasis>"
msgstr ""
"동일한 테이블 속으로 데이터를 입력하는 다른 프로세스가 없을 때에만 유일한 "
"<literal>long, short 또는 int클러스터 내에서는 사용하지 "
"말라.</emphasis>"

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>identity"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, no-c-format
msgid ""
"supports identity columns in DB2, MySQL, MS SQL Server, Sybase and "
"HypersonicSQL. The returned identifier is of type <literal>long, "
"<literal>short or int."
msgstr ""
"DB2, MySQL, MS SQL Server, Sybase, HypersonicSQL에서 식별 컬럼들을 지원한다. "
"반환되는 식별자는 <literal>long, short 또는 "
"<literal>int 타입이다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>sequence"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, no-c-format
msgid ""
"uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in "
"Interbase. The returned identifier is of type <literal>long, "
"<literal>short or int"
msgstr ""
"DB2, PostgreSQL, Oracle, SAP DB, McKoi에서 시퀀스를 사용하거나 Interbase에서 "
"생성기(generator)를 사용한다. 반환되는 식별자는 <literal>long, "
"<literal>short 또는 int 타입이다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>hilo"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, no-c-format
msgid ""
"uses a hi/lo algorithm to efficiently generate identifiers of type "
"<literal>long, short or int, "
"given a table and column (by default <literal>hibernate_unique_key "
"and <literal>next_hi respectively) as a source of hi values. The "
"hi/lo algorithm generates identifiers that are unique only for a particular "
"database."
msgstr ""
"테이블과 컬럼(디폴트로 각각 <literal>hibernate_unique_key와 "
"<literal>next_hi)이 hi 값들의 소스로서 주어지면, longshort 또는 int 타입의 식별자"
"들을 효과적으로 생성시키는데 hi/lo 알고리즘을 사용한다. hi/lo 알고리즘은 특"
"정 데이터베이스에 대해서만 유일한 식별자들을 생성시킨다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>seqhilo"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, no-c-format
msgid ""
"uses a hi/lo algorithm to efficiently generate identifiers of type "
"<literal>long, short or int, "
"given a named database sequence."
msgstr ""
"명명된 데이터베이스 시퀀스가 주어지면, <literal>long, "
"<literal>short 또는 int 타입의 식별자들을 효과적"
"으로 생성시키는데 hi/lo 알고리즘을 사용한다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>uuid"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"uses a 128-bit UUID algorithm to generate identifiers of type string that "
"are unique within a network (the IP address is used). The UUID is encoded as "
"a string of 32 hexadecimal digits in length."
msgstr ""
"네트웍 내에서 유일한(IP 주소가 사용된다) string 타입의 식별자들을 생성시키기 "
"위해 128 비트 UUID 알고리즘을 사용한다. UUID는 길이가 32인 16진수들의 문자열"
"로서 인코딩 된다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>guid"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, no-c-format
msgid "uses a database-generated GUID string on MS SQL Server and MySQL."
msgstr "MS SQL Server와 MySQL 상에서 데이터베이스 생성 GUID 문자열을 사용한다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>native"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"selects <literal>identity, sequence or "
"<literal>hilo depending upon the capabilities of the underlying "
"database."
msgstr ""
"기본 데이터베이스의 가용성들에 의존하여 <literal>identity, "
"<literal>sequence 또는 hilo를 찾아낸다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>assigned"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"lets the application assign an identifier to the object before <literal>save"
"()</literal> is called. This is the default strategy if no <"
"generator></literal> element is specified."
msgstr ""
"어플리케이션으로 하여금 <literal>save()가 호출되기 전에 식별자를 객"
"체에 할당하도록 한다. <literal><generator> 요소가 지정되지 않"
"을 경우 이것이 디폴트 방도이다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>select"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"retrieves a primary key, assigned by a database trigger, by selecting the "
"row by some unique key and retrieving the primary key value."
msgstr ""
"어떤 유일 키에 의해 행을 select하고 프라이머리 키 값을 검색함으로써 데이터베"
"이스 트리거에 의해 할당된 프라이머리 키를 검색한다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>foreign"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"uses the identifier of another associated object. It is usually used in "
"conjunction with a <literal><one-to-one> primary key "
"association."
msgstr ""
"또 다른 연관된 객체의 식별자를 사용한다. 대개 <literal><one-to-one>"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"a specialized sequence generation strategy that utilizes a database sequence "
"for the actual value generation, but combines this with JDBC3 "
"getGeneratedKeys to return the generated identifier value as part of the "
"insert statement execution. This strategy is only supported on Oracle 10g "
"drivers targeted for JDK 1.4. Comments on these insert statements are "
"disabled due to a bug in the Oracle drivers."
msgstr ""
"실제 값 생성을 위해 데이터베이스 시퀀스를 활용하지만, 생성된 식별자 값을 "
"insert 문장 실행의 부분으로서 실제로 반환시키기 위해 이것을 JDBC3 "
"getGeneratedKeys와 결합시킨 특화된 시퀀스 생성 방도. 이 방도는 JDK 1.4에 대상"
"화된 Oracle 10g 드라이버들 상에서만 지원되는 거승로 알려져 있다. 이들 insert "
"문장들에 대한 주석들은 Oracle 드라이버들 내에 있는 버그 때문에 사용불가능하"
"게 되어 있음을 노트하라."

#. Tag: title
#, no-c-format
msgid "Hi/lo algorithm"
msgstr "Hi/lo algorithm"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>hilo and seqhilo generators "
"provide two alternate implementations of the hi/lo algorithm. The first "
"implementation requires a \"special\" database table to hold the next "
"available \"hi\" value. Where supported, the second uses an Oracle-style "
"sequence."
msgstr ""
"<literal>hilo와 seqhilo 생성기들은 식별자 생성"
"에 대한 마음에 드는 접근법인, hi/lo 알고리즘에 대한 두 개의 대체 구현들은 제"
"공한다. 첫 번째 구현은 다음에 이용 가능한 \"hi\" 값을 수용하기 위한 \"특별한"
"\" 데이터베이스 테이블을 필요로 한다. 두 번째는 (지원되는) Oracle 스타일의 시"
"퀀스를 사용한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Unfortunately, you cannot use <literal>hilo when supplying your "
"own <literal>Connection to Hibernate. When Hibernate uses an "
"application server datasource to obtain connections enlisted with JTA, you "
"must configure the <literal>hibernate.transaction.manager_lookup_class을 제공"
"할 때 <literal>hilo를 사용할 수 없다. Hibernate가 JTA의 도움을 받"
"는 커넥션들을 얻기 위해 어플리케이션 서버 데이터소스를 사용할 때 당신은 "
"<literal>hibernate.transaction.manager_lookup_class를 적절하게 구성"
"해야 한다."

#. Tag: title
#, no-c-format
msgid "UUID algorithm"
msgstr "UUID 알고리즘"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The UUID contains: IP address, startup time of the JVM that is accurate to a "
"quarter second, system time and a counter value that is unique within the "
"JVM. It is not possible to obtain a MAC address or memory address from Java "
"code, so this is the best option without using JNI."
msgstr ""
"UUID 는 다음을 포함한다: IP 주소, JVM의 시작 시간(정확히 1/4 초), 시스템 시간"
"과 (JVM 내에서 유일한) counter 값. Java 코드로부터 MAC 주소 또는 메모리 주소"
"를 얻는 것은 불가능하여서, 이것은 우리가 JNI를 사용하지 않고서 행할 수 있는 "
"최상의 것이다."

#. Tag: title
#, no-c-format
msgid "Identity columns and sequences"
msgstr "식별 컬럼들과 시퀀스들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"For databases that support identity columns (DB2, MySQL, Sybase, MS SQL), "
"you can use <literal>identity key generation. For databases that "
"support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you "
"can use <literal>sequence style key generation. Both of these "
"strategies require two SQL queries to insert a new object. For example:"
msgstr ""
"식별 컬럼들을 지원하는 데이터베이스들(DB2, MySQL, Sybase, MS SQL)의 경우, 당"
"신은 <literal>identity 키 생성을 사용할 수 있다. 시퀀스들을 지원하"
"는 데이터베이스들(DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB)의 경우, "
"당신은 <literal>sequence 스타일 키 생성을 사용할 수도 있다. 이들 방"
"도들 모두 새로운 객체를 insert하기 위해 두 개의 SQL 질의들을 필요로 한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"For cross-platform development, the <literal>native strategy will, "
"depending on the capabilities of the underlying database, choose from the "
"<literal>identity, sequence and hilo 방도가 기준 데이터베이"
"스들의 가용성들에 따라 <literal>identity, sequencehilo 방도 중에서 선택될 것이다."

#. Tag: title
#, no-c-format
msgid "Assigned identifiers"
msgstr "할당된 식별자들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"If you want the application to assign identifiers, as opposed to having "
"Hibernate generate them, you can use the <literal>assigned "
"generator. This special generator uses the identifier value already assigned "
"to the object's identifier property. The generator is used when the primary "
"key is a natural key instead of a surrogate key. This is the default "
"behavior if you do not specify a <literal><generator> "
"element."
msgstr ""
"(Hibernate로 하여금 식별자들을 생성시키도록 하는 것과는 반대로) 당신이 어플리"
"케이션으로 하여금 식별자들을 할당하도록 원할 경우, 당신은 <literal>assigned 요소를 지정하지 않을 경우에 이것이 디폴"
"트 특징이다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>assigned generator makes Hibernate use "
"<literal>unsaved-value=\"undefined\". This forces Hibernate to go "
"to the database to determine if an instance is transient or detached, unless "
"there is a version or timestamp property, or you define <literal>Interceptor."
"isUnsaved()</literal>."
msgstr ""
"<literal>assigned 생성기(generator)를 선택하는 것은 , version 또는 "
"timestamp 프로퍼티가 존재하지 않는 한 또는 당신이 <literal>Interceptor."
"isUnsaved()</literal>를 정의하지 않는 한, 하나의 인스턴스가 transient 또는 "
"detached인지를 결정하기 위해 Hibernae로 하여금 데이터베이스에 접촉하도록 강제"
"하는, <literal>unsaved-value=\"undefined\"를 Hibernate에게 사용하도"
"록 한다."

#. Tag: title
#, no-c-format
msgid "Primary keys assigned by triggers"
msgstr "트리거들에 의해 할당된 프라이머리 키들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Hibernate does not generate DDL with triggers. It is for legacy schemas only."
msgstr ""
"리거시 스키마에 대해서만(Hibernate는 트리거들을 가진 DDL을 생성시키지 않는"
"다)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"In the above example, there is a unique valued property named "
"<literal>socialSecurityNumber. It is defined by the class, as a "
"natural key and a surrogate key named <literal>person_id, whose "
"value is generated by a trigger."
msgstr ""
"위의 예제에서, natural 키로서 클래스에 의해 <literal>socialSecurityNumber로 명명된 대용키가 존재한다."

#. Tag: title
#, no-c-format
msgid "Enhanced identifier generators"
msgstr "NOT TRANSLATED!Enhanced identifier generators"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Starting with release 3.2.3, there are 2 new generators which represent a re-"
"thinking of 2 different aspects of identifier generation. The first aspect "
"is database portability; the second is optimization Optimization means that "
"you do not have to query the database for every request for a new identifier "
"value. These two new generators are intended to take the place of some of "
"the named generators described above, starting in 3.3.x. However, they are "
"included in the current releases and can be referenced by FQN."
msgstr ""
"Starting with release 3.2.3, there are 2 new generators which represent a re-"
"thinking of 2 different aspects of identifier generation. The first aspect "
"is database portability; the second is optimization (not having to query the "
"database for every request for a new identifier value). These two new "
"generators are intended to take the place of some of the named generators "
"described above (starting in 3.3.x); however, they are included in the "
"current releases and can be referenced by FQN."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The first of these new generators is <literal>org.hibernate.id.enhanced."
"SequenceStyleGenerator</literal> which is intended, firstly, as a "
"replacement for the <literal>sequence generator and, secondly, as "
"a better portability generator than <literal>native. This is "
"because <literal>native generally chooses between "
"<literal>identity and sequence which have "
"largely different semantics that can cause subtle issues in applications "
"eyeing portability. <literal>org.hibernate.id.enhanced."
"SequenceStyleGenerator</literal>, however, achieves portability in a "
"different manner. It chooses between a table or a sequence in the database "
"to store its incrementing values, depending on the capabilities of the "
"dialect being used. The difference between this and <literal>native generator and secondly as a better "
"portability generator than <literal>native (because "
"<literal>native (generally) chooses between identitysequence which have largely different "
"semantics which can cause subtle isssues in applications eyeing "
"portability). <literal>org.hibernate.id.enhanced.SequenceStyleGenerator is that table-"
"based and sequence-based storage have the same exact semantic (in fact "
"sequences are exactly what Hibernate tries to emmulate with its table-based "
"generators). This generator has a number of configuration parameters: "
"<placeholder-1/>"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>sequence_name (optional, defaults to "
"<literal>hibernate_sequence): the name of the sequence or table to "
"be used."
msgstr ""
"<literal>sequence_name (optional, defaults to "
"<literal>hibernate_sequence): The name of the sequence (or table) "
"to be used."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>initial_value (optional, defaults to 1 (optional, defaults to 1 (optional - defaults to 1 (optional, defaults to 1 (optional - defaults to false (optional, defaults to false (optional - defaults to next_val (optional, defaults to next_val (optional - defaults to none (optional, defaults to none"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The second of these new generators is <literal>org.hibernate.id.enhanced."
"TableGenerator</literal>, which is intended, firstly, as a replacement for "
"the <literal>table generator, even though it actually functions "
"much more like <literal>org.hibernate.id.MultipleHiLoPerTableGeneratororg.hibernate.id."
"MultipleHiLoPerTableGenerator</literal> that utilizes the notion of "
"pluggable optimizers. Essentially this generator defines a table capable of "
"holding a number of different increment values simultaneously by using "
"multiple distinctly keyed rows. This generator has a number of configuration "
"parameters:"
msgstr ""
"The second of these new generators is <literal>org.hibernate.id.enhanced."
"TableGenerator</literal> which is intended firstly as a replacement for the "
"<literal>table generator (although it actually functions much more "
"like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator) and "
"secondly as a re-implementation of <literal>org.hibernate.id."
"MultipleHiLoPerTableGenerator</literal> utilizing the notion of pluggable "
"optimiziers. Essentially this generator defines a table capable of holding a "
"number of different increment values simultaneously by using multiple "
"distinctly keyed rows. This generator has a number of configuration "
"parameters: <placeholder-1/>"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>table_name (optional - defaults to "
"<literal>hibernate_sequences): the name of the table to be used."
msgstr ""
"<literal>table_name (optional, defaults to "
"<literal>hibernate_sequences): The name of the table to be used."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>value_column_name (optional - defaults to "
"<literal>next_val): the name of the column on the table that is "
"used to hold the value."
msgstr ""
"<literal>value_column_name (optional, defaults to "
"<literal>next_val): The name of the column on the table which is "
"used to hold the value."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>segment_column_name (optional - defaults to "
"<literal>sequence_name): the name of the column on the table that "
"is used to hold the \"segment key\". This is the value which identifies "
"which increment value to use."
msgstr ""
"<literal>segment_column_name (optional, defaults to "
"<literal>sequence_name): The name of the column on the table which "
"is used to hold the \"segement key\". This is the value which distinctly "
"identifies which increment value to use."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>segment_value (optional - defaults to default (optional, defaults to default (optional - defaults to "
"<literal>255): Used for schema generation; the column size to "
"create this segment key column."
msgstr ""
"<literal>segment_value_length (optional, defaults to 255 (optional - defaults to 1 (optional, defaults to 1 (optional - defaults to 1 (optional, defaults to 1 (optional - defaults to ): "
"See <xref linkend=\"mapping-declaration-id-enhanced-optimizers\" />"
msgstr ""
"<literal>optimizer (optional, defaults to none"

#. Tag: title
#, no-c-format
msgid "Identifier generator optimization"
msgstr "NOT TRANSLATED! Identifier generator optimization"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"For identifier generators that store values in the database, it is "
"inefficient for them to hit the database on each and every call to generate "
"a new identifier value. Instead, you can group a bunch of them in memory and "
"only hit the database when you have exhausted your in-memory value group. "
"This is the role of the pluggable optimizers. Currently only the two "
"enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\" /> "
"support this operation."
msgstr ""
"For identifier generators which store values in the database, it is "
"inefficient for them to hit the database on each and every call to generate "
"a new identifier value. Instead, you'd ideally want to group a bunch of them "
"in memory and only hit the database when you have exhausted your in-memory "
"value group. This is the role of the pluggable optimizers. Currently only "
"the two enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced"
"\"/> support this notion. <placeholder-1/>"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>none (generally this is the default if no optimizer was "
"specified): this will not perform any optimizations and hit the database for "
"each and every request."
msgstr ""
"<literal>none (generally this is the default if no optimizer was "
"specified): This says to not perform any optimizations, and hit the database "
"each and every request."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>hilo: applies a hi/lo algorithm around the database "
"retrieved values. The values from the database for this optimizer are "
"expected to be sequential. The values retrieved from the database structure "
"for this optimizer indicates the \"group number\". The "
"<literal>increment_size is multiplied by that value in memory to "
"define a group \"hi value\"."
msgstr ""
"<literal>hilo: applies a hi/lo algorithm around the database "
"retrieved values. The values from the database for this optimizer are "
"expected to be sequential. The values retrieved from the database structure "
"for this optimizer indicates the \"group number\"; the "
"<literal>increment_size is multiplied by that value in memory to "
"define a group \"hi value\"."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>pooled: as with the case of hilo, this "
"optimizer attempts to minimize the number of hits to the database. Here, "
"however, we simply store the starting value for the \"next group\" into the "
"database structure rather than a sequential value in combination with an in-"
"memory grouping algorithm. Here, <literal>increment_size refers to "
"the values coming from the database."
msgstr ""
"<literal>pooled: like was discussed for hilo, "
"this optimizers attempts to minimize the number of hits to the database. "
"Here, however, we simply store the starting value for the \"next group\" "
"into the database structure rather than a sequential value in combination "
"with an in-memory grouping algorithm. <literal>increment_size here "
"refers to the values coming from the database."

#. Tag: title
#, no-c-format
msgid "composite-id"
msgstr "composite-id"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A table with a composite key can be mapped with multiple properties of the "
"class as identifier properties. The <literal><composite-id> "
"element accepts <literal><key-property> property mappings "
"and <literal><key-many-to-one> mappings as child elements."
msgstr ""
"composite 키를 가진 테이블의 경우, 당신은 클래스의 여러 프로퍼티들을 식별자 "
"프로퍼티들로서 매핑할 수 있다. <literal><composite-id> 요소"
"는 자식 요소들로서 <literal><key-property> 프로퍼티 매핑과 "
"<literal><key-many-to-one> 매핑들을 허용한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The persistent class <emphasis>must override equals()hashCode() to implement composite identifier "
"equality. It must also implement <literal>Serializable."
msgstr ""
"당신의 영속 클래스는 composite 식별자 동등성을 구현하기 위해서 "
"<literal>equals()와 hashCode()를 오버라이드 "
"<emphasis>시켜야 한다. 그것은 또한 Serializable"
"을 구현해야 한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Unfortunately, this approach means that a persistent object is its own "
"identifier. There is no convenient \"handle\" other than the object itself. "
"You must instantiate an instance of the persistent class itself and populate "
"its identifier properties before you can <literal>load() the "
"persistent state associated with a composite key. We call this approach an "
"<emphasis>embedded composite identifier, and discourage it for "
"serious applications."
msgstr ""
"불행히도, composite 식별자들에 대한 이 접근법은 영속 객체가 그것 자신의 식별"
"자라는 점을 의미한다. 객체 자신 외의 다른 \"핸들\"이 존재하지 않는다. 당신은 "
"당신이 composite key로 연관된 영속 상태를 <literal>load() 할 수 있"
"기 이전에 영속 클래스 그 자체의 인스턴스를 초기화 하고 그것의 식별자 프로퍼티"
"들을 군집화 시켜야 한다. 우리는 이 접근법을 <emphasis>embedded "
"composite 식별자로 부르고, 중대한 어플리케이션들에 대해 그것을 억제시킨다."

#. Tag: para
#, no-c-format
msgid ""
"A second approach is what we call a <emphasis>mapped composite "
"identifier, where the identifier properties named inside the <literal><"
"composite-id></literal> element are duplicated on both the persistent "
"class and a separate identifier class."
msgstr ""
"두 번째 접근법은 우리가 <emphasis>mapped composite 식별자라고 부르"
"는 것인데, 여기서 <literal><composite-id> 요소 내에 명명된 여"
"기서 식별자 프로퍼티들은 영속 클래스와 별도의 식별자 클래스 양자 상에 중복된"
"다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"In this example, both the composite identifier class, <literal>MedicareId and dependent. The "
"identifier class must override <literal>equals() and "
"<literal>hashCode() and implement Serializable. "
"The main disadvantage of this approach is code duplication."
msgstr ""
"이 예제에서, composite 식별자 클래스인 <literal>MedicareId와 엔티"
"티 크래스 그 자체 양자는 <literal>medicareNumber와 "
"<literal>dependent로 명명된 프로퍼티들을 갖는다. 식별자 클래스는 "
"<literal>equals()와 hashCode()를 오버라이드 시켜"
"고 <literal>Serializable을 구현해야 한다. 이 접근법의 단점은 아주 "
"명백한—코드 중복이다."

#. Tag: para
#, no-c-format
msgid ""
"The following attributes are used to specify a mapped composite identifier:"
msgstr "다음 속성들은 매핑된 composite 식별자를 지정하는데 사용된다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>mapped (optional - defaults to false): "
"indicates that a mapped composite identifier is used, and that the contained "
"property mappings refer to both the entity class and the composite "
"identifier class."
msgstr ""
"<literal>mapped (옵션, 디폴트는 false): 하나의 "
"매핑된 composite 식별자가 사용됨을, 그리고 포함된 프로퍼티 매핑들이 엔티티 클"
"래스와 composite 식별자 클래스 양자를 참조함을 나타낸다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>class (optional - but required for a mapped composite "
"identifier): the class used as a composite identifier."
msgstr ""
"<literal>class (옵션, 하지만 하나의 매핑된 commposite 식별자에 대해"
"서는 필수적임): 하나의 composite 식별자로서 사용되는 클래스."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"We will describe a third, even more convenient approach, where the composite "
"identifier is implemented as a component class in <xref linkend=\"components-"
"compositeid\" />. The attributes described below apply only to this "
"alternative approach:"
msgstr ""
"우리는 <xref linkend=\"components-compositeid\"/>에서 composite 식별자가 하나"
"의 component 클래스로서 구현되는 보다 편리한 접근법인 세번째 방도를 설명할 것"
"이다. 아래에 설명되어 있는 속성들은 이 대체적인 접근법에만 적용된다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>name (optional - required for this approach): a property "
"of component type that holds the composite identifier. Please see chapter 9 "
"for more information."
msgstr ""
"<literal>name (옵션, 이 접근법의 경우에는 필수임): 하나의 "
"component 식별자를 소유하는 컴포넌트 타입의 프로퍼티(9장을 보라)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>access (optional - defaults to property (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 액세스하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 액세스하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근 하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 액세스하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>class (optional - defaults to the property type "
"determined by reflection): the component class used as a composite "
"identifier. Please see the next section for more information."
msgstr ""
"<literal>class (옵션 - 디폴트는 reflection에 의해 결정된 프로퍼티 "
"타입): 하나의 composite 식별자로서 사용되는 컴포넌트 클래스(다음 절을 보라)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The third approach, an <emphasis>identifier component, is "
"recommended for almost all applications."
msgstr ""
"이 세번째 접근법, <emphasis>identifier component은 거의 모든 어플"
"리케이션들에 대해 우리가 권장하는 것이다."

#. Tag: title
#, fuzzy, no-c-format
msgid "Discriminator"
msgstr "discriminator"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal><discriminator> element is required for "
"polymorphic persistence using the table-per-class-hierarchy mapping "
"strategy. It declares a discriminator column of the table. The discriminator "
"column contains marker values that tell the persistence layer what subclass "
"to instantiate for a particular row. A restricted set of types can be used: "
"<literal>string, character, integerbyte, short, "
"<literal>boolean, yes_no, true_false 요소는 table-per-class-hierarchy(테"
"이블 당 클래스 계층구조) 매핑 방도를 사용하는 다형성 영속화에 필요하고 테이블"
"의 discriminator(판별자) 컬럼을 선언한다. discriminator 컬럼은 특정 행에 대"
"해 초기화 시킬 서브 클래스가 무엇인지를 영속 계층에 알려주는 표시자 값들을 포"
"함한다. 타입들의 제한적인 집합이 사용될 수 있다: <literal>string, "
"<literal>character, integer, byteshort, boolean, "
"<literal>yes_no, true_false."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>column (optional - defaults to class): "
"the name of the discriminator column."
msgstr ""
"<literal>column (옵션 - 디폴트는 class) "
"discriminator 컬럼명."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>type (optional - defaults to string): "
"a name that indicates the Hibernate type"
msgstr ""
"<literal>type (옵션 - 디폴트는 string) "
"Hibernate 타입을 나타내는 이름"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>force (optional - defaults to false): "
"\"forces\" Hibernate to specify the allowed discriminator values, even when "
"retrieving all instances of the root class."
msgstr ""
"<literal>force (옵션 - 디폴트는 false) 이것은 "
"Hibernate로 하여금 루트 클래스의 모든 인스턴스들을 검색할 때조차도 허용된 "
"discriminator 값들을 지정하도록 \"강제한다\"."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>insert (optional - defaults to true): "
"set this to <literal>false if your discriminator column is also "
"part of a mapped composite identifier. It tells Hibernate not to include the "
"column in SQL <literal>INSERTs."
msgstr ""
"<literal>insert (옵션 - 디폴트는 true) 당신의 "
"discriminator 컬럼이 또한 매핑된 composite 식별자의 부분일 경우에 이것을 "
"<literal>false로 설정하라. (Hibernate에게 SQL INSERT (optional): an arbitrary SQL expression that is "
"executed when a type has to be evaluated. It allows content-based "
"discrimination."
msgstr ""
"<literal>formula (옵션) 타입이 평가 되어야 할 때 실행되는 임의의 "
"SQL 표현식. 컨텐츠 기반의 판별을 허용해준다."

#. Tag: para
#, no-c-format
msgid ""
"Actual values of the discriminator column are specified by the "
"<literal>discriminator-value attribute of the <"
"class></literal> and <subclass> elements."
msgstr ""
"discriminator 컬럼의 실제 값들은 <literal><class> 요소와 "
"<literal><subclass> 요소의 discriminator-value attribute is only useful if the table contains "
"rows with \"extra\" discriminator values that are not mapped to a persistent "
"class. This will not usually be the case."
msgstr ""
"<literal>force 속성은 테이블이 영속 클래스로 매핑되지 않는 \"특별한"
"\" discriminator 값들을 가진 행들을 포함할 경우에(만) 유용하다. 이것은 대개 "
"그 경우가 아닐 것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>formula attribute allows you to declare an arbitrary "
"SQL expression that will be used to evaluate the type of a row. For example:"
msgstr ""
"<literal>formula 속성을 사용하여 당신은 행의 타입을 판단하는데 사용"
"될 임의의 SQL 표현식을 선언할 수 있다:"

#. Tag: title
#, fuzzy, no-c-format
msgid "Version (optional)"
msgstr "version (옵션)"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal><version> element is optional and indicates "
"that the table contains versioned data. This is particularly useful if you "
"plan to use <emphasis>long transactions. See below for more "
"information:"
msgstr ""
"<literal><version> 요소는 옵션이고 테이블이 버전화된 데이터"
"를 포함한다는 것을 나타낸다. 이것은 당신이 <emphasis>긴 트랜잭션(long "
"transaction)들</emphasis>을 사용할 계획이라면 특히 유용하다 (아래를 보라)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>column (optional - defaults to the property name): the "
"name of the column holding the version number."
msgstr ""
"<literal>column (옵션 - 디폴트는 프로퍼티 명): 버전 번호를 가진 컬"
"럼의 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>name: the name of a property of the persistent class."
msgstr "<literal>name: 영속 클래스의 프로퍼티 명."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>type (optional - defaults to integer): "
"the type of the version number."
msgstr ""
"<literal>type (옵션 - 디폴트는 integer): 버전 번"
"호의 타입."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>access (optional - defaults to property (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 액세스하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 액세스하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근 하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 액세스하는데 사용할 방도.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>access (옵션 - 디폴트는 property): "
"Hibernate가 프로퍼티 값에 접근하는데 사용할 방도."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>unsaved-value (optional - defaults to undefined "
"specifies that the identifier property value should be used."
msgstr ""
"<literal>unsaved-value (옵션 - 디폴트는 undefined는 식별자 프로퍼티 값이 사용될 것임을 지정한다.)"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>generated (optional - defaults to never for more information."
msgstr ""
"<literal>generated (옵션 - 디폴트는 never): 이 "
"version 프로퍼티 값이 데이터베이스에 의해 실제로 산출되는지를 지정한다. "
"<xref linkend=\"mapping-generated\">산출되는 프로퍼티들에 관한 논의를 "
"보라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>insert (optional - defaults to true): "
"specifies whether the version column should be included in SQL insert "
"statements. It can be set to <literal>false if the database column "
"is defined with a default value of <literal>0."
msgstr ""
"<literal>insert (옵션 - 디폴트는 true): version "
"컬럼이 SQL insert 문장들 속에 포함될 것인지 여부를 지정한다. 데이터베이스 컬"
"럼이 디폴트 값 <literal>0으로 정의되는 경우에만 false, "
"<literal>integer, short, timestampcalendar."
msgstr ""
"버전 번호들은 <literal>long, integer, "
"<literal>short, timestamp 또는 "
"<literal>calendar 타입일 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A version or timestamp property should never be null for a detached "
"instance. Hibernate will detect any instance with a null version or "
"timestamp as transient, irrespective of what other <literal>unsaved-valueDeclaring a nullable version or "
"timestamp property is an easy way to avoid problems with transitive "
"reattachment in Hibernate. It is especially useful for people using assigned "
"identifiers or composite keys</emphasis>."
msgstr ""
"version 또는 timestamp 프로퍼티는 detached 인스턴스에 대해 결코 null일 수가 "
"없어서, Hibernate는 다른 <literal>unsaved-value 방도들이 지정되는 "
"것에 상관없이, null version이나 timestamp를 가진 임의의 인스턴스를 transient"
"로서 검출할 것이다. <emphasis>null 허용되는 version 이나 property를 선언하는 "
"것은 Hibernate에서 transitive reattachment에 대한 임의의 문제들을 피하는 쉬"
"운 방법이고, assigned 식별자들이나 composite key들을 사용하는 사람들에게 특"
"히 유용하다!</emphasis>"

#. Tag: title
#, fuzzy, no-c-format
msgid "Timestamp (optional)"
msgstr "timestamp (옵션)"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The optional <literal><timestamp> element indicates that the "
"table contains timestamped data. This provides an alternative to versioning. "
"Timestamps are a less safe implementation of optimistic locking. However, "
"sometimes the application might use the timestamps in other ways."
msgstr ""
"옵션 <literal><timestamp> 요소는 테이블이 타임스탬프화 된 데"
"이터를 포함함을 나타낸다. 이것은 버전화에 대한 대체물로서 고안되었다. "
"Timestamp은 고유하게 optimistic 잠금에 대한 다소 안전한 구현이다. 하지만 때때"
"로 어플리케이션은 다른 방법들로 timestamp들을 사용할 수도 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>column (optional - defaults to the property name): the "
"name of a column holding the timestamp."
msgstr ""
"<literal>column (옵션 - 디폴트는 프로퍼티 명): 타임스탬프를 포함하"
"는 컬럼 명."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>name: the name of a JavaBeans style property of Java type "
"<literal>Date or Timestamp of the persistent "
"class."
msgstr ""
"<literal>name: 영속 클래스에 대해 자바 Date 또"
"는 <literal>Timestamp 타입을 가진 자바빈즈 스타일의 프로퍼티 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>unsaved-value (optional - defaults to null "
"specifies that the identifier property value should be used."
msgstr ""
"<literal>unsaved-value (옵션 - 디폴트는 null): "
"이전 세션에서 저장되었거나 로드되었던 detached 인스턴스로부터 인스턴스를 구별"
"지우는, 인스턴스가 새로이 초기화됨(unsaved)을 나타내는 version 프로퍼티 값."
"(<literal>undefined는 식별자 프로퍼티 값이 사용될 것임을 지정한다.)"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>source (optional - defaults to vm): "
"Where should Hibernate retrieve the timestamp value from? From the database, "
"or from the current JVM? Database-based timestamps incur an overhead because "
"Hibernate must hit the database in order to determine the \"next value\". It "
"is safer to use in clustered environments. Not all <literal>Dialects (옵션 - 디폴트는 vm): Hibernate"
"는 어디서 timestamp 값을 검색할 것인가? 데이터베이스로부터인가 현재의 JVM으로"
"부터인가? 데이터베이스 기반의 timestamp들은 Hibernate가 \"다음 값\"을 결정하"
"기 위해 데이터베이스에 접속해야 하기 때문에 오버헤드를 초래하지만, 클러스터링"
"된 환경들에서의 용도로 보다 더 안전할 것이다. 또한 모든 <literal>Dialect들은 정밀도 결핍 때문에 잠금"
"에 있어 사용이 안전하지 않을 수 있음을 노트하라(예를 들면 오라클 8)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>generated (optional - defaults to never for more information."
msgstr ""
"<literal>generated (옵션 - 디폴트는 never): 이 "
"timestamp 프로퍼티 값이 데이터베이스에 의해 실제로 생성됨을 지정한다. <xref "
"linkend=\"mapping-generated\">산출되는 프로퍼티들</xref>에 대한 논의들 보라."

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal><Timestamp> is equivalent to <version "
"type=\"timestamp\"></literal>. And <timestamp source=\"db"
"\"></literal> is equivalent to <version type=\"dbtimestamp"
"\"></literal>"
msgstr ""
"<literal><timestamp>는 <version type=\"timestamp"
"\"></literal>과 같음을 노트하라. 그리고 <timestamp use-db="
"\"true\"></literal>는 <version type=\"dbtimestamp\"> element declares a persistent "
"JavaBean style property of the class."
msgstr ""
"<literal><property> 요소는 클래스의 자바빈즈 스타일의 영속 프"
"로퍼티를 선언한다."

#. Tag: para
#, no-c-format
msgid ""
"<literal>name: the name of the property, with an initial lowercase "
"letter."
msgstr "<literal>name: 첫 소문자로 시작하는 프로퍼티 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>column (optional - defaults to the property name): the "
"name of the mapped database table column. This can also be specified by "
"nested <literal><column> element(s)."
msgstr ""
"<literal>column (옵션 - 디폴트는 프로퍼티 이름): 매핑된 데이터베이"
"스 테이블 컬럼의 이름. 이것은 또한 내부에 포함되는 <literal><column> (optional - defaults to true and/or INSERT statements. "
"Setting both to <literal>false allows a pure \"derived\" property "
"whose value is initialized from some other property that maps to the same "
"column(s), or by a trigger or other application."
msgstr ""
"<literal>update, insert (옵션 - 디폴트는 trueUPDATE와/또는 "
"<literal>INSERT 문장들속에 포함될 것임을 지정한다. 둘다 "
"<literal>false로 설정하는 것은 그 값이 동일한 컬럼(들)로 매핑되는 "
"어떤 다른 프로퍼티로부터 또는 트리거에 의해 또는 다른 어플리케이션으로부터 초"
"기화 되는 순수하게 \"파생된(derived)\" 프로퍼티를 허용해준다."

#. Tag: para
#, no-c-format
msgid ""
"<literal>formula (optional): an SQL expression that defines the "
"value for a <emphasis>computed property. Computed properties do "
"not have a column mapping of their own."
msgstr ""
"<literal>formula (옵션): 계산되는 프로퍼티에 "
"대해 값을 정의하는 SQL 표현식. 계산되는 프로퍼티들은 그것들 자신에 대한 컬럼 "
"매핑을 갖지 않는다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>lazy (optional - defaults to false): "
"specifies that this property should be fetched lazily when the instance "
"variable is first accessed. It requires build-time bytecode instrumentation."
msgstr ""
"<literal>lazy (옵션 - 디폴트는 false): 인스턴스 "
"변수가 처음으로 액세스 될 때 이 프로퍼티가 lazily하게 페치될 것임을 지정한다"
"(빌드-시 바이트코드 수단을 필요로 한다)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>unique (optional): enables the DDL generation of a unique "
"constraint for the columns. Also, allow this to be the target of a "
"<literal>property-ref."
msgstr ""
"<literal>unique (옵션): 컬럼들에 대한 유일 컨스트레인트의 DDL 생성"
"을 가능하게 만든다. 또한 이것이 <literal>property-ref의 타켓이 되"
"는 것을 허용해준다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>not-null (optional): enables the DDL generation of a "
"nullability constraint for the columns."
msgstr ""
"<literal>not-null (옵션): 컬럼들에 대해 null 가능 컨스트레인트의 "
"DDL 생성을 가능하게 만든다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>optimistic-lock (optional - defaults to true (옵션 - 디폴트는 true (optional - defaults to never for more information."
msgstr ""
"<literal>generated (옵션 - 디폴트는 never): 이 "
"프로퍼티 값이 데이터베이스에 의해 실제로 산출되는지를 지정한다. <xref "
"linkend=\"mapping-generated\">산출되는 프로퍼티들</xref>에 대한 논의를 보라."

#. Tag: para
#, no-c-format
msgid "<emphasis>typename could be:"
msgstr "<emphasis>typename은 다음일 수 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The name of a Hibernate basic type: <literal>integer, string, character, "
"date, timestamp, float, binary, serializable, object, blob</literal> etc."
msgstr ""
"Hibernate 기본 타입의 이름 (예를 들어. <literal>integer, string, character, "
"date, timestamp, float, binary, serializable, object, blob</literal>)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The name of a Java class with a default basic type: <literal>int, float, "
"char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</"
"literal> etc."
msgstr ""
"디폴트 기본 타입을 가진 Java 클래스의 이름(예를 들어. <literal>int, float, "
"char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</"
"literal>)."

#. Tag: para
#, no-c-format
msgid "The name of a serializable Java class."
msgstr "serializable Java 클래스의 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The class name of a custom type: <literal>com.illflow.type.MyCustomTypeHibernate."
"DATE</literal> and Hibernate.TIMESTAMP, or to specify a "
"custom type."
msgstr ""
"만일 당신이 타입을 지정하지 않을 경우, Hibernate는 정확한 Hibernate 타입을 추"
"정하기 위해 명명된 프로퍼티에 대해 reflection을 사용할 것이다. Hibernate는 "
"그 순서에서 2,3,4 규칙들을 사용하여 프로퍼티 getter의 반환 클래스의 이름을 해"
"석하려고 시도할 것이다. 하지만 이것은 항상 충분하지는 않다. 어떤 경우들에서, "
"당신은 여전히 <literal>type 속성을 필요로 할 것이다.(예를 들어, "
"<literal>Hibernate.DATE와 Hibernate.TIMESTAMP 사"
"이를 구별하기 위해, 또는 맞춤 타입을 지정하기 위해.)"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>access attribute allows you to control how Hibernate "
"accesses the property at runtime. By default, Hibernate will call the "
"property get/set pair. If you specify <literal>access=\"field\", "
"Hibernate will bypass the get/set pair and access the field directly using "
"reflection. You can specify your own strategy for property access by naming "
"a class that implements the interface <literal>org.hibernate.property."
"PropertyAccessor</literal>."
msgstr ""
"<literal>access 속성은 당신으로 하여금 Hibernate가 런타임 시에 프로"
"퍼티에 액세스하는 방법을 제어하도록 해준다. 디폴트로 Hibernate는 프로퍼티 "
"get/set 쌍을 호출할 것이다. 만일 당신이 <literal>access=\"field\""
"를 지정할 경우, Hibernate는 get/set 쌍을 피하고 reflection을 사용하여 직접 필"
"드에 액세스 할 것이다. 당신은 <literal>org.hibernate.property."
"PropertyAccessor</literal> 인터페이스를 구현하는 클래스를 명명함으로써 프로퍼"
"티 접근을 위한 당신 자신의 방도를 지정할 수도 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A powerful feature is derived properties. These properties are by definition "
"read-only. The property value is computed at load time. You declare the "
"computation as an SQL expression. This then translates to a <literal>SELECT in the given example. "
"You can also use the nested <literal><formula> mapping "
"element if you do not want to use the attribute."
msgstr ""
"당신은 특정 컬럼(주어진 예제에서는 <literal>customerId)에 대해 "
"alias를 선언하지 않음으로써 엔티티들 자신의 테이블을 참조할 수 있음을 노트하"
"라. 또한 당신은 만일 당신이 그 속성을 사용하고 싶지 않을 경우에 내포된 "
"<literal><formula> 매핑 요소를 사용할 수 있음을 노트하라."

#. Tag: title
#, fuzzy, no-c-format
msgid "Many-to-one"
msgstr "many-to-one"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"An ordinary association to another persistent class is declared using a "
"<literal>many-to-one element. The relational model is a many-to-"
"one association; a foreign key in one table is referencing the primary key "
"column(s) of the target table."
msgstr ""
"또 다른 영속 클래스에 대한 정규 연관관계는 <literal>many-to-one 요"
"소를 사용하여 선언된다. 관계형 모형은 many-to-one 연관관계이다.: 하나의 테이"
"블 내에 있는 foreign 키는 대상 테이블의 프라이머리 키 컬럼(들)을 참조하고 있"
"다."

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>name: the name of the property."
msgstr "<literal>name: 프로퍼티의 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>column (optional): the name of the foreign key column. "
"This can also be specified by nested <literal><column> "
"element(s)."
msgstr ""
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>column (옵션): foreign key 컬럼의 이름. 이것은 또한 내포"
"된 <literal><column> 요소(들)에 의해 지정된다.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>column (옵션): foreign key 컬럼의 이름. 이것은 또한 내포"
"된 <literal><column> 요소(들)에 의해 지정될 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>class (optional - defaults to the property type "
"determined by reflection): the name of the associated class."
msgstr ""
"<literal>class (옵션 - 디폴트는 reflection에 의해 결정된 프로퍼티 "
"타입): 연관된 클래스의 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>cascade (optional): specifies which operations should be "
"cascaded from the parent object to the associated object."
msgstr ""
"<literal>cascade (옵션) 어느 오퍼레이션들이 부모 객체로부터 연관된 "
"객체로 케스케이드 될 것인지를 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>fetch (optional - defaults to select): "
"chooses between outer-join fetching or sequential select fetching."
msgstr ""
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>fetch (옵션 - 디폴트는 select): outer-"
"join 페칭 또는 sequential select 페칭 사이에서 선택하라.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>fetch (옵션 - 디폴트는 select): outer-"
"join 페칭 또는 순차적인 select 페칭 중에서 선택하라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>update, insert (optional - defaults to true and/or INSERT statements. "
"Setting both to <literal>false allows a pure \"derived\" "
"association whose value is initialized from another property that maps to "
"the same column(s), or by a trigger or other application."
msgstr ""
"<literal>update, insert (옵션 - 디폴트는 true) "
"매핑된 컬럼들이 SQL <literal>UPDATE와/또는 INSERTfalse"
"로 설정하는 것은 그 값이 동일한 컬럼(들)로 매핑시키는 어떤 다른 컬럼들로부터 "
"초기화 되거나 트리거나 다른 어플리케이션에 의해 초기화되는 단순한 \"파생된\" "
"연관관계 값을 허용한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>property-ref (optional): the name of a property of the "
"associated class that is joined to this foreign key. If not specified, the "
"primary key of the associated class is used."
msgstr ""
"<literal>property-ref: (옵션) 이 foreign key에 조인되는 연관된 클래"
"스의 프로퍼티 이름. 지정되지 않을 경우, 연관 클래스의 프라이머리 키가 사용된"
"다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>unique (optional): enables the DDL generation of a unique "
"constraint for the foreign-key column. By allowing this to be the target of "
"a <literal>property-ref, you can make the association multiplicity "
"one-to-one."
msgstr ""
"<literal>unique (옵션): foreign-key 컬럼을 위한 유일 컨스트레인트"
"의 DDL 생성을 가능하도록 해준다. 또한 이것이 property-ref의 대상이 되는 것을 "
"허용해준다. 이것은 연관 다중성(association multiplicity)을 효율적으로 일 대 "
"일로 만든다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>not-null (optional): enables the DDL generation of a "
"nullability constraint for the foreign key columns."
msgstr ""
"<literal>not-null (옵션): foreign key 컬럼들을 위한 null 가능한 컨"
"스트레인트의 DDL 생성을 가능하도록 해준다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>lazy (optional - defaults to proxy): "
"by default, single point associations are proxied. <literal>lazy=\"no-proxy"
"\"</literal> specifies that the property should be fetched lazily when the "
"instance variable is first accessed. This requires build-time bytecode "
"instrumentation. <literal>lazy=\"false\" specifies that the "
"association will always be eagerly fetched."
msgstr ""
"<literal>lazy (옵션 - 디폴트는 proxy): 디폴트"
"로, 단일 포인트 연관들이 프락시된다. <literal>lazy=\"no-proxy\"는 "
"인스턴스 변수가 처음으로 접근될 때 그 프로퍼티가 lazily 페치될 것임을 지정한"
"다(빌드-시 바이트코드 수단을 필요로 한다). <literal>lazy=\"false\""
"는 그 연관이 항상 eagerly 페치될 것임을 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>not-found (optional - defaults to exception will treat a missing row as a null "
"association."
msgstr ""
"<literal>not-found (옵션 - 디폴트는 exception): "
"누락된 행들을 참조하는 foreign key들이 어떻게 처리될 것인지를 지정한다: "
"<literal>ignore는 한 개의 누락된 행을 한 개의 null 연관으로 취급할 "
"것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>entity-name (optional): the entity name of the associated "
"class."
msgstr "<literal>entity-name (옵션): 연관된 클래스의 엔티티 이름."

#. Tag: para
#, no-c-format
msgid ""
"<literal>formula (optional): an SQL expression that defines the "
"value for a <emphasis>computed foreign key."
msgstr ""
"<literal>formula (옵션): 계산된 foreign key에 "
"대한 값을 정의하는 SQL 표현식."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Setting a value of the <literal>cascade attribute to any "
"meaningful value other than <literal>none will propagate certain "
"operations to the associated object. The meaningful values are divided into "
"three categories. First, basic operations, which include: <literal>persist, "
"merge, delete, save-update, evict, replicate, lock and refresh</literal>; "
"second, special values: <literal>delete-orphan; and third,"
"<literal>all comma-separated combinations of operation names: "
"<literal>cascade=\"persist,merge,evict\" or cascade=\"all,"
"delete-orphan\"</literal>. See  "
"for a full explanation. Note that single valued, many-to-one and one-to-one, "
"associations do not support orphan delete."
msgstr ""
"<literal>cascade 속성 값을 none 아닌 어떤 의미있"
"는 다른 값으로 설정하는 것은 어떤 오퍼레이션들을 연관된 객체에게 보급할 것이"
"다. 유의미한 값들은 Hibernate의 기본 오퍼레이션들의 이름들, 즉 "
"<literal>persist, merge, delete, save-update, evict, replicate, lock, "
"refresh</literal> 뿐만 아니라 특별한 값들, 즉 delete-orphanall 그리고 오퍼레이션 이름들의 쉼표 분리된 조합"
"들, 예를 들면 <literal>cascade=\"persist,merge,evict\" 또는 "
"<literal>cascade=\"all,delete-orphan\"이다. 전체 설명은  declaration:"
msgstr ""
"일반적인 <literal>many-to-one 선언은 다음과 같이 간단하게 보여진다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>property-ref attribute should only be used for "
"mapping legacy data where a foreign key refers to a unique key of the "
"associated table other than the primary key. This is a complicated and "
"confusing relational model. For example, if the <literal>Product "
"class had a unique serial number that is not the primary key. The "
"<literal>unique attribute controls Hibernate's DDL generation with "
"the SchemaExport tool."
msgstr ""
"<literal>property-ref 속성은 오직 foreign key가 프라이머리 키가 아"
"닌 연관된 테이블의 유일 키를 참조하는 리거시 데이터를 매핑하는데만 사용된다. "
"이것은 꼴사나운 관계형 모형이다. 예를 들어, <literal>Product 클래스"
"가 프라이머리 키를 아닌, 유일한 시리얼 번호를 갖는다고 가정하자."
"(<literal>unique 속성은 SchemaExport 도구로 Hibernate의 DDL 생성을 "
"제어한다.)"

#. Tag: para
#, no-c-format
msgid "Then the mapping for <literal>OrderItem might use:"
msgstr ""
"그런 다음 <literal>OrderItem에 대한 매핑은 다음을 사용할 것이다:"

#. Tag: para
#, fuzzy, no-c-format
msgid "This is not encouraged, however."
msgstr "하지만 이것은 확실히 권장되지 않는다."

#. Tag: para
#, no-c-format
msgid ""
"If the referenced unique key comprises multiple properties of the associated "
"entity, you should map the referenced properties inside a named <literal><"
"properties></literal> element."
msgstr ""
"만일 참조된 유일 키가 연관된 엔티티의 여러 프로퍼티들을 포함할 경우, 당신은 "
"명명된 <literal><properties> 요소 내부에 참조된 프로퍼티들을 "
"매핑할 것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"If the referenced unique key is the property of a component, you can specify "
"a property path:"
msgstr ""
"만일 참조된 유일키가 컴포넌트의 프로퍼티일 경우, 당신은 하나의 프로퍼티 경로"
"를 지정할 수 있다:"

#. Tag: title
#, fuzzy, no-c-format
msgid "One-to-one"
msgstr "one-to-one"

#. Tag: para
#, no-c-format
msgid ""
"A one-to-one association to another persistent class is declared using a "
"<literal>one-to-one element."
msgstr ""
"또 다른 영속 클래스에 대한 one-to-one 연관관계는 <literal>one-to-one (optional): specifies that a foreign key "
"constraint on the primary key of the mapped table and references the table "
"of the associated class. This option affects the order in which <literal>save"
"()</literal> and delete() are cascaded, and determines "
"whether the association can be proxied. It is also used by the schema export "
"tool."
msgstr ""
"<literal>constrained (옵션) 매핑된 테이블의 프라이머리 키에 대한 "
"foreign 키 컨스트레인트가 연관된 클래스의 테이블을 참조하는지 여부를 지정한"
"다. 이 옵션은 <literal>save()와 delete()가 케스"
"케이드 되는 순서에 영향을 주고, 그 연관이 프락시 될 것인지 여부를 결정한다 "
"(또한 스키마 내보내기 도구에 의해 사용된다)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>property-ref (optional): the name of a property of the "
"associated class that is joined to the primary key of this class. If not "
"specified, the primary key of the associated class is used."
msgstr ""
"<literal>property-ref: (옵션) 이 클래스의 프라이머리 키에 연결된 연"
"관 클래스의 프로퍼티의 이름. 만일 지정되지 않을 경우, 연관 클래스의 프라이머"
"리 키가 사용된다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>formula (optional): almost all one-to-one associations "
"map to the primary key of the owning entity. If this is not the case, you "
"can specify another column, columns or expression to join on using an SQL "
"formula. See <literal>org.hibernate.test.onetooneformula for an "
"example."
msgstr ""
"<literal>formula (옵션): 거의 모든 one to one 연관관계들은 소유하"
"는 엔티티의 프라이머리 키로 매핑된다. 이것이 그 경우가 아닌 드문 경우들에서, "
"당신은 SQL formula 사용에 결합시킬 몇몇 다른 컬럼, 컬럼들, 또는 표현식을 지정"
"할 수 있다.(예제는 <literal>org.hibernate.test.onetooneformula를 보"
"라.)"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>lazy (optional - defaults to proxy): "
"by default, single point associations are proxied. <literal>lazy=\"no-proxy"
"\"</literal> specifies that the property should be fetched lazily when the "
"instance variable is first accessed. It requires build-time bytecode "
"instrumentation. <literal>lazy=\"false\" specifies that the "
"association will always be eagerly fetched. <emphasis>Note that if "
"<literal>constrained=\"false\", proxying is impossible and "
"Hibernate will eagerly fetch the association</emphasis>."
msgstr ""
"<literal>lazy (옵션 - 디폴트는 proxy): 디폴트로 "
"한쪽 끝 연관들이 프락시 된다. <literal>lazy=\"no-proxy\"는 인스턴"
"스 변수가 처음 접근될 때 그 프로퍼티가 lazily 페치될 것임을 지정한다(빌드-시 "
"바이트코드 수단을 필요로 한다). <literal>lazy=\"false\"는 그 연관들"
"이 항상 eagerly 페치될 것임을 지정한다. <emphasis>만일 constrained="
"\"false\"</literal>인 경우에, 프락싱은 불가능하고 Hibernate는 그 연관을 "
"eager 페치시킬 것이다!</emphasis>"

#. Tag: para
#, fuzzy, no-c-format
msgid "There are two varieties of one-to-one associations:"
msgstr "one-to-one 연관관계에는 두 가지 변종이 존재한다:"

#. Tag: para
#, no-c-format
msgid "primary key associations"
msgstr "프라이머리 키 연관관계들"

#. Tag: para
#, no-c-format
msgid "unique foreign key associations"
msgstr "유일 foreign 키 연관관계들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Primary key associations do not need an extra table column. If two rows are "
"related by the association, then the two table rows share the same primary "
"key value. To relate two objects by a primary key association, ensure that "
"they are assigned the same identifier value."
msgstr ""
"프라이머리 키 연관들은 특별한 테이블 컬럼을 필요로 하지 않는다; 만일 두 개의 "
"행들이 그 연관에 의해 관계지워지면, 두 개의 테이블 행들은 동일한 프라이머리 "
"키 값을 공유한다. 따라서 만일 두 개의 객체들이 프라이머리 키 연관에 의해 관계"
"지워지도록 당신이 원할 경우, 당신은 그것들에 동일한 식별자 값이 할당되도록 해"
"야 한다!"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"For a primary key association, add the following mappings to "
"<literal>Employee and Person respectively:"
msgstr ""
"프라이머리 키 연관에 대해, 다음 매핑들을 <literal>Employee와 "
"<literal>Person 각각에 추가하라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Ensure that the primary keys of the related rows in the PERSON and EMPLOYEE "
"tables are equal. You use a special Hibernate identifier generation strategy "
"called <literal>foreign:"
msgstr ""
"이제 우리는 PERSON 과 EMPLOYEE 테이블들에서 관계지워진 행들의 프라이머리 키들"
"이 동일함을 확실히 해야 한다! 우리는 <literal>foreign로 명명되는 특"
"별한 Hibernate 식별자 생성 방도를 사용한다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A newly saved instance of <literal>Person is assigned the same "
"primary key value as the <literal>Employee instance referred with "
"the <literal>employee property of that Person."
msgstr ""
"그때 <literal>Person의 새로이 저장된 인스턴스는 그 "
"<literal>Person의 employee 프로퍼티에 대해 참조"
"된 <literal>Employee 인스턴스와 동일한 프라이머리 키를 할당받는다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Alternatively, a foreign key with a unique constraint, from "
"<literal>Employee to Person, can be expressed "
"as:"
msgstr ""
"달리, <literal>Employee로부터 Person으로의 유일 "
"컨스트레인트를 가진 하나의 foreign key는 다음과 같이 표현될 수 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"This association can be made bidirectional by adding the following to the "
"<literal>Person mapping:"
msgstr ""
"그리고 이 연관은 다음을 <literal>Person 매핑에 추가함으로써 양방향"
"이 될 수 있다:"

#. Tag: title
#, fuzzy, no-c-format
msgid "Natural-id"
msgstr "natural-id"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Although we recommend the use of surrogate keys as primary keys, you should "
"try to identify natural keys for all entities. A natural key is a property "
"or combination of properties that is unique and non-null. It is also "
"immutable. Map the properties of the natural key inside the <literal><"
"natural-id></literal> element. Hibernate will generate the necessary "
"unique key and nullability constraints and, as a result, your mapping will "
"be more self-documenting."
msgstr ""
"비록 우리가 프라이머리 키들로서 대용키들을 사용하는 것을 권장했을지라도, 당신"
"은 여전히 모든 엔티티들에 대한 natural 키들을 식별하고자 원할 것이다. "
"narutal 키는 유일(unique)하고 null이 아닌 프로퍼티 또는 프로퍼티들의 조합이"
"다. 그것이 또한 불변하는 것일 경우가 더 좋다. <literal><natural-id> and "
"<literal>hashCode() to compare the natural key properties of the "
"entity."
msgstr ""
"우리는 당신이 엔티티에 대한 narutal 키 프로퍼티들을 비교하는데 "
"<literal>equals()와 hashCode()를 구현할 것을 강"
"력하게 권장한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"This mapping is not intended for use with entities that have natural primary "
"keys."
msgstr ""
"이 매핑은 natural 프라이머리 키들을 가진 엔티티들을 위한 용도로 고안된 것은 "
"아니다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>mutable (optional - defaults to false (옵션, 디폴트는 false): 디폴트"
"로, narutal 식별자 프로퍼티들은 변경될 수 없는 것(상수)으로 가정된다."

#. Tag: title
#, fuzzy, no-c-format
msgid "Component and dynamic-component"
msgstr "component, dynamic-component"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal><component> element maps properties of a child "
"object to columns of the table of a parent class. Components can, in turn, "
"declare their own properties, components or collections. See the \"Component"
"\" examples below:"
msgstr ""
"<literal><component> 요소는 자식 객체의 프로퍼티들을 부모 클"
"래스에 대한 테이블의 컬럼들로 매핑시킨다. 컴포넌트들은 그것들 자신의 프로퍼티"
"들, 컴포넌트들, 또는 콜렉션들을 선언한다. 이래 \"컴포넌트들\"을 보라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>class (optional - defaults to the property type "
"determined by reflection): the name of the component (child) class."
msgstr ""
"<literal>class (옵션 - 디폴트는 reflection에 의해 결정된 프로퍼티 "
"타입): 컴포넌트(자식) 클래스의 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>insert: do the mapped columns appear in SQL "
"<literal>INSERTs?"
msgstr ""
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>insert: 매핑된 컬럼들이 SQL INSERT들 속"
"에 나타나야 하는가?\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>insert: 매핑된 컬럼들이 SQL INSERT들 내"
"에 나타날 것인가?"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>update: do the mapped columns appear in SQL "
"<literal>UPDATEs?"
msgstr ""
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>update: 매핑된 컬럼들이 SQL UPDATE들 속"
"에 나타나야 하는가?\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>update: 매핑된 컬럼들이 SQL UPDATE들 내"
"에 나타날 것인가?"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>lazy (optional - defaults to false): "
"specifies that this component should be fetched lazily when the instance "
"variable is first accessed. It requires build-time bytecode instrumentation."
msgstr ""
"<literal>lazy (옵션 - 디폴트는 false): 인스턴스 "
"변수가 처음으로 액세스될 때 이 컴포넌트가 lazily(느리게) 페치되어야 하는지 여"
"부를 지정한다 (빌드 시 바이트코드 수단을 필요로 한다)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>optimistic-lock (optional - defaults to true (옵션 - 디폴트는 true (optional - defaults to false): "
"specifies that a unique constraint exists upon all mapped columns of the "
"component."
msgstr ""
"<literal>unique (옵션 - 디폴트는 false): 유일 컨"
"스트레인트가 컴포넌트의 모든 매핑된 컬럼들에 대해 존재하는지 여부를 지정한다."

#. Tag: para
#, no-c-format
msgid ""
"The child <literal><property> tags map properties of the "
"child class to table columns."
msgstr ""
"자식 <literal><property> 태그들은 자식 클래스의 프로퍼티들을 "
"테이블 컬럼들로 매핑시킨다."

#. Tag: para
#, no-c-format
msgid ""
"The <literal><component> element allows a <"
"parent></literal> subelement that maps a property of the component class "
"as a reference back to the containing entity."
msgstr ""
"<literal><component> 요소는 컴포넌트 클래스의 프로퍼티를 포함"
"하는 엔티티에 대한 참조로서 매핑시키는 <literal><parent> 서브"
"요소를 허용한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal><dynamic-component> element allows a "
"<literal>Map to be mapped as a component, where the property names "
"refer to keys of the map. See <xref linkend=\"components-dynamic\" /> for "
"more information."
msgstr ""
"<literal><dynamic-component> 요소는 컴포넌트로서 매핑될"
"<literal>Map을 허용한다. 여기서 프로퍼티 이름들은 map의 키들을 참조"
"한다. <xref linkend=\"components-dynamic\"/>을 보라."

#. Tag: title
#, fuzzy, no-c-format
msgid "Properties"
msgstr "properties"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal><properties> element allows the definition of a "
"named, logical grouping of the properties of a class. The most important use "
"of the construct is that it allows a combination of properties to be the "
"target of a <literal>property-ref. It is also a convenient way to "
"define a multi-column unique constraint. For example:"
msgstr ""
"<literal><properties> 요소는 클래스의 프로퍼티들의 명명된, 논"
"리적 그룹핑에 대한 정의를 허용한다. 그 구조에 대한 가장 중요한 사용은 그것이 "
"프로퍼티들의 조합이 <literal>property-ref의 대상이 되는 것을 허용해"
"준다는 점이다. 또한 그것은 다중 컬럼 유일 컨스트레인느를 정의하는 편리한 방법"
"이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>name: the logical name of the grouping. It is "
"<emphasis>not an actual property name."
msgstr ""
"<literal>name: 그룹핑의 논리적 이름 - 실제 프로퍼티 이름이 "
"<emphasis>아니다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>optimistic-lock (optional - defaults to true (옵션 - 디폴트는 true "
"mapping:"
msgstr ""
"예를 들어, 만일 우리가 다음 <literal><properties> 매핑을 가"
"질 경우:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You might have some legacy data association that refers to this unique key "
"of the <literal>Person table, instead of to the primary key:"
msgstr ""
"그 때 우리는 프라이머리 키가 아닌, <literal>Person 테이블의 이 유"
"일 키를 참조하는 어떤 리거시 데이터 연관을 가질 수 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The use of this outside the context of mapping legacy data is not "
"recommended."
msgstr ""
"우리는 리거시 데이터를 매핑시키는 컨텍스트 바깥에서 이런 종류의 것을 사용하"
"는 것을 권장하지 않는다."

#. Tag: title
#, fuzzy, no-c-format
msgid "Subclass"
msgstr "subclass"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Polymorphic persistence requires the declaration of each subclass of the "
"root persistent class. For the table-per-class-hierarchy mapping strategy, "
"the <literal><subclass> declaration is used. For example:"
msgstr ""
"마지막으로, 다형성 영속성은 루트 영속 클래스에 대한 각각의 서브클래스 선언을 "
"필요로 한다.(권장되는) table-per-class-hierarchy(테이블 당 클래스 계층구조) "
"매핑 방도의 경우, <literal><subclass> 선언이 사용된다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>name: the fully qualified class name of the subclass."
msgstr ""
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>name: 서브클래스의 전체 수식어가 붙은 클래스 이름.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>name: 서브클래스의 전체 수식어가 붙은 클래스 명.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>name: 서브클래스의 전체 수식어가 붙은 클래스 명."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>discriminator-value (optional - defaults to the class "
"name): a value that distinguishes individual subclasses."
msgstr ""
"<literal>discriminator-value (옵션 - 디폴트는 클래스 이름): 개개의 "
"서브클래스들을 구분짓는 값."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>proxy (optional): specifies a class or interface used for "
"lazy initializing proxies."
msgstr ""
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>proxy (옵션): lazy 초기화 프락시들을 사용하는데 클래스 또"
"는 인터페이스를 지정한다.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>proxy (옵션): 프락시들을 lazy 초기화 시키는데 사용할 클래"
"스 또는 인터페이스를 지정한다.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>proxy (옵션): 프락시들을 lazy 초기화 시키는데 사용할 클래"
"스 또는 인터페이스를 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>lazy (optional - defaults to true): "
"setting <literal>lazy=\"false\" disables the use of lazy fetching."
msgstr ""
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>lazy (옵션 - 디폴트는 true): "
"<literal>lazy=\"false\" 설정은 lazy 페칭의 사용을 불가능하게 만든"
"다.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>lazy (옵션 - 디폴트는 true): "
"<literal>lazy=\"false\" 설정은 lazy 페칭을 사용불가능하게 만든다\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>lazy (옵션 - 디폴트는 true): "
"<literal>lazy=\"false\" 설정은 lazy 페칭을 사용불가능하게 만든다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Each subclass declares its own persistent properties and subclasses. "
"<literal><version> and <id> "
"properties are assumed to be inherited from the root class. Each subclass in "
"a hierarchy must define a unique <literal>discriminator-value. If "
"this is not specified, the fully qualified Java class name is used."
msgstr ""
"각각의 서브클래스는 그것 자신의 영속 프로퍼티들과 서브클래스들을 선언할 것이"
"다. <literal><version> 프로퍼티와 <id>를 정의해야 한"
"다. none이 지정될 경우, 전체 수식어가 붙은 자바 클래스 이름이 사용된다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"For information about inheritance mappings see <xref linkend=\"inheritance"
"\" />."
msgstr "상속 매핑들에 대한 정보는 <xref linkend=\"inheritance\"/>을 보라."

#. Tag: title
#, fuzzy, no-c-format
msgid "Joined-subclass"
msgstr "joined-subclass"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Each subclass can also be mapped to its own table. This is called the table-"
"per-subclass mapping strategy. An inherited state is retrieved by joining "
"with the table of the superclass. To do this you use the <literal><joined-"
"subclass></literal> element. For example:"
msgstr ""
"다른 방법으로 각각의 서브클래스는 그것 자신이 테이블로 매핑될 수 있다(table-"
"per-subclass 매핑 방도). 상속된 상태는 슈퍼클래스의 테이블과 조인함으로써 검"
"색된다. 우리는 <literal><joined-subclass> 요소를 사용한다."

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>table: the name of the subclass table."
msgstr "<literal>table: 서브클래스 테이블의 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>proxy (optional): specifies a class or interface to use "
"for lazy initializing proxies."
msgstr ""
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>proxy (옵션): lazy 초기화 프락시들을 사용하는데 클래스 또"
"는 인터페이스를 지정한다.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>proxy (옵션): 프락시들을 lazy 초기화 시키는데 사용할 클래"
"스 또는 인터페이스를 지정한다.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>proxy (옵션): 프락시들을 lazy 초기화 시키는데 사용할 클래"
"스 또는 인터페이스를 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>lazy (optional, defaults to true): "
"setting <literal>lazy=\"false\" disables the use of lazy fetching."
msgstr ""
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>lazy (옵션 - 디폴트는 true): "
"<literal>lazy=\"false\" 설정은 lazy 페칭의 사용을 불가능하게 만든"
"다.\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>lazy (옵션 - 디폴트는 true): "
"<literal>lazy=\"false\" 설정은 lazy 페칭을 사용불가능하게 만든다\n"
"#-#-#-#-#  - (PACKAGE VERSION)  #-#-#-#-#\n"
"<literal>lazy (옵션 - 디폴트는 true): "
"<literal>lazy=\"false\" 설정은 lazy 페칭을 사용불가능하게 만든다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A discriminator column is not required for this mapping strategy. Each "
"subclass must, however, declare a table column holding the object identifier "
"using the <literal><key> element. The mapping at the start "
"of the chapter would then be re-written as:"
msgstr ""
"판별자(discriminator) 컬럼은 이 매핑 방도에 필요하지 않다. 하지만 각각의 서브"
"클래스는 <literal><key> 요소를 사용하여 객체 식별자를 보관하"
"는 테이블 컬럼을 선언해야 한다. 이 장의 시작 부분에 있는 매핑은 다음과 같이 "
"다시 작성될 것이다:"

#. Tag: title
#, fuzzy, no-c-format
msgid "Union-subclass"
msgstr "union-subclass"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A third option is to map only the concrete classes of an inheritance "
"hierarchy to tables. This is called the table-per-concrete-class strategy. "
"Each table defines all persistent states of the class, including the "
"inherited state. In Hibernate, it is not necessary to explicitly map such "
"inheritance hierarchies. You can map each class with a separate <literal><"
"class></literal> declaration. However, if you wish use polymorphic "
"associations (e.g. an association to the superclass of your hierarchy), you "
"need to use the <literal><union-subclass> mapping. For "
"example:"
msgstr ""
"제3의 옵션은 상속 계층구조의 concrete 클래스들 만을 테이블들로 매핑하는 것이"
"다 (table-per-concrete-class 방도). 여기서 각각의 테이블은 상속된 상태를 포함"
"하여 클래스의 모든 영속 상태를 정의한다. Hibernate에서, 그것은 그런 상속 계층"
"구조들을 명시적으로 매핑하는데 필수적이지 않다. 당신은 별도의 <literal><"
"class></literal> 선언을 가진 각각의 클래스를 간단히 매핑시킬 수 있다. 하지"
"만 당신이 다형성 연관관계들(예를 들면 당신의 계층구조의 슈퍼클래스에 대한 연"
"관)을 사용하고자 원할 경우, 당신은 <literal><union-subclass> "
"매핑을 사용할 필요가 있다."

#. Tag: para
#, no-c-format
msgid ""
"No discriminator column or key column is required for this mapping strategy."
msgstr "이 매핑 방도에는 판별자 컬럼이나 키 컬럼이 필요하지 않다."

#. Tag: title
#, fuzzy, no-c-format
msgid "Join"
msgstr "join"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Using the <literal><join> element, it is possible to map "
"properties of one class to several tables that have a one-to-one "
"relationship. For example:"
msgstr ""
"<literal><join>요소를 사용하면, 테이블들 사이에 1대일 관계가 "
"존재할 때, 하나의 클래스에 속한 프로퍼티들을 여러 테이블들로 매핑시키는 것이 "
"가능하다."

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>table: the name of the joined table."
msgstr "<literal>table: 조인된 테이블의 이름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>fetch (optional - defaults to join): "
"if set to <literal>join, the default, Hibernate will use an inner "
"join to retrieve a <literal><join> defined by a class or its "
"superclasses. It will use an outer join for a <literal><join>select then "
"Hibernate will use a sequential select for a <literal><join> "
"defined on a subclass. This will be issued only if a row represents an "
"instance of the subclass. Inner joins will still be used to retrieve a "
"<literal><join> defined by the class and its superclasses."
msgstr ""
"<literal>fetch (옵션 - 디폴트는 join): "
"<literal>join으로 설정될 경우, 디폴트로 Hibernate는 하나의 클래스 "
"또는 그것의 슈퍼 클래스들에 의해 정의된 <literal><join>을 검"
"색하는데 inner join을 사용하고 서브클래스에 의해 정의된 <literal><join>"
"</literal>을 검색하는데 outer join을 사용할 것이다. 만일 select<"
"join></literal>에 대해 sequential select를 사용할 것이고, 그것은 한 행이 "
"서브클래스의 인스턴스를 표현하는 것으로 판명되는 경우에만 명령이 내려질 것이"
"다. inner join들은 여전히 클래스와 그것의 슈퍼클래스들에 의해 정의된 "
"<literal><join>을 검색하는데 사용될 것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>inverse (optional - defaults to false (옵션 - 디폴트는 false): 이용 "
"가능할 경우, Hibernate는 이 조인에 의해 정의된 프로퍼티들을 삽입시키거나 업데"
"이트하려고 시도하지 않을 것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>optional (optional - defaults to false (옵션 - 디폴트는 false): 이용 "
"가능할 경우, Hibernate는 이 조인에 의해 정의된 프로퍼티들이 null이 아닐 경우"
"에만 한 행을 삽입시킬 것이고 그 프로퍼티들을 검색하는데 outer join을 항상 사"
"용할 것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"For example, address information for a person can be mapped to a separate "
"table while preserving value type semantics for all properties:"
msgstr ""
"예를 들어, (모든 프로퍼티들에 대해 value 타입 의미를 유지하면서) 개인의 주소 "
"정보는 별도의 테이블에 매핑될 수 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"This feature is often only useful for legacy data models. We recommend fewer "
"tables than classes and a fine-grained domain model. However, it is useful "
"for switching between inheritance mapping strategies in a single hierarchy, "
"as explained later."
msgstr ""
"이 특징은 자주 리거시 데이터 모형들에 대해서만 유용하고, 우리는 클래스들과 "
"잘 정제된 도메인 모형 보다 더 적은 테이블들을 권장한다. 하지만 뒷 부분에 설명"
"되어 있듯이, 그것은 하나의 계층구조 내에 있는 상속 매핑 방도들 사이를 전환하"
"는 것에 유용하다."

#. Tag: title
#, fuzzy, no-c-format
msgid "Key"
msgstr "key"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal><key> element has featured a few times within "
"this guide. It appears anywhere the parent mapping element defines a join to "
"a new table that references the primary key of the original table. It also "
"defines the foreign key in the joined table:"
msgstr ""
"우리는 지금까지 몇 번 나타났던 <literal><key> 요소를 보았다. "
"그것은 부모 매핑 요소가 새로운 테이블에 대한 조인을 정의하는 어느 곳에서나 나"
"타나고, 그것은 조인된 테이블의 foreign 키를 정의하고, 그것은 원래의 테이블의 "
"프라이머리 키를 참조한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>on-delete (optional - defaults to noaction (옵션 - 디폴트는 noaction): "
"foreign key 컨스트레인트가 데이터베이스 레벨의 cascade delete를 사용가능하도"
"록 할 것인지 여부를 지정한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>property-ref (optional): specifies that the foreign key "
"refers to columns that are not the primary key of the original table. It is "
"provided for legacy data."
msgstr ""
"<literal>property-ref (옵션): foreign key가 원래의 테이블의 프라이"
"머리 키가 아닌 컬럼들을 참조함을 지정한다. (리거시 데이터에 제공됨.)"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>not-null (optional): specifies that the foreign key "
"columns are not nullable. This is implied whenever the foreign key is also "
"part of the primary key."
msgstr ""
"<literal>not-null (옵션): foreign 키 컬럼들이 not null 임를 지정한"
"다(이것은 foreign 키가 또한 프라이머리 키의 부분일 때마다 함축된다)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>update (optional): specifies that the foreign key should "
"never be updated. This is implied whenever the foreign key is also part of "
"the primary key."
msgstr ""
"<literal>update (옵션): foreign 키가 결코 업데이트되지 않아야 함을 "
"지정한다(이것은 foreign 키가 또한 프라이머리 키의 부분일 때마다 함축된다)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>unique (optional): specifies that the foreign key should "
"have a unique constraint. This is implied whenever the foreign key is also "
"the primary key."
msgstr ""
"<literal>unique (옵션): foreign 키가 유일 컨스트레인트를 가져야 함"
"을 지정한다 (이것은 foreign 키가 또한 프라이머리 키의 부분일 때마다 함축된"
"다)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"For systems where delete performance is important, we recommend that all "
"keys should be defined <literal>on-delete=\"cascade\". Hibernate "
"uses a database-level <literal>ON CASCADE DELETE constraint, "
"instead of many individual <literal>DELETE statements. Be aware "
"that this feature bypasses Hibernate's usual optimistic locking strategy for "
"versioned data."
msgstr ""
"우리는 delete 퍼포먼스가 중요한 시스템들에 대해 권장하고, 모든 키들은 "
"<literal>on-delete=\"cascade\"로 정의되고, Hibernate는 많은 "
"<literal>DELETE 문장들 대신에, 데이터베이스 레벨의 ON "
"CASCADE DELETE</literal> 컨스트레인트를 사용할 것이다. 이 특징은 Hibernate의 "
"통상적인 버전화된 데이터에 대한 optimistic 잠금 방도를 무시한다는 점을 알고 "
"있어라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>not-null and update attributes are "
"useful when mapping a unidirectional one-to-many association. If you map a "
"unidirectional one-to-many association to a non-nullable foreign key, you "
"<emphasis>must declare the key column using <key not-"
"null=\"true\"></literal>."
msgstr ""
"<literal>not-null 속성과 update 속성들은 단방향 "
"one to many 연관관계를 매핑할 때 유용하다. 만일 당신이 단방향 one to many를 "
"null이 허용되지 않는 foreign 키로 매핑할 경우, 당신은 <literal><key not-"
"null=\"true\"></literal>를 사용하여 그 키 컬럼을 선언해야 한다 attribute will "
"alternatively accept a <literal><column> subelement. "
"Likewise, <literal><formula> is an alternative to the "
"<literal>formula attribute. For example:"
msgstr ""
"column 속성을 허용하는 임의의 매핑 요소는 대안적으로 하나의 <literal><"
"column></literal> 서브요소를 수용할 것이다. 비슷하게 <"
"formula></literal>는 formula 속성에 대한 대안이다."

#. Tag: para
#, no-c-format
msgid ""
"Most of the attributes on <literal>column provide a means of "
"tailoring the DDL during automatic schema generation. The <literal>readwrite attributes allow you to specify custom "
"SQL that Hibernate will use to access the column's value. For more on this, "
"see the discussion of <link linkend=\"mapping-column-read-and-write\">column "
"read and write expressions</link>."
msgstr ""

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>column and formula elements can "
"even be combined within the same property or association mapping to express, "
"for example, exotic join conditions."
msgstr ""
"<literal>column 속성과 formula 속성은 예를 들어 "
"신종 조인 조건들을 표현하기 위해 동일한 property 또는 연관관계 매핑 내에 결합"
"될 수 있다."

#. Tag: title
#, fuzzy, no-c-format
msgid "Import"
msgstr "import"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"If your application has two persistent classes with the same name, and you "
"do not want to specify the fully qualified package name in Hibernate "
"queries, classes can be \"imported\" explicitly, rather than relying upon "
"<literal>auto-import=\"true\". You can also import classes and "
"interfaces that are not explicitly mapped:"
msgstr ""
"당신의 어플리케이션이 동일한 이름을 가진 두 개의 영속 클래스들을 갖고, 당신"
"이 Hibernate 질의들 내에서 전체 수식어가 붙은 (패키지)이름을 지정하는 것을 원"
"하지 않는다고 가정하자. 클래스들은 <literal>auto-import=\"true\"에 "
"의존하기 보다 명시적으로 \"임포트 될 \" 것이다. 당신은 심지어 명시적으로 매핑"
"되지 않는 클래스들과 인터페이스들을 임포트 시킬 수(가져오기 할 수) 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>class: the fully qualified class name of any Java class."
msgstr ""
"<literal>class: 임의의 Java 클래스의 전체 수식어가 붙은 클래스 이"
"름."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>rename (optional - defaults to the unqualified class "
"name): a name that can be used in the query language."
msgstr ""
"<literal>rename (옵션 - 디폴트는 수식어가 붙지 않은 클래스 이름): "
"질의 언어 내에서 사용될 이름."

#. Tag: title
#, fuzzy, no-c-format
msgid "Any"
msgstr "any"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"There is one more type of property mapping. The <literal><any> 매"
"핑 요소는 여러 테이블들로부터 클래스들에 대한 하나의 다형성 연관관계를 정의한"
"다. 이 매핑 타입은 언제나 하나 이상의 컬럼을 필요로 한다. 첫 번째 컬럼은 연관"
"된 엔티티의 타입을 보관한다. 나머지 컬럼들은 식별자를 보관한다. 이런 종류의 "
"연관관계들에 대해 foreign key 컨스트레인트를 지정하는 것이 불가능해서, 이것"
"은 (다형성) 연관관계들을 매핑하는 통상적인 방법으로서 가장 확실한 수단이 아니"
"다. 당신은 매우 특별한 경우들 (예를 들어 감사 로그들, 사용자 세션 데이터 등)"
"에서만 이것을 사용해야 한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>meta-type attribute allows the application to specify "
"a custom type that maps database column values to persistent classes that "
"have identifier properties of the type specified by <literal>id-type 속성은 어플리케이션으로 하여금 데이터베이스 컬"
"럼 값들을 <literal>id-type에 의해 지정된 타입의 식별자 프로퍼티들"
"을 가진 영속 클래스들로 매핑시키는 맞춤형 타입을 지정하도록 한다. 당신은 "
"meta-type의 값들로부터 클래스 이름들로의 매핑을 지정해야 한다."

#. Tag: para
#, no-c-format
msgid "<literal>name: the property name."
msgstr "<literal>name: 프로퍼티 이름."

#. Tag: para
#, no-c-format
msgid "<literal>id-type: the identifier type."
msgstr "<literal>id-type: 식별자 타입."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>meta-type (optional - defaults to string (옵션 - 디폴트는 string): "
"discriminator 매핑에 허용되는 임의의 타입."

#. Tag: para
#, no-c-format
msgid ""
"<literal>cascade (optional- defaults to none): "
"the cascade style."
msgstr ""
"<literal>cascade (optional- defaults to none): "
"cascade 스타일."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>optimistic-lock (optional - defaults to true (옵션 - 디폴트는 true exists independently of any other objects "
"holding references to the entity. Contrast this with the usual Java model, "
"where an unreferenced object is garbage collected. Entities must be "
"explicitly saved and deleted. Saves and deletions, however, can be "
"<emphasis>cascaded from a parent entity to its children. This is "
"different from the ODMG model of object persistence by reachability and "
"corresponds more closely to how application objects are usually used in "
"large systems. Entities support circular and shared references. They can "
"also be versioned."
msgstr ""
"<emphasis>entity는 엔티티에 대한 참조들을 보관하는 임의의 다른 객"
"체들과는 독립적으로 존재한다. 참조되지 않은 객체가 쓰레기 수집되는 통상의 자"
"바 모형과 이것은 대조적이다. (저장들과 삭제들이 부모 엔티티로부터 그것의 자식"
"으로의 케스케이드 되는 경우를 제외하면) 엔티티들은 명시적으로 저장되고 삭제되"
"어야 한다. 이것은 도달 가능성(reachablity)에 의한 객체 영속성의 ODMG 모형과"
"는 다르다 - 그리고 어플리케이션 객체들이 대형 시스템들에서 대개 어떻게 사용되"
"는가에 훨씬 더 가깝게 대응한다. 엔티티들은 순환 참조와 공유 참조들을 지원한"
"다. 그것들 또한 버전화 될 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"An entity's persistent state consists of references to other entities and "
"instances of <emphasis>value types. Values are primitives: "
"collections (not what is inside a collection), components and certain "
"immutable objects. Unlike entities, values in particular collections and "
"components, <emphasis>are persisted and deleted by reachability. "
"Since value objects and primitives are persisted and deleted along with "
"their containing entity, they cannot be independently versioned. Values have "
"no independent identity, so they cannot be shared by two entities or "
"collections."
msgstr ""
"엔티티의 영속 상태는 다른 엔티티들에 대한 참조들과 <emphasis>value 삭제 된다. value 객체들(과 원시 타입들)"
"이 그것들의 포함하는 엔티티에 따라 영속화 되고 삭제 되므로, 그것들은 독립적으"
"로 버전화 되지 않는다. 값들은 독립적인 엔티티를 갖지 않아서, 그것들은 두 개"
"의 엔티티들이나 콜렉션들에 의해 공유될 수 없다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Until now, we have been using the term \"persistent class\" to refer to "
"entities. We will continue to do that. Not all user-defined classes with a "
"persistent state, however, are entities. A <emphasis>component is "
"a user-defined class with value semantics. A Java property of type "
"<literal>java.lang.String also has value semantics. Given this "
"definition, all types (classes) provided by the JDK have value type "
"semantics in Java, while user-defined types can be mapped with entity or "
"value type semantics. This decision is up to the application developer. An "
"entity class in a domain model will normally have shared references to a "
"single instance of that class, while composition or aggregation usually "
"translates to a value type."
msgstr ""
"지금까지 우리는 엔티티들을 참조하기 위해 \"영속 클래스\"를 사용해 왔다. 우리"
"는 그것을 계속 사용할 것이다. 하지만 엄격히 말해, 영속 상태를 가진 모든 사용"
"자 정의 클래스들은 엔티티들이 아니다. <emphasis>컴포넌트는 value "
"의미를 가진 사용자 정의 클래스이다. <literal>java.lang.String 타입"
"의 자바 프로퍼티는 또한 value 의미를 갖는다. 이 정의가 주어지면, 우리는 JDK"
"에 의해 제공된 모든 타입들(클래스들)이 자바에서 value 타입 의미를 갖고, 반면"
"에 사용자 정의 타입들은 엔티티 또는 type 의미로서 매핑된다고 말할 수 있다. "
"이 판단은 어플리케이션 개발자에게 달려 있다. 도메인 모형에서 엔티티 클래스에 "
"대한 좋은 힌트는 그 클래스의 하나의 인스턴스에 대한 공유된 참조들인 반면에, "
"composition이나 aggregation은 대개 value 타입으로 변환된다."

#. Tag: para
#, fuzzy, no-c-format
msgid "We will revisit both concepts throughout this reference guide."
msgstr "우리는 문서를 통해 두 개념들을 다시 고찰할 것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The challenge is to map the Java type system, and the developers' definition "
"of entities and value types, to the SQL/database type system. The bridge "
"between both systems is provided by Hibernate. For entities, <literal><"
"class></literal>, <subclass> and so on are used. "
"For value types we use <literal><property>, <"
"component></literal>etc., that usually have a type "
"attribute. The value of this attribute is the name of a Hibernate "
"<emphasis>mapping type. Hibernate provides a range of mappings "
"for standard JDK value types out of the box. You can write your own mapping "
"types and implement your own custom conversion strategies."
msgstr ""
"도점점은 Java type 시스템(과 엔티티들 및 value 타입들에 대한 개발자의 정의)"
"를 SQL/데이터베이스 type 타입으로 매핑하는 것이다. 두 시스템들 사이의 다리는 "
"Hibernate에 의해 제공된다: 엔티티들의 경우 우리는 <literal><class><subclass> 등을 사용한다.value 타입들의 경"
"우 우리는 대개<literal>type 속성을 가진 <property><component> 등을 사용한다. 이 속성의 값은 "
"Hibernate <emphasis>매핑 타입의 이름이다. Hibernate는 (표준 JDK "
"value 타입들에 대해) 많은 매핑들을 제공한다. 나중에 보게 되듯이, 당신은 당신 "
"자신의 매핑 타입들을 작성할 수 있고 마찬가지로 당신의 맞춤형 변환 방도들을 구"
"현할 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"With the exception of collections, all built-in Hibernate types support null "
"semantics."
msgstr ""
"콜렉션들을 제외한 모든 미리 빌드된 Hibernate 타입들은 null 의미를 지원한다."

#. Tag: title
#, no-c-format
msgid "Basic value types"
msgstr "기본 value 타입들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The built-in <emphasis>basic mapping types can be roughly "
"categorized into the following:"
msgstr ""
"미리-만들어진 <emphasis>기본 매핑 타입들은 대략 다음과 같이 카테고"
"리로 분류된다 <placeholder-1/>"

#. Tag: term
#, fuzzy, no-c-format
msgid ""
"<literal>integer, long, short, float, double, character, byte, boolean, "
"yes_no, true_false</literal>"
msgstr ""
"integer, long, short, float, double, character, byte, boolean, yes_no, "
"true_false"

#. Tag: para
#, no-c-format
msgid ""
"Type mappings from Java primitives or wrapper classes to appropriate (vendor-"
"specific) SQL column types. <literal>boolean, yes_no and "
"<literal>true_false are all alternative encodings for a Java "
"<literal>boolean or java.lang.Boolean."
msgstr ""
"자바 원시타입들이나 wrapper 클래스들로부터 적절한(벤더-지정적인) SQL 컬럼 타"
"입들로의 타입 매핑. <literal>boolean, yes_no와 "
"<literal>true_false는 Java boolean이나 "
"<literal>java.lang.Boolean에 대한 모든 대체적인 인코딩들이다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>string"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, no-c-format
msgid ""
"A type mapping from <literal>java.lang.String to VARCHARVARCHAR2)."
msgstr ""
"<literal>java.lang.String으로부터 VARCHAR (또는 "
"Oracle <literal>VARCHAR2)로의 타입 매핑."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>date, time, timestamp"
msgstr "date, time, timestamp"

#. Tag: para
#, no-c-format
msgid ""
"Type mappings from <literal>java.util.Date and its subclasses to "
"SQL types <literal>DATE, TIME and "
"<literal>TIMESTAMP (or equivalent)."
msgstr ""
"<literal>java.util.Date와 그것의 서브클래스로부터 SQL 타입들인 "
"<literal>DATE, TIME, TIMESTAMP"
msgstr "calendar, calendar_date"

#. Tag: para
#, no-c-format
msgid ""
"Type mappings from <literal>java.util.Calendar to SQL types "
"<literal>TIMESTAMP and DATE (or equivalent)."
msgstr ""
"<literal>java.util.Calendar로부터 SQL 타입들인 TIMESTAMPDATE (또는 등가물)로의 타입 매핑들."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>big_decimal, big_integer"
msgstr "big_decimal, big_integer"

#. Tag: para
#, no-c-format
msgid ""
"Type mappings from <literal>java.math.BigDecimal and java."
"math.BigInteger</literal> to NUMERIC (or Oracle "
"<literal>NUMBER)."
msgstr ""
"<literal>java.math.BigDecimal과 java.math.BigIntegerNUMERIC (또는 Oracle NUMBER"
msgstr "locale, timezone, currency"

#. Tag: para
#, no-c-format
msgid ""
"Type mappings from <literal>java.util.Locale, java.util."
"TimeZone</literal> and java.util.Currency to "
"<literal>VARCHAR (or Oracle VARCHAR2). "
"Instances of <literal>Locale and Currency are "
"mapped to their ISO codes. Instances of <literal>TimeZone are "
"mapped to their <literal>ID."
msgstr ""
"<literal>java.util.Locale, java.util.TimeZone, "
"그리고 <literal>java.util.Currency로부터 VARCHAR"
"(또는 Oracle <literal>VARCHAR2)로의 타입 매핑. LocaleCurrency의 인스턴스들은 그것들의 ISO 코드들로 "
"매핑된다. <literal>TimeZone의 인스턴스들은 그것들의 ID"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, no-c-format
msgid ""
"A type mapping from <literal>java.lang.Class to VARCHARVARCHAR2). A Class "
"is mapped to its fully qualified name."
msgstr ""
"<literal>java.lang.Class로부터 VARCHAR (또는 "
"Oracle <literal>VARCHAR2)로의 타입 매핑. Class"
"는 그것의 전체 수식어가 붙은 이름으로 매핑된다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>binary"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, no-c-format
msgid "Maps byte arrays to an appropriate SQL binary type."
msgstr "byte 배열들을 적절한 SQL binary 타입으로 매핑시킨다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>text"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, no-c-format
msgid ""
"Maps long Java strings to a SQL <literal>CLOB or TEXT 또는 TEXT "
"타입으로 매핑시킨다"

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>serializable"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Maps serializable Java types to an appropriate SQL binary type. You can also "
"indicate the Hibernate type <literal>serializable with the name of "
"a serializable Java class or interface that does not default to a basic type."
msgstr ""
"serializable Java 타입들을 적절한 SQL binary 타입으로 매핑시킨다. 당신은 또"
"한 디폴트로 기본 타입이 아닌 serializable 자바 클래스 또는 인터페이스의 이름"
"을 가진 Hibernate 타입 <literal>serializable을 나타낼 수도 있다."

#. Tag: term
#, fuzzy, no-c-format
msgid "<literal>clob, blob"
msgstr "<literal>all은 모든 컬럼들을 체크한다"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Type mappings for the JDBC classes <literal>java.sql.Clob and "
"<literal>java.sql.Blob. These types can be inconvenient for some "
"applications, since the blob or clob object cannot be reused outside of a "
"transaction. Driver support is patchy and inconsistent."
msgstr ""
"<literal>java.sql.Clob와 java.sql.Blob JDBC 클래"
"스들에 대한 타입 매핑들. 이들 타입들은 몇몇 어플리케이션들에서는 불편하다. 왜"
"냐하면 blob 또는 clob 객체는 트랜잭션 외부에서 재사용될 수 없기 때문이다.(게"
"다가 드라이버 지원이 비일관적이고 페치되어야 한다)"

#. Tag: term
#, fuzzy, no-c-format
msgid ""
"<literal>imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, "
"imm_serializable, imm_binary</literal>"
msgstr ""
"imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, "
"imm_serializable, imm_binary"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Type mappings for what are considered mutable Java types. This is where "
"Hibernate makes certain optimizations appropriate only for immutable Java "
"types, and the application treats the object as immutable. For example, you "
"should not call <literal>Date.setTime() for an instance mapped as "
"<literal>imm_timestamp. To change the value of the property, and "
"have that change made persistent, the application must assign a new, "
"nonidentical, object to the property."
msgstr ""
"대개 가변적인 Java 타입들로 간주되는 것에 대한 타입 매핑들. 여기서 Hibernate"
"는 불변적인 Java 타입들에 대해서만 적절한 어떤 최적화를 행하고, 어플리케이션 "
"그 객체를 변할 수 없는 것으로 취급한다. 예를 들어, 당신은 "
"<literal>imm_timestamp로서 매핑된 인스턴스에 대해 Date."
"setTime()</literal>을 호출하지 않을 것이다. 프로퍼티의 값을 변경시키고, 그 변"
"경을 영속화 시키기 위해서, 어플리케이션은 하나의 새로운 (동일하지 않은) 객체"
"를 그 프로퍼티에 할당해야 한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Unique identifiers of entities and collections can be of any basic type "
"except <literal>binary, blob and clob, "
"<literal>blob 그리고 clob를 제외한 기본 타입 중 "
"어느 것일 수 있다. (Composite 식별자들이 또한 허용된다. 아래를 보라.)"

#. Tag: para
#, no-c-format
msgid ""
"The basic value types have corresponding <literal>Type constants "
"defined on <literal>org.hibernate.Hibernate. For example, "
"<literal>Hibernate.STRING represents the string "
"type."
msgstr ""
"기본 value 타입들은 <literal>org.hibernate.Hibernate에 정의되어 있"
"는 대응하는 <literal>Type 상수들을 갖는다. 예를 들어, "
"<literal>Hibernate.STRING은 string 타입을 표현한"
"다."

#. Tag: title
#, no-c-format
msgid "Custom value types"
msgstr "맞춤형 value 타입들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"It is relatively easy for developers to create their own value types. For "
"example, you might want to persist properties of type <literal>java.lang."
"BigInteger</literal> to VARCHAR columns. Hibernate does "
"not provide a built-in type for this. Custom types are not limited to "
"mapping a property, or collection element, to a single table column. So, for "
"example, you might have a Java property <literal>getName()/"
"<literal>setName() of type java.lang.String "
"that is persisted to the columns <literal>FIRST_NAME, "
"<literal>INITIAL, SURNAME."
msgstr ""
"개발자들이 그들 자신들의 value 타입들을 생성시키는 것이 상대적으로 쉽다. 예"
"를 들어, 당신은 <literal>java.lang.BigInteger 타입의 프로퍼티들을 "
"<literal>VARCHAR 컬럼들로 영속화 시키고자 원할 수 있다. Hibernate"
"는 이것을 위한 미리 만들어진 타입을 제공하지 않는다. 그러나 맞춤형 타입들은 "
"프로퍼티(또는 콜렉션 요소)를 하나의 테이블 컬럼으로의 매핑하는 것에 제약되지 "
"않는다. 따라서 예를 들어, 당신은 <literal>FIRST_NAME, "
"<literal>INITIAL, SURNAME 컬럼들로 영속화 되는 "
"<literal>java.lang.String 타입의 자바 프로퍼티getName()setName()를 가질 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"To implement a custom type, implement either <literal>org.hibernate."
"UserType</literal> or org.hibernate.CompositeUserType and "
"declare properties using the fully qualified classname of the type. View "
"<literal>org.hibernate.test.DoubleStringType to see the kind of "
"things that are possible."
msgstr ""
"맞춤형 타입을 구현하려면, <literal>org.hibernate.UserType 또는 "
"<literal>org.hibernate.CompositeUserType을 구현하고 그 타입의 전체 "
"수식어가 붙은 클래스명을 사용하여 프로퍼티들을 선언하라. 가능한 종류의 것들"
"을 보려면 <literal>org.hibernate.test.DoubleStringType을 체크하라."

#. Tag: para
#, no-c-format
msgid ""
"Notice the use of <literal><column> tags to map a property "
"to multiple columns."
msgstr ""
"하나의 프로퍼티를 여러 개의 컬럼들로 매핑시키는 <literal><column>, EnhancedUserTypeUserCollectionType, and "
"<literal>UserVersionType interfaces provide support for more "
"specialized uses."
msgstr ""
"<literal>CompositeUserType, EnhancedUserType, "
"<literal>UserCollectionType, 그리고 UserVersionType in the "
"mapping file. To do this, your <literal>UserType must implement "
"the <literal>org.hibernate.usertype.ParameterizedType interface. "
"To supply parameters to your custom type, you can use the <literal><"
"type></literal> element in your mapping files."
msgstr ""
"당신은 매핑 파일 속에 <literal>UserType에 대한 파라미터들을 제공할 "
"수도 있다. 이것을 행하기 위해, 당신의 <literal>UserType은 "
"<literal>org.hibernate.usertype.ParameterizedType 인터페이스를 구현"
"해야 한다. 당신의 맞춤형 타입에 파라미터들을 제공하기 위해, 당신은 당신의 매"
"핑 파일들 속에 <literal><type> 요소를 사용할 수 있다."

#. Tag: para
#, no-c-format
msgid ""
"The <literal>UserType can now retrieve the value for the parameter "
"named <literal>default from the Properties "
"object passed to it."
msgstr ""
"<literal>UserType은 이제 그것에 전달된 Propertiesdefault로 명명된 파라미터에 대한 값을 "
"검색할 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"If you regularly use a certain <literal>UserType, it is useful to "
"define a shorter name for it. You can do this using the <literal><"
"typedef></literal> element. Typedefs assign a name to a custom type, and "
"can also contain a list of default parameter values if the type is "
"parameterized."
msgstr ""
"만일 당신이 매우 자주 어떤 UserType을 사용할 경우, 그것은 그것에 대한 더 짧"
"은 이름을 정의하는 것이 유용할 수 있다. <literal><typedef> 요"
"소를 사용하여 이것을 행할 수 있다. Typedef들은 이름을 맞춤형 타입에 할당하"
"고, 또한 만일 그 타입이 파라미터화 된 경우에 디폴트 파라미터 값들의 리스트를 "
"포함할 수도 있다."

#. Tag: para
#, no-c-format
msgid ""
"It is also possible to override the parameters supplied in a typedef on a "
"case-by-case basis by using type parameters on the property mapping."
msgstr ""
"property 매핑 상에 type 파라미터들을 사용함으로써 경우에 맞게 typedef 내에 제"
"공된 파라미터들을 오버라이드 시키는 것이 가능하다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Even though Hibernate's rich range of built-in types and support for "
"components means you will rarely need to use a custom type, it is considered "
"good practice to use custom types for non-entity classes that occur "
"frequently in your application. For example, a <literal>MonetaryAmountCompositeUserType 거의 없을 것"
"임을 의미할 지라도, 그럼에도 불구하고 그것은 당신의 어플리케이션에서 자주 발"
"생하는 (엔티티가 아닌) 클래스들에 대해 맞춤형 타입들을 사용하는 좋은 형식으"
"로 간주된다. 예를 들어 <literal>MonetaryAmount 클래스는 비록 그것"
"이 컴포넌트로서 쉽게 매핑될 수 있을지라도, <literal>CompositeUserType to "
"disambiguate between instances of the two mapped entities. By default, the "
"entity name is the same as the class name. Hibernate lets you specify the "
"entity name when working with persistent objects, when writing queries, or "
"when mapping associations to the named entity."
msgstr ""
"하나의 특정한 영속 클래스에 대해 하나 이상의 매핑을 제공하는 것이 가능하다. "
"이 경우에 당신은 두 개의 매핑된 엔티티들의 인스턴스들 사이를 명확하게 하기 위"
"해 <emphasis>하나의 엔티티 이름을 지정해야 한다. (디폴트로, 엔티"
"티 이름은 클래스 이름과 동일한 것이다.) Hibernate는 영속 객체들에 대해 작업"
"할 때, 질의들을 작성할 때, 또는 명명된 엔티티에 대한 연관들을 매핑할 때 당신"
"으로 하여금 엔티티 이름을 지정하도록 한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Associations are now specified using <literal>entity-name instead "
"of <literal>class."
msgstr ""
"연관들은 이제 <literal>class 대신에 entity-name"
"을 사용하여 어떻게 지정되는지를 주목하라."

#. Tag: title
#, no-c-format
msgid "SQL quoted identifiers"
msgstr "SQL 인용부호 표시된 식별자들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You can force Hibernate to quote an identifier in the generated SQL by "
"enclosing the table or column name in backticks in the mapping document. "
"Hibernate will use the correct quotation style for the SQL <literal>Dialect에 대해 정확한 인용 스타일을 사용"
"할 것이다(대개 이중 인용부호 이지만, SQL Server의 경우에는 모난 괄호들이고 "
"MySQL의 경우에는 역인용부호(`))."

#. Tag: title
#, no-c-format
msgid "Metadata alternatives"
msgstr "Metadata 대안들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"XML does not suit all users so there are some alternative ways to define O/R "
"mapping metadata in Hibernate."
msgstr ""
"XML은 모든 사람들을 위한 것이 아니지만, Hibernate에서 O/R 매핑 메타데이터를 "
"정의하는 몇몇 대안적인 방법들이 존재한다."

#. Tag: title
#, no-c-format
msgid "Using XDoclet markup"
msgstr "XDoclet 마크업 사용하기"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Many Hibernate users prefer to embed mapping information directly in "
"sourcecode using XDoclet <literal>@hibernate.tags. We do not cover "
"this approach in this reference guide since it is considered part of "
"XDoclet. However, we include the following example of the <literal>Cat를 사용하"
"여 소스 코드 속에 직접 매핑 정보를 삽입시키는 것을 선호한다. 우리는 이 문서에"
"서 이 접근법을 다루지 않을 것이다. 왜냐하면 그것은 엄격하게는 XDoclet의 부분"
"으로 간주되기 때문이다. 하지만 우리는 XDoclet 매핑들을 가진 <literal>Cat of JSR-220 (the "
"persistence API). Support for mapping metadata is available via the "
"<emphasis>Hibernate Annotations package as a separate download. "
"Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
msgstr ""
"JDK 5.0은 언어 레벨에서 XDoclet-스타일의 주석들, type-safe와 컴파일 시 체킹"
"을 도입했다. 이 메커니즘은 XDoclet 주석들 보다 더 강력하며 도구들과 IDE들에 "
"의해 더 좋게 지원된다. 예를 들어 IntelliJ IDEA는 JDK 5.0 주석들에 대한 자동-"
"완성 기능과 구문 강조를 지원한다. EJB 명세서의 새로운 개정판(JSR-220)은 엔티"
"티 빈즈에 대한 프라이머리 메타데이터 메커니즘으로서 JDK 5.0 Annotations을 사"
"용한다. Hibernate3는 JSR-220(영속 API)의 <literal>EntityManager를 "
"구현하고, 매핑 메타데이터에 대한 지원은 별도의 내려받기로서 "
"<emphasis>Hibernate Annotations 패키지를 통해 이용 가능하다. EJB3 "
"(JSR-220)과 Hibernate3 metadata 양자가 지원된다."

#. Tag: para
#, no-c-format
msgid "This is an example of a POJO class annotated as an EJB entity bean:"
msgstr "다음은 EJB 엔티티 빈으로서 주석이 붙은 POJO 클래스에 관한 예제이다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Support for JDK 5.0 Annotations (and JSR-220) is currently under "
"development. Please refer to the Hibernate Annotations module for more "
"details."
msgstr ""
"JDK 5.0 Annotations(그리고 JSR-220)에 대한 지원은 여전히 작업이 진행 중이고 "
"완성되지 않았음을 노트하라. 상세한 것은 Hibernate Anotations를 참조하라."

#. Tag: title
#, fuzzy, no-c-format
msgid "Generated properties"
msgstr "산출되는 프로퍼티들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Generated properties are properties that have their values generated by the "
"database. Typically, Hibernate applications needed to <literal>refresh시킬 필요"
"가 있었다.하지만 generated로 마크된 프로퍼티들은 어플리케이션으로 하여금 이 "
"책임을 Hibernate에게 위임시키도록 한다. 본질적으로 Hibernate가 산출되는 프로"
"퍼티들을 정의했던 엔티티에 대해 SQL INSERT 또는 UPDATE 명령을 내릴 때마다 바"
"로 직후에 산출되는 값들을 검색하기 위해 하나의 select 명령을 내린다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Properties marked as generated must additionally be non-insertable and non-"
"updateable. Only <link linkend=\"mapping-declaration-version\">versionstimestamps, "
"and <link linkend=\"mapping-declaration-property\">simple properties, "
"can be marked as generated."
msgstr ""
"generated로 마크된 프로퍼티들은 부가적으로 inser 가능하지 않아야 하고 update "
"불가능해야 한다. 오직 Properties marked as generated must additionally be "
"non-insertable and non-updateable. <xref linkend=\"mapping-declaration-"
"version\">versions</xref>, , 그리고 "
"단순 프로퍼티들</xref> 만이 generated로 마크될 수 있다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>never (the default): the given property value is not "
"generated within the database."
msgstr ""
"<literal>never (디폴트) - 는 주어진 프로퍼티 값이 데이터베이스 내"
"에 생성되지 않을 것임을 의미한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>insert: the given property value is generated on insert, "
"but is not regenerated on subsequent updates. Properties like created-date "
"fall into this category. Even though <link linkend=\"mapping-declaration-"
"version\">version</link> and  properties can be marked as generated, this option is "
"not available."
msgstr ""
"<literal>insert - 는 주어진 프로퍼티 값이 insert 시에 생성되지만, "
"차후의 업데이트들에서 다시 생성되지 않을 것임을 기술한다. 생성-날짜와 같은 것"
"들이 이 카테고리 내로 포함될 것이다. 비록 <xref linkend=\"mapping-"
"declaration-version\">version</xref>과  프로퍼티들이 생성되는 것으로서 마크될 수 있을 지"
"라도, 이 옵션은 거기서 이용 불가능함을 노트하라..."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>always: the property value is generated both on insert "
"and on update."
msgstr ""
"<literal>always - 는 프로퍼티 값이 insert 시와 update 시 모두에 생"
"성됨을 기술한다."

#. Tag: title
#, no-c-format
msgid "Column read and write expressions"
msgstr ""

#. Tag: para
#, no-c-format
msgid ""
"Hibernate allows you to customize the SQL it uses to read and write the "
"values of columns mapped to <link linkend=\"mapping-declaration-property"
"\">simple properties</link>. For example, if your database provides a set of "
"data encryption functions, you can invoke them for individual columns like "
"this: <programlisting role=\"XML\"><property name=\"creditCardNumber"
"\"> <column name=\"credit_card_num\" read=\"decrypt(credit_card_num)\" "
"write=\"encrypt(?)\"/> </property></programlisting>"
msgstr ""

#. Tag: para
#, no-c-format
msgid ""
"Hibernate applies the custom expressions automatically whenever the property "
"is referenced in a query. This functionality is similar to a derived-"
"property <literal>formula with two differences:"
msgstr ""

#. Tag: para
#, no-c-format
msgid ""
"The property is backed by one or more columns that are exported as part of "
"automatic schema generation."
msgstr ""

#. Tag: para
#, no-c-format
msgid "The property is read-write, not read-only."
msgstr ""

#. Tag: para
#, no-c-format
msgid ""
"The <literal>write expression, if specified, must contain exactly "
"one '?' placeholder for the value."
msgstr ""

#. Tag: title
#, fuzzy, no-c-format
msgid "Auxiliary database objects"
msgstr "보조 데이터베이스 객체들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Auxiliary database objects allow for the CREATE and DROP of arbitrary "
"database objects. In conjunction with Hibernate's schema evolution tools, "
"they have the ability to fully define a user schema within the Hibernate "
"mapping files. Although designed specifically for creating and dropping "
"things like triggers or stored procedures, any SQL command that can be run "
"via a <literal>java.sql.Statement.execute() method is valid (for "
"example, ALTERs, INSERTS, etc.). There are essentially two modes for "
"defining auxiliary database objects:"
msgstr ""
"Hibernate 매핑 파일들 내에 사용자 스키마를 완전하게 정의하기 위한 능력을 제공"
"하기 위해서, Hibernate의 스키마 방출 도구들과 함께 임의적인 데이터베이스 객체"
"들에 대한 CREATE와 DROP을 허용해준다. 비록 트리거들 또는 내장 프로시저들과 같"
"은 것들을 생성시키고 드롭시키기 이해 특별히 고안되었을지라도 하나의 "
"<literal>java.sql.Statement.execute() 메소드를 통해 실행될 수 있는 "
"SQL 명령이 여기서 유효하다(ALTERs, INSERTS, 기타). 보조 데0이터베이스 객체들"
"을 정의하는 두 가지 모드들이 본질적으로 존재한다..."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The first mode is to explicitly list the CREATE and DROP commands in the "
"mapping file:"
msgstr ""
"첫 번째 모드는 매핑 파일 바깥에서 CREATE 및 DROP 명령들을 명시적으로 나열하"
"는 것이다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The second mode is to supply a custom class that constructs the CREATE and "
"DROP commands. This custom class must implement the <literal>org.hibernate."
"mapping.AuxiliaryDatabaseObject</literal> interface."
msgstr ""
"두번째 모드는 CREATE 및 DROP 명령들을 생성시키는 방법을 알고 있는 하나의 맞"
"춤 클래스를 제공하는 것이다. 이 맞춤 클래스는 <literal>org.hibernate.mapping."
"AuxiliaryDatabaseObject</literal> 인터페이스를 구현해야 한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Additionally, these database objects can be optionally scoped so that they "
"only apply when certain dialects are used."
msgstr ""
"덧붙여 이들 데이터베이스 객체들은 어떤 dialect들이 사용될 때 그것들이 단지 적"
"용될 수 있도록 선택적으로 변동될 수 있다."

#~ msgid "increment"
#~ msgstr "increment"

#~ msgid "identity"
#~ msgstr "identity"

#~ msgid "sequence"
#~ msgstr "sequence"

#~ msgid "hilo"
#~ msgstr "hilo"

#~ msgid "seqhilo"
#~ msgstr "seqhilo"

#~ msgid "uuid"
#~ msgstr "uuid"

#~ msgid "guid"
#~ msgstr "guid"

#~ msgid "native"
#~ msgstr "native"

#~ msgid "assigned"
#~ msgstr "assigned"

#~ msgid "select"
#~ msgstr "select"

#~ msgid "foreign"
#~ msgstr "foreign"

#~ msgid "sequence-identity"
#~ msgstr "sequence-identity"

#, fuzzy
#~ msgid ""
#~ "<literal>optimizer (optional - defaults to none (optional- defaults to none (optional - defaults to  (optional- defaults to none (optional): A name that indicates the Hibernate "
#~ "type."
#~ msgstr "<literal>type (옵션): Hibernate 타입을 나타내는 이름."

#~ msgid ""
#~ "<literal>cascade (optional): Specifies which operations should "
#~ "be cascaded from the parent object to the associated object."
#~ msgstr ""
#~ "<literal>cascade (옵션): 어느 오퍼레이션들이 부모 객체로부터 연"
#~ "관된 객체로 케스케이드 될 것인지를 지정한다."

#~ msgid ""
#~ "<literal>optimistic-lock (optional - defaults to true (옵션 - 디폴트는 true (optional, defaults to ): See "
#~ "<xref linkend=\"mapping-declaration-id-enhanced-optimizers\"/>"
#~ msgstr ""
#~ "<literal>optimizer (optional, defaults to ): See "
#~ "<xref linkend=\"mapping-declaration-id-enhanced-optimizers\"/>"