← Back to branch summary

~raginggoblin/infolog/infolog

« back to all changes in this revision

Viewing changes to InfologServer/lib/hibernate-distribution-3.3.2.GA/project/documentation/manual/src/main/docbook/ko-KR/content/component_mapping.po

  • Committer: Raging Goblin
  • Date: 2013-11-16 16:51:32 UTC
  • Revision ID: raging_goblin-20131116165132-weujnptzc88uy4ah
Mavenized the project, now using shared project InfologSync

Show diffs side-by-side

added added

removed removed

Lines of Context:
InfologServer/lib/hibernate-distribution-3.3.2.GA/project/documentation/manual/src/main/docbook/ko-KR/content/component_mapping.po
1
 
msgid ""
2
 
msgstr ""
3
 
"Project-Id-Version: PACKAGE VERSION\n"
4
 
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
5
 
"POT-Creation-Date: 2009-06-10 21:02+0000\n"
6
 
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
7
 
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
8
 
"Language-Team: LANGUAGE <LL@li.org>\n"
9
 
"MIME-Version: 1.0\n"
10
 
"Content-Type: text/plain; charset=UTF-8\n"
11
 
"Content-Transfer-Encoding: 8bit\n"
12
 
 
13
 
#. Tag: title
14
 
#: component_mapping.xml:29
15
 
#, no-c-format
16
 
msgid "Component Mapping"
17
 
msgstr "Component 매핑"
18
 
 
19
 
#. Tag: para
20
 
#: component_mapping.xml:31
21
 
#, fuzzy, no-c-format
22
 
msgid ""
23
 
"The notion of a <emphasis>component</emphasis> is re-used in several "
24
 
"different contexts and purposes throughout Hibernate."
25
 
msgstr ""
26
 
"<emphasis>component</emphasis>의 개념은 Hibernate에서 다른 용도로 몇몇 다른 "
27
 
"컨텍스트들 내에서 재사용된다."
28
 
 
29
 
#. Tag: title
30
 
#: component_mapping.xml:37
31
 
#, no-c-format
32
 
msgid "Dependent objects"
33
 
msgstr "종속 객체들"
34
 
 
35
 
#. Tag: para
36
 
#: component_mapping.xml:39
37
 
#, fuzzy, no-c-format
38
 
msgid ""
39
 
"A component is a contained object that is persisted as a value type and not "
40
 
"an entity reference. The term \"component\" refers to the object-oriented "
41
 
"notion of composition and not to architecture-level components. For example, "
42
 
"you can model a person like this:"
43
 
msgstr ""
44
 
"하나의 컴포넌트는 엔티티 참조가 아닌, value 타입으로서 영속화 되는 하나의 포"
45
 
"함된 객체이다. \"컴포넌트\" 용어는 (아키텍처 수준의 컴포넌트들이 아닌) "
46
 
"composition(구성,합성)에 대한 객체-지향적인 개념을 언급한다. 예를 들어 당신"
47
 
"은 다음과 같이 개인을 모형화 시킬 수도 있다:"
48
 
 
49
 
#. Tag: programlisting
50
 
#: component_mapping.xml:45
51
 
#, no-c-format
52
 
msgid ""
53
 
"<![CDATA[public class Person {\n"
54
 
"    private java.util.Date birthday;\n"
55
 
"    private Name name;\n"
56
 
"    private String key;\n"
57
 
"    public String getKey() {\n"
58
 
"        return key;\n"
59
 
"    }\n"
60
 
"    private void setKey(String key) {\n"
61
 
"        this.key=key;\n"
62
 
"    }\n"
63
 
"    public java.util.Date getBirthday() {\n"
64
 
"        return birthday;\n"
65
 
"    }\n"
66
 
"    public void setBirthday(java.util.Date birthday) {\n"
67
 
"        this.birthday = birthday;\n"
68
 
"    }\n"
69
 
"    public Name getName() {\n"
70
 
"        return name;\n"
71
 
"    }\n"
72
 
"    public void setName(Name name) {\n"
73
 
"        this.name = name;\n"
74
 
"    }\n"
75
 
"    ......\n"
76
 
"    ......\n"
77
 
"}]]>"
78
 
msgstr ""
79
 
 
80
 
#. Tag: programlisting
81
 
#: component_mapping.xml:47
82
 
#, no-c-format
83
 
msgid ""
84
 
"<![CDATA[public class Name {\n"
85
 
"    char initial;\n"
86
 
"    String first;\n"
87
 
"    String last;\n"
88
 
"    public String getFirst() {\n"
89
 
"        return first;\n"
90
 
"    }\n"
91
 
