basic_mapping.po

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

#, no-c-format
msgid ""
"<literal>optimistic-lock</literal> (optional, defaults to <literal>version</"
"literal>): Determines the optimistic locking strategy."
msgstr ""
"<literal>optimistic-lock</literal> (옵션 - 디폴트는 <literal>version</"
"literal>): optimistic 잠금 방도를 결정한다."

#. Tag: para
#: basic_mapping.xml:311
#, no-c-format
msgid ""
"<literal>lazy</literal> (optional): Lazy fetching may be completely disabled "
"by setting <literal>lazy=\"false\"</literal>."
msgstr ""
"<literal>lazy</literal> (옵션): <literal>lazy=\"false\"</literal>를 설정함으"
"로써 Lazy fetching이 전체적으로 사용불가능하게 될 수 있다."

#. Tag: para
#: basic_mapping.xml:317
#, no-c-format
msgid ""
"<literal>entity-name</literal> (optional, defaults to the class name): "
"Hibernate3 allows a class to be mapped multiple times (to different tables, "
"potentially), and 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</literal>(옵션, 디폴트는 클래스 이름): Hibernate3는 하나"
"의 클래스가 (잠정적으로 다른 테이블들로) 여러번 매핑되는 것을 허용해주고, "
"Java 레벨에서 Map 또는 XML에 의해 표현 되는 엔티티 매핑들을 허용한다. 이들 경"
"우들에서, 당신은 그 엔티티에 대한 명시적인 임의의 이름을 제공해야 한다. "
"<literal>entity-name</literal> (옵션): Hibernate3는 하나의 클래스가 (잠정적으"
"로 다른 테이블들로) 여러 번 매핑되는 것을 허용하며, 자바 레벨에서 Map들 또는 "
"XML에 의해 표현되는 엔티티 매핑들을 허용한다. 이들 경우들에서, 당신은 그 엔티"
"티들에 대한 명시적인 임의의 이름을 제공해야 한다. 추가 정보는 <xref linkend="
"\"persistent-classes-dynamicmodels\"/>과 <xref linkend=\"xml\"/>을 보라."

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

#. Tag: para
#: basic_mapping.xml:333
#, no-c-format
msgid ""
"<literal>rowid</literal> (optional): Hibernate can use so called ROWIDs on "
"databases which support. E.g. on Oracle, Hibernate can use the "
"<literal>rowid</literal> extra column for fast updates if you set this "
"option to <literal>rowid</literal>. A ROWID is an implementation detail and "
"represents the physical location of a stored tuple."
msgstr ""
"<literal>rowid</literal> (옵션): Hibernate는 지원되는 데이터베이스들, 예를 들"
"어 Oracle 상에서 이른바 ROWID들을 사용할 수 있고, Hibernate는 당신이 이 옵션"
"을 <literal>rowid</literal>로 설정하는 경우에 빠른 업데이트를 위한 특별한 "
"<literal>rowid</literal> 컬럼을 사용할 수 있다. ROWID는 구현 상세이고 저장된 "
"튜플(tuple)의 물리적이니 위치를 표현한다."

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

#. Tag: para
#: basic_mapping.xml:348
#, no-c-format
msgid ""
"<literal>abstract</literal> (optional): Used to mark abstract superclasses "
"in <literal>&lt;union-subclass&gt;</literal> hierarchies."
msgstr ""
"<literal>abstract</literal> (옵션): <literal>&lt;union-subclass&gt;</"
"literal> 계층 구조들 내에서 abstract 슈퍼클래스들을 마크하는데 사용된다."

#. Tag: para
#: basic_mapping.xml:356
#, no-c-format
msgid ""
"It is perfectly acceptable for the named persistent class to be an "
"interface. You would then declare implementing classes of that interface "
"using the <literal>&lt;subclass&gt;</literal> element. You may persist any "
"<emphasis>static</emphasis> inner class. You should specify the class name "
"using the standard form ie. <literal>eg.Foo$Bar</literal>."
msgstr ""
"명명된 영속 클래스가 인터페이스가 되는 것은 완전히 수용가능하다. 그런 다음 당"
"신은 <literal>&lt;subclass&gt;</literal> 요소를 사용하여 그 인터페이스에 대"
"한 구현 클래스들을 선언할 것이다. 당신은 임의의 <emphasis>static</emphasis> "
"inner 클래스를 영속화 시킬 수 있다. 당신은 표준 형식, 예를 들어 <literal>eg."
"Foo$Bar</literal>를 사용하여 클래스 이름을 지정해야 한다."

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

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