"    void setFirst(String first) {\n"
92
 
"        this.first = first;\n"
93
 
"    }\n"
94
 
"    public String getLast() {\n"
95
 
"        return last;\n"
96
 
"    }\n"
97
 
"    void setLast(String last) {\n"
98
 
"        this.last = last;\n"
99
 
"    }\n"
100
 
"    public char getInitial() {\n"
101
 
"        return initial;\n"
102
 
"    }\n"
103
 
"    void setInitial(char initial) {\n"
104
 
"        this.initial = initial;\n"
105
 
"    }\n"
106
 
"}]]>"
107
 
msgstr ""
108
 
 
109
 
#. Tag: para
110
 
#: component_mapping.xml:49
111
 
#, fuzzy, no-c-format
112
 
msgid ""
113
 
"Now <literal>Name</literal> can be persisted as a component of "
114
 
"<literal>Person</literal>. <literal>Name</literal> defines getter and setter "
115
 
"methods for its persistent properties, but it does not need to declare any "
116
 
"interfaces or identifier properties."
117
 
msgstr ""
118
 
"이제 <literal>Name</literal>은 <literal>Person</literal>의 컴포넌트로서 영속"
119
 
"화 될 수도 있다. <literal>Name</literal>이 그것의 영속 프로퍼티들에 대한 "
120
 
"getter 메소드와 setter 메소드를 정의하지만, 어떤 인터페이스들이나 식별자 프로"
121
 
"퍼티들을 선언하는 것을 필요로 하지 않음을 주목하라."
122
 
 
123
 
#. Tag: para
124
 
#: component_mapping.xml:56
125
 
#, fuzzy, no-c-format
126
 
msgid "Our Hibernate mapping would look like this:"
127
 
msgstr "우리의 Hibernate 매핑은 다음과 같을 것이다:"
128
 
 
129
 
#. Tag: programlisting
130
 
#: component_mapping.xml:60
131
 
#, no-c-format
132
 
msgid ""
133
 
"<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
134
 
"    <id name=\"Key\" column=\"pid\" type=\"string\">\n"
135
 
"        <generator class=\"uuid\"/>\n"
136
 
"    </id>\n"
137
 
"    <property name=\"birthday\" type=\"date\"/>\n"
138
 
"    <component name=\"Name\" class=\"eg.Name\"> <!-- class attribute "
139
 
"optional -->\n"
140
 
"        <property name=\"initial\"/>\n"
141
 
"        <property name=\"first\"/>\n"
142
 
"        <property name=\"last\"/>\n"
143
 
"    </component>\n"
144
 
"</class>]]>"
145
 
msgstr ""
146
 
 
147
 
#. Tag: para
148
 
#: component_mapping.xml:62
149
 
#, no-c-format
150
 
msgid ""
151
 
"The person table would have the columns <literal>pid</literal>, "
152
 
"<literal>birthday</literal>, <literal>initial</literal>, <literal>first</"
153
 
"literal> and <literal>last</literal>."
154
 
msgstr ""
155
 
"person 테이블은 <literal>pid</literal>, <literal>birthday</literal>, "
156
 
"<literal>initial</literal>, <literal>first</literal>, <literal>last</"
157
 
"literal> 컬럼들을 가질 것이다."
158
 
 
159
 
#. Tag: para
160
 
#: component_mapping.xml:70
161
 
#, fuzzy, no-c-format
162
 
msgid ""
163
 
"Like value types, components do not support shared references. In other "
164
 
"words, two persons could have the same name, but the two person objects "
165
 
"would contain two independent name objects that were only \"the same\" by "
166
 
"value. The null value semantics of a component are <emphasis>ad hoc</"
167
 
"emphasis>. When reloading the containing object, Hibernate will assume that "
168
 
"if all component columns are null, then the entire component is null. This "
169
 
"is suitable for most purposes."
170
 
msgstr ""
171
 
"모든 값(value) 타입들처럼, 컴포넌트들은 공유된 참조들을 지원하지 않는다. 달"
172
 
"리 말해, 두 명의 개인들은 동일한 이름을 가질 수 있지만, 두 개의 person 객체들"
173
 
"은 오직 값 만이 \"동일한\" 두 개의 독립적인 name 객체들을 포함할 것이다. 컴포"
174
 
"넌트의 null 값 의미는 <emphasis>특별한 용도를 위한 것이다</emphasis>. 포함된 "
175
 
"객체를 다시 로드시킬 때, Hibernate는 모든 컴포넌트 컬럼들이 null일 경우에 전"
176
 
"체 컴포넌트가 null이라고 가정할 것이다. 이것은 대부분의 용도에 맞을 것이다."
177
 
 
178
 