#. Tag: para
#: basic_mapping.xml:375
#, no-c-format
msgid ""
"<emphasis>Implicit</emphasis> polymorphism means that instances of the class "
"will be returned by a query that names any superclass or implemented "
"interface or the class and that instances of any subclass of the class will "
"be returned by a query that names the class itself. <emphasis>Explicit</"
"emphasis> polymorphism means that class instances will be returned only by "
"queries that explicitly name that class and that queries that name the class "
"will return only instances of subclasses mapped inside this <literal>&lt;"
"class&gt;</literal> declaration as a <literal>&lt;subclass&gt;</literal> or "
"<literal>&lt;joined-subclass&gt;</literal>. For most purposes the default, "
"<literal>polymorphism=\"implicit\"</literal>, 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> 다형성은 클래스의 인스턴스들이 어떤 서브클래스"
"나 구현된 인터페이스 또는 클래스를 명명하는 질의에 의해 반환될 것임을 의미하"
"고 그 클래스의 어떤 서브클래스에 대한 인스턴스들이 그 클래스 자체를 명명하는 "
"질의에 의해 반환될 것임을 의미한다. <emphasis>Explicit</emphasis> 다형성은 클"
"래스 인스턴스들이 그 클래스를 명시적으로 명명하는 질의들에 의해서만 반환될 것"
"임을 의미고 그 클래스를 명명하는 질의들이 이 <literal>&lt;class&gt;</"
"literal> 선언 내부에서 <literal>&lt;subclass&gt;</literal> 또는 <literal>&lt;"
"joined-subclass&gt;</literal>로 매핑된 서브 클래스들의 인스턴스들 만을 반환하"
"게 될 것임을 의미한다. 대부분의 용도로, 디폴트인 <literal>polymorphism="
"\"implicit\"</literal>가 적절하다.두 개의 다른 클래스들이 동일한 테이블로 매"
"핑될 때 Explicit 다형성이 유용하다(이것은 테이블 컬럼들의 서브셋을 포함하는 "
"\"경량급\" 클래스를 허용한다)."

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

#. Tag: para
#: basic_mapping.xml:398
#, no-c-format
msgid ""
"Note that the <literal>dynamic-update</literal> and <literal>dynamic-insert</"
"literal> settings are not inherited by subclasses and so may also be "
"specified on the <literal>&lt;subclass&gt;</literal> or <literal>&lt;joined-"
"subclass&gt;</literal> elements. These settings may increase performance in "
"some cases, but might actually decrease performance in others. Use "
"judiciously."
msgstr ""
"<literal>dynamic-update</literal> 설정과 <literal>dynamic-insert</literal> 설"
"정은 서브클래스들에 의해 상속되지 않고 따라서 또한 <literal>&lt;subclass&gt;"
"</literal> 또는 <literal>&lt;joined-subclass&gt;</literal> 요소들 상에 지정"
"될 수도 있음을 노트하라. 이들 설정들은 몇몇 경우들에서 퍼포먼스를 증가시키지"
"만 다른 경우들에서는 퍼포먼스를 실제로 감소시킬 수도 있다. 적절하게 사용하라."

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

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

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

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

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

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

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

#. Tag: para
#: basic_mapping.xml:445
#, no-c-format
msgid ""
"There is no difference between a view and a base table for a Hibernate "
"mapping, as expected this is transparent at the database level (note that "
"some DBMS don't support views properly, especially with updates). Sometimes "
"you want to use a view, but can't create one in the database (ie. 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: programlisting
#: basic_mapping.xml:453
#, no-c-format
msgid ""
"<![CDATA[<class name=\"Summary\">\n"
"    <subselect>\n"
"        select item.name, max(bid.amount), count(*)\n"
"        from item\n"
"        join bid on bid.item_id = item.id\n"
"        group by item.name\n"
"    </subselect>\n"
"    <synchronize table=\"item\"/>\n"
"    <synchronize table=\"bid\"/>\n"
"    <id name=\"name\"/>\n"
"    ...\n"
"</class>]]>"
msgstr ""

#. Tag: para
#: basic_mapping.xml:455
#, no-c-format
msgid ""
"Declare the tables to synchronize this entity with, ensuring that auto-flush "