#. Tag: para
179
 
#: component_mapping.xml:78
180
 
#, fuzzy, no-c-format
181
 
msgid ""
182
 
"The properties of a component can be of any Hibernate type (collections, "
183
 
"many-to-one associations, other components, etc). Nested components should "
184
 
"<emphasis>not</emphasis> be considered an exotic usage. Hibernate is "
185
 
"intended to support a fine-grained object model."
186
 
msgstr ""
187
 
"컴포넌트의 프로퍼티들은 임의의 Hibernate 타입일 수 있다(콜렉션들, many-to-"
188
 
"one 연관들, 다른 컴포넌트들, 기타). 내포된 컴포넌트들은 신종의 사용례로 간주"
189
 
"되지 <emphasis>않을</emphasis> 것이다. Hibernate는 매우 잘 정제된 객체 모형"
190
 
"을 지원하도록 고안되어있다."
191
 
 
192
 
#. Tag: para
193
 
#: component_mapping.xml:85
194
 
#, no-c-format
195
 
msgid ""
196
 
"The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;"
197
 
"parent&gt;</literal> subelement that maps a property of the component class "
198
 
"as a reference back to the containing entity."
199
 
msgstr ""
200
 
"<literal>&lt;component&gt;</literal> 요소는 컴포넌트 클래스의 프로퍼티를 포함"
201
 
"되는 엔티티에 대한 역 참조로서 매핑시키는 <literal>&lt;parent&gt;</literal> "
202
 
"서브요소를 허용한다."
203
 
 
204
 
#. Tag: programlisting
205
 
#: component_mapping.xml:91
206
 
#, no-c-format
207
 
msgid ""
208
 
"<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
209
 
"    <id name=\"Key\" column=\"pid\" type=\"string\">\n"
210
 
"        <generator class=\"uuid\"/>\n"
211
 
"    </id>\n"
212
 
"    <property name=\"birthday\" type=\"date\"/>\n"
213
 
"    <component name=\"Name\" class=\"eg.Name\" unique=\"true\">\n"
214
 
"        <parent name=\"namedPerson\"/> <!-- reference back to the Person --"
215
 
">\n"
216
 
"        <property name=\"initial\"/>\n"
217
 
"        <property name=\"first\"/>\n"
218
 
"        <property name=\"last\"/>\n"
219
 
"    </component>\n"
220
 
"</class>]]>"
221
 
msgstr ""
222
 
 
223
 
#. Tag: title
224
 
#: component_mapping.xml:96
225
 
#, no-c-format
226
 
msgid "Collections of dependent objects"
227
 
msgstr "종속 객체들을 가진 콜렉션들"
228
 
 
229
 
#. Tag: para
230
 
#: component_mapping.xml:98
231
 
#, fuzzy, no-c-format
232
 
msgid ""
233
 
"Collections of components are supported (e.g. an array of type "
234
 
"<literal>Name</literal>). Declare your component collection by replacing the "
235
 
"<literal>&lt;element&gt;</literal> tag with a <literal>&lt;composite-"
236
 
"element&gt;</literal> tag:"
237
 
msgstr ""
238
 
"컴포넌트들을 가진 콜렉션들이 지원된다(예를 들면 <literal>Name</literal> 타입"
239
 
"을 가진 배열). <literal>&lt;element&gt;</literal> 태그를 <literal>&lt;"
240
 
"composite-element&gt;</literal> 태그로 대체시켜서 당신의 컴포넌트 콜렉션을 선"
241
 
"언하라."
242
 
 
243
 
#. Tag: programlisting
244
 
#: component_mapping.xml:105
245
 
#, no-c-format
246
 
msgid ""
247
 
"<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">\n"
248
 
"    <key column=\"id\"/>\n"
249
 
"    <composite-element class=\"eg.Name\"> <!-- class attribute required -->\n"
250
 
"        <property name=\"initial\"/>\n"
251
 
"        <property name=\"first\"/>\n"
252
 
"        <property name=\"last\"/>\n"
253
 
"    </composite-element>\n"
254
 
"</set>]]>"
255
 
msgstr ""
256
 
 
257
 
#. Tag: para
258
 
#: component_mapping.xml:108
259
 
#, fuzzy, no-c-format
260
 
msgid ""
261
 
"If you define a <literal>Set</literal> of composite elements, it is "
262
 
"important to implement <literal>equals()</literal> and <literal>hashCode()</"
263
 
"literal> correctly."
264
 
msgstr ""
265
 
"노트: 만일 당신이 composite 요소를 가진 하나의 <literal>Set</literal>를 정의"
266
 
"할 경우, <literal>equals()</literal>와 <literal>hashCode()</literal>를 정확하"
267
 
"게 구현하는 것이 매우 중요하다."
268
 
 
269
 
#. Tag: para
270
 
#: component_mapping.xml:115
271
 
#, fuzzy, no-c-format
272
 
msgid ""
273
 
"Composite elements can contain components but not collections. If your "
274
 
"composite element contains components, use the <literal>&lt;nested-composite-"
275
 
"element&gt;</literal> tag. This case is a collection of components which "
276
 
"themselves have components. You may want to consider if a one-to-many "
277
 
"association is more appropriate. Remodel the composite element as an entity, "
278
 
"but be aware that even though the Java model is the same, the relational "
279
 
"model and persistence semantics are still slightly different."
280
 
msgstr ""
281
 
"Composite 요소들은 컴포넌트들을 포함하지만 콜렉션들을 포함하지 않는다. 만일 "
282
 
"당신의 composite 요소 자체가 컴포넌트들을 포함할 경우, <literal>&lt;nested-"
283
 
"composite-element&gt;</literal> 태그를 사용하라. 이것은 꽤 신종의 경우-그것"
284
 
"들 자체가 컴포넌트들을 갖고 있는 컴포넌트들의 콜렉션-이다. 이 단계에서 당신"
285
 
"은 one-to-many 연관이 더 적절한지를 당신 스스로에게 질문하게 될 것이다. 하나"
286
 
"의 엔티티로서 composite 요소를 다시 모델링하려고 시도하라 - 그러나 자바 모형"
287
 
"들이 동일할지라도, 관계형 모형과 영속화 의미들은 여전히 약간 다르다."
288
 
 
289
 
#. Tag: para
290
 
#: component_mapping.xml:127
291
 
#, fuzzy, no-c-format
292
 
msgid ""
293
 
"A composite element mapping does not support null-able properties if you are "
294
 
"using a <literal>&lt;set&gt;</literal>. There is no separate primary key "
295
 
"column in the composite element table. Hibernate uses each column's value to "
296
 
"identify a record when deleting objects, which is not possible with null "
297
 
"values. You have to either use only not-null properties in a composite-"
298
 
"element or choose a <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</"
299
 
"literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>."
300
 
msgstr ""
301
 
"당신이 하나의 <literal>&lt;set&gt;</literal>을 사용 중이라면, 하나의 "
302
 
"composite 요소 매핑은 null 가능한 프로퍼티들을 지원하지 않음을 노트하길 바란"
303
 
"다. Hibernate는 객체들을 삭제할 때 하나의 레코드를 식별하는데 각각의 컬럼들 "
304
 
"값을 사용해야 하며 (composite 요소 테이블 내에 별도의 프라이머리 키 컬럼이 존"
305
 
"재하지 않는다), 그것은 null 값들에 대해서는 불가능하다. 당신은 하나의 "
306
 
"composite-요소 내에 not-null 프로퍼티들 만을 사용해야 하거나 하나의 "
307
 
"<literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, "
308
 
"<literal>&lt;bag&gt;</literal> 또는 <literal>&lt;idbag&gt;</literal>을 선택해"
309
 
"야 한다."
310
 
 
311
 
#. Tag: para
312
 
#: component_mapping.xml:138
313
 
#, fuzzy, no-c-format
314
 
msgid ""
315
 
"A special case of a composite element is a composite element with a nested "
316
 
"<literal>&lt;many-to-one&gt;</literal> element. This mapping allows you to "
317
 
"map extra columns of a many-to-many association table to the composite "
318
 
"element class. The following is a many-to-many association from "
319
 
"<literal>Order</literal> to <literal>Item</literal>, where "
320
 
"<literal>purchaseDate</literal>, <literal>price</literal> and "
321
 
"<literal>quantity</literal> are properties of the association:"
322
 
msgstr ""
323
 
"composite 요소에 대한 하나의 특별한 경우는 내포된 <literal>&lt;many-to-"
324
 
"one&gt;</literal> 요소를 가진 composite 요소이다. 이같은 매핑은 many-to-many "
325
 
"연관 테이블의 특별한 컬럼들을 composite 요소 클래스로 매핑시키는 것을 당신에"
326
 
"게 허용해준다. 다음은 <literal>Order</literal>로부터 <literal>Item</literal>"
327
 
"으로의 many-to-many 연관이다. 여기서 <literal>purchaseDate</literal>, "
328
 
"<literal>price</literal>, 그리고 <literal>quantity</literal>는 연관의 프로퍼"
329
 
"티들이다:"
330
 
 
331
 
#. Tag: programlisting
332
 
#: component_mapping.xml:148
333
 
#, no-c-format
334
 
msgid ""
335
 
"<![CDATA[<class name=\"eg.Order\" .... >\n"
336
 
"    ....\n"
337
 
"    <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
338
 
"        <key column=\"order_id\">\n"
339
 
"        <composite-element class=\"eg.Purchase\">\n"
340
 
"            <property name=\"purchaseDate\"/>\n"
341
 
"            <property name=\"price\"/>\n"
342
 
"            <property name=\"quantity\"/>\n"
343
 
"            <many-to-one name=\"item\" class=\"eg.Item\"/> <!-- class "
344
 
"attribute is optional -->\n"
345
 
"        </composite-element>\n"
346
 
"    </set>\n"
347
 
"</class>]]>"
348
 
msgstr ""
349
 
 
350
 
#. Tag: para
351
 
#: component_mapping.xml:150
352
 
#, fuzzy, no-c-format
353
 
msgid ""
354
 
"There cannot be a reference to the purchase on the other side for "
355
 
"bidirectional association navigation. Components are value types and do not "
356
 
"allow shared references. A single <literal>Purchase</literal> can be in the "
357
 
"set of an <literal>Order</literal>, but it cannot be referenced by the "
358
 
"<literal>Item</literal> at the same time."
359
 
msgstr ""
360
 
"물론, 양방향 연관 네비게이션의 경우, 다른 측 상에 있는 purchase에 대한 참조"
361
 
"가 존재할 수 없다. 컴포넌트들이 값(value) 타입들이고 공유된 참조들을 허용하"
362
 
"지 않음을 기억하라. 하나의 <literal>Purchase</literal>는<literal>Order</"
363
 
"literal>를 가진 set 내에 있을 수 있지만, 그것은 동시에 <literal>Item</"
364
 
"literal>에 의해 참조될 수 없다."
365
 
 
366
 
#. Tag: para
367
 
#: component_mapping.xml:158
368
 
#, no-c-format
369
 
msgid "Even ternary (or quaternary, etc) associations are possible:"
370
 
msgstr "심지어 세겹의(또는 네 겹의, 기타) 연관들이 가능하다:"
371
 
 
372
 
#. Tag: programlisting
373
 
#: component_mapping.xml:160
374
 
#, no-c-format
375
 
msgid ""
376
 
"<![CDATA[<class name=\"eg.Order\" .... >\n"
377
 
"    ....\n"
378
 
"    <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
379
 
"        <key column=\"order_id\">\n"
380
 
"        <composite-element class=\"eg.OrderLine\">\n"
381
 
"            <many-to-one name=\"purchaseDetails class=\"eg.Purchase\"/>\n"
382
 
"            <many-to-one name=\"item\" class=\"eg.Item\"/>\n"
383
 
"        </composite-element>\n"
384
 
"    </set>\n"
385
 
"</class>]]>"
386
 
msgstr ""
387
 
 
388
 
#. Tag: para
389
 
#: component_mapping.xml:162
390
 
#, fuzzy, no-c-format
391
 
msgid ""
392
 
"Composite elements can appear in queries using the same syntax as "
393
 
"associations to other entities."
394
 
msgstr ""
395
 
"composite 요소들은 다른 엔티티들에 대한 연관들과 동일한 구문을 사용하여 질의"
396
 
"들 내에 나타날 수도 있다."
397
 
 
398
 
#. Tag: title
399
 
#: component_mapping.xml:170
400
 
#, no-c-format
401
 
msgid "Components as Map indices"
402
 
msgstr "Map 인덱스들로서 컴포넌트들"
403
 
 
404
 
#. Tag: para
405
 
#: component_mapping.xml:172
406
 
#, fuzzy, no-c-format
407
 
msgid ""
408
 
"The <literal>&lt;composite-map-key&gt;</literal> element allows you to map a "
409
 
"component class as the key of a <literal>Map</literal>. Ensure that you "
410
 
"override <literal>hashCode()</literal> and <literal>equals()</literal> "
411
 
"correctly on the component class."
412
 
msgstr ""
413
 
"<literal>&lt;composite-map-key&gt;</literal> 요소는 당신에게 하나의 컴포넌트 "
414
 
"클래스를 하나의 <literal>Map</literal>의 키로서 매핑시키도록 한다. 당신은 컴"
415
 
"포넌트 클래스 상에서 <literal>hashCode()</literal>와 <literal>equals()</"
416
 
"literal>를 정확하게 오버라이드 시키도록 하라."
417
 
 
418
 
#. Tag: title
419
 
#: component_mapping.xml:181
420
 
#, no-c-format
421
 
msgid "Components as composite identifiers"
422
 
msgstr "composite 식별자들로서 컴포넌트들"
423
 
 
424
 
#. Tag: para
425
 
#: component_mapping.xml:183
426
 
#, fuzzy, no-c-format
427
 
msgid ""
428
 
"You can use a component as an identifier of an entity class. Your component "
429
 
"class must satisfy certain requirements:"
430
 
msgstr ""
431
 
"당신은 하나의 컴포넌트를 하나의 엔티티 클래스에 대한 하나의 식별자로서 사용"
432
 
"할 수도 있다. 당신의 컴포넌트 클래스는 어떤 사양들을 충족시켜야 한다:"
433
 
 
434
 
#. Tag: para
435
 
#: component_mapping.xml:190
436
 
#, no-c-format
437
 
msgid "It must implement <literal>java.io.Serializable</literal>."
438
 
msgstr "그것은 <literal>java.io.Serializable</literal>을 구현해야 한다."
439
 
 
440
 
#. Tag: para
441
 
#: component_mapping.xml:195
442
 
#, fuzzy, no-c-format
443
 
msgid ""
444
 
"It must re-implement <literal>equals()</literal> and <literal>hashCode()</"
445
 
"literal> consistently with the database's notion of composite key equality."
446
 
msgstr ""
447
 
"그것은 composite 키 등가(equality)에 대한 데이터베이스 개념과 일치되게, "
448
 
"<literal>equals()</literal>와 <literal>hashCode()</literal>를 다시 구현해야 "
449
 
"한다."
450
 
 
451
 
#. Tag: title
452
 
#: component_mapping.xml:204
453
 
#, no-c-format
454
 
msgid "Note"
455
 
msgstr ""
456
 
 
457
 
#. Tag: para
458
 
#: component_mapping.xml:205
459
 
#, fuzzy, no-c-format
460
 
msgid ""
461
 
"In Hibernate3, although the second requirement is not an absolutely hard "
462
 
"requirement of Hibernate, it is recommended."
463
 
msgstr ""
464
 
"노트: Hibernate3에서, 두 번째 사양은 Hibernate의 절대적으로 엄격한 사양이 아"
465
 
"니다. 그러나 아무튼 그것을 행하라."
466
 
 
467
 
#. Tag: para
468
 
#: component_mapping.xml:211
469
 
#, fuzzy, no-c-format
470
 
msgid ""
471
 
"You cannot use an <literal>IdentifierGenerator</literal> to generate "
472
 
"composite keys. Instead the application must assign its own identifiers."
473
 
msgstr ""
474
 
"당신은 compsite 키들을 생성시키는데 <literal>IdentifierGenerator</literal>를 "
475
 
"사용할 수 없다. 대신에 어플리케이션은 그것 자신의 식별자들을 할당해야 한다."
476
 
 
477
 
#. Tag: para
478
 
#: component_mapping.xml:216
479
 
#, fuzzy, no-c-format
480
 
msgid ""
481
 
"Use the <literal>&lt;composite-id&gt;</literal> tag, with nested "
482
 
"<literal>&lt;key-property&gt;</literal> elements, in place of the usual "
483
 
"<literal>&lt;id&gt;</literal> declaration. For example, the "
484
 
"<literal>OrderLine</literal> class has a primary key that depends upon the "
485
 
"(composite) primary key of <literal>Order</literal>."
486
 
msgstr ""
487
 
"통상의 <literal>&lt;id&gt;</literal> 선언 위치에 (내포된 <literal>&lt;key-"
488
 
"property&gt;</literal> 요소들을 가진) <literal>&lt;composite-id&gt;</"
489
 
"literal> 태그를 사용하라. 예를 들어, <literal>OrderLine</literal> 클래스는 "
490
 
"<literal>Order</literal>의 (composite) 프라이머리 키에 의존하는 프라이머리 키"
491
 
"를 갖는다."
492
 
 
493
 
#. Tag: programlisting
494
 
#: component_mapping.xml:224
495
 
#, no-c-format
496
 
msgid ""
497
 
"<![CDATA[<class name=\"OrderLine\">\n"
498
 
"    \n"
499
 
"    <composite-id name=\"id\" class=\"OrderLineId\">\n"
500
 
"        <key-property name=\"lineId\"/>\n"
501
 
"        <key-property name=\"orderId\"/>\n"
502
 
"        <key-property name=\"customerId\"/>\n"
503
 
"    </composite-id>\n"
504
 
"    \n"
505
 
"    <property name=\"name\"/>\n"
506
 
"    \n"
507
 
"    <many-to-one name=\"order\" class=\"Order\"\n"
508
 
"            insert=\"false\" update=\"false\">\n"
509
 
"        <column name=\"orderId\"/>\n"
510
 
"        <column name=\"customerId\"/>\n"
511
 
"    </many-to-one>\n"
512
 
"    ....\n"
513
 
"    \n"
514
 
"</class>]]>"
515
 
msgstr ""
516
 
 
517
 
#. Tag: para
518
 
#: component_mapping.xml:226
519
 
#, fuzzy, no-c-format
520
 
msgid ""
521
 
"Any foreign keys referencing the <literal>OrderLine</literal> table are now "
522
 
"composite. Declare this in your mappings for other classes. An association "
523
 
"to <literal>OrderLine</literal> is mapped like this:"
524
 
msgstr ""
525
 
"이제 <literal>OrderLine</literal> 테이블을 참조하는 임의의 foreign 키들이 또"
526
 
"한 compsite이다. 당신은 다른 클래스들에 대한 당신의 매핑들 속에 이것을 선언해"
527
 
"야 한다. <literal>OrderLine</literal>에 대한 하나의 연관은 다음과 같이 매핑"
528
 
"될 것이다:"
529
 
 
530
 
#. Tag: programlisting
531
 
#: component_mapping.xml:232
532
 
#, no-c-format
533
 
msgid ""
534
 
"<![CDATA[<many-to-one name=\"orderLine\" class=\"OrderLine\">\n"
535
 
"<!-- the \"class\" attribute is optional, as usual -->\n"
536
 
"    <column name=\"lineId\"/>\n"
537
 
"    <column name=\"orderId\"/>\n"
538
 
"    <column name=\"customerId\"/>\n"
539
 
"</many-to-one>]]>"
540
 
msgstr ""
541
 
 
542
 
#. Tag: para
543
 
#: component_mapping.xml:235
544
 
#, no-c-format
545
 
msgid ""
546
 
"The <literal>column</literal> element is an alternative to the "
547
 
"<literal>column</literal> attribute everywhere. Using the <literal>column</"
548
 
"literal> element just gives more declaration options, which are mostly "
549
 
"useful when utilizing <literal>hbm2ddl</literal>"
550
 
msgstr ""
551
 
 
552
 
#. Tag: para
553
 
#: component_mapping.xml:244
554
 
#, no-c-format
555
 
msgid ""
556
 
"A <literal>many-to-many</literal> association to <literal>OrderLine</"
557
 
"literal> also uses the composite foreign key:"
558
 
msgstr ""
559
 
"<literal>OrderLine</literal>에 대한 <literal>many-to-many</literal> 연관은 또"
560
 
"한 composite foreign 키를 사용한다:"
561
 
 
562
 
#. Tag: programlisting
563
 
#: component_mapping.xml:249
564
 
#, no-c-format
565
 
msgid ""
566
 
"<![CDATA[<set name=\"undeliveredOrderLines\">\n"
567
 
"    <key column name=\"warehouseId\"/>\n"
568
 
"    <many-to-many class=\"OrderLine\">\n"
569
 
"        <column name=\"lineId\"/>\n"
570
 
"        <column name=\"orderId\"/>\n"
571
 
"        <column name=\"customerId\"/>\n"
572
 
"    </many-to-many>\n"
573
 
"</set>]]>"
574
 
msgstr ""
575
 
 
576
 
#. Tag: para
577
 
#: component_mapping.xml:251
578
 
#, no-c-format
579
 
msgid ""
580
 
"The collection of <literal>OrderLine</literal>s in <literal>Order</literal> "
581
 
"would use:"
582
 
msgstr ""
583
 
"<literal>Order</literal>에서 <literal>OrderLine</literal>들의 콜렉션이 사용"
584
 
"될 것이다:"
585
 
 
586
 
#. Tag: programlisting
587
 
#: component_mapping.xml:256
588
 
#, no-c-format
589
 
msgid ""
590
 
"<![CDATA[<set name=\"orderLines\" inverse=\"true\">\n"
591
 
"    <key>\n"
592
 
"        <column name=\"orderId\"/>\n"
593
 
"        <column name=\"customerId\"/>\n"
594
 
"    </key>\n"
595
 
"    <one-to-many class=\"OrderLine\"/>\n"
596
 
"</set>]]>"
597
 
msgstr ""
598
 
 
599
 
#. Tag: para
600
 
#: component_mapping.xml:258
601
 
#, fuzzy, no-c-format
602
 
msgid "The <literal>&lt;one-to-many&gt;</literal> element declares no columns."
603
 
msgstr ""
604
 
"(통상적으로 <literal>&lt;one-to-many&gt;</literal> 요소는 컬럼들을 선언하지 "
605
 
"않는다.)"
606
 
 
607
 
#. Tag: para
608
 
#: component_mapping.xml:262
609
 
#, no-c-format
610
 
msgid ""
611
 
"If <literal>OrderLine</literal> itself owns a collection, it also has a "
612
 
"composite foreign key."
613
 
msgstr ""
614
 
"만일 <literal>OrderLine</literal> 자체가 하나의 콜렉션을 소유할 경우, 그것은 "
615
 
"또한 하나의 composite foreign 키를 갖는다."
616
 
 
617
 
#. Tag: programlisting
618
 
#: component_mapping.xml:267
619
 
#, no-c-format
620
 
msgid ""
621
 
"<![CDATA[<class name=\"OrderLine\">\n"
622
 
"    ....\n"
623
 
"    ....\n"
624
 
"    <list name=\"deliveryAttempts\">\n"
625
 
"        <key>   <!-- a collection inherits the composite key type -->\n"
626
 
"            <column name=\"lineId\"/>\n"
627
 
"            <column name=\"orderId\"/>\n"
628
 
"            <column name=\"customerId\"/>\n"
629
 
"        </key>\n"
630
 
"        <list-index column=\"attemptId\" base=\"1\"/>\n"
631
 
"        <composite-element class=\"DeliveryAttempt\">\n"
632
 
"            ...\n"
633
 
"        </composite-element>\n"
634
 
"    </set>\n"
635
 
"</class>]]>"
636
 
msgstr ""
637
 
 
638
 
#. Tag: title
639
 
#: component_mapping.xml:272
640
 
#, no-c-format
641
 
msgid "Dynamic components"
642
 
msgstr "동적인 컴포넌트들"
643
 
 
644
 
#. Tag: para
645
 
#: component_mapping.xml:274
646
 
#, fuzzy, no-c-format
647
 
msgid "You can also map a property of type <literal>Map</literal>:"
648
 
msgstr "당신은 <literal>Map</literal> 타입의 프로퍼티를 매핑시킬 수도 있다:"
649
 
 
650
 
#. Tag: programlisting
651
 
#: component_mapping.xml:278
652
 
#, no-c-format
653
 
msgid ""
654
 
"<![CDATA[<dynamic-component name=\"userAttributes\">\n"
655
 
"    <property name=\"foo\" column=\"FOO\" type=\"string\"/>\n"
656
 
"    <property name=\"bar\" column=\"BAR\" type=\"integer\"/>\n"
657
 
"    <many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/>\n"
658
 
"</dynamic-component>]]>"
659
 
msgstr ""
660
 
 
661
 
#. Tag: para
662
 
#: component_mapping.xml:280
663
 
#, fuzzy, no-c-format
664
 
msgid ""
665
 
"The semantics of a <literal>&lt;dynamic-component&gt;</literal> mapping are "
666
 
"identical to <literal>&lt;component&gt;</literal>. The advantage of this "
667
 
"kind of mapping is the ability to determine the actual properties of the "
668
 
"bean at deployment time just by editing the mapping document. Runtime "
669
 
"manipulation of the mapping document is also possible, using a DOM parser. "
670
 
"You can also access, and change, Hibernate's configuration-time metamodel "
671
 
"via the <literal>Configuration</literal> object."
672
 
msgstr ""
673
 
"<literal>&lt;dynamic-component&gt;</literal> 매핑의 의미는 <literal>&lt;"
674
 
"component&gt;</literal>와 동일하다. 이런 종류의 매핑의 장점은 배치 시에 단지 "
675
 
"매핑 문서를 편집함으로써 그 bean의 실제 프로퍼티들을 결정하는 가용성이다. 매"
676
 
"핑 문서에 대한 런타임 처리는 또한 DOM 파서를 사용하여 가능하다. 더 좋게는 당"
677
 
"신이 <literal>Configuration</literal> 객체를 통해 Hibernate의 구성-시 메타모"
678
 
"형에 접근할 수 있다(그리고 변경시킬 수 있다)"
679
 
 
680
 
#~ msgid ""
681
 
#~ "(Note that the <literal>&lt;column&gt;</literal> tag is an alternative to "
682
 
#~ "the <literal>column</literal> attribute everywhere.)"
683
 
#~ msgstr ""
684
 
#~ "(<literal>&lt;column&gt;</literal> 태그가 모든 곳에서 <literal>column</"
685
 
#~ "literal> 속성에 대한 대안임을 노트하라.)"