match to latest English XML

git-svn-id: https://svn.jboss.org/repos/hibernate/core/trunk@14148 1b8cb986-b30d-0410-93ca-fae66ebed9b2

documentation/manual/ko-KR/src/main/docbook/content/architecture.xml

@@ -284,7 +284,14 @@
 					<literal>org.hibernate.context.ThreadLocalSessionContext</literal> - 현재의 세션들은 
 					실행 쓰레드에 의해 추적된다. 상세한 것은 다시 javadocs를 보라.
 				</para>
-			</listitem>
+			</listitem>            <listitem>
+				<para> NOT TRANSLATED!
+					<literal>org.hibernate.context.ManagedSessionContext</literal> - current
+					sessions are tracked by thread of execution. However, you are responsible to
+					bind and unbind a <literal>Session</literal> instance with static methods
+					on this class, it does never open, flush, or close a <literal>Session</literal>.
+				</para>
+            </listitem>
 		</itemizedlist>
 	    <para>
                         처음의 두 구현들은 <emphasis>session-per-request</emphasis>로 알려지고 사용되고 있는 

documentation/manual/ko-KR/src/main/docbook/content/basic_mapping.xml

@@ -862,7 +862,175 @@
             </sect3>
 
         </sect2>
+	
+	<sect2 id="mapping-declaration-id-enhanced">
+		<title>NOT TRANSLATED!Enhanced identifier generators</title>
+		
+		<para>
+			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.
+		</para>
+		
+		<para>
+			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</literal> generator and secondly as
+			a better portability generator than <literal>native</literal> (because <literal>native</literal>
+			(generally) chooses between <literal>identity</literal> and <literal>sequence</literal> which have
+			largely different semantics which can cause subtle isssues in applications eyeing portability).
+			<literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> however achieves portability in
+			a different manner.  It chooses between using 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</literal> 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:
+			<itemizedlist spacing="compact">
+				<listitem>
+					<para>
+						<literal>sequence_name</literal> (optional, defaults to <literal>hibernate_sequence</literal>):
+						The name of the sequence (or table) to be used.
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial
+						value to be retrieved from the sequence/table.  In sequence creation terms, this is analogous
+						to the clause typical named "STARTS WITH".
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by
+						which subsequent calls to the sequence/table should differ.  In sequence creation terms, this
+						is analogous to the clause typical named "INCREMENT BY".
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>force_table_use</literal> (optional, defaults to <literal>false</literal>): Should
+						we force the use of a table as the backing structure even though the dialect might support
+						sequence?
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>value_column</literal> (optional, defaults to <literal>next_val</literal>): Only
+						relevant for table structures!  The name of the column on the table which is used to
+						hold the value.
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>optimizer</literal> (optional, defaults to <literal>none</literal>):
+						See <xref linkend="mapping-declaration-id-enhanced-optimizers"/>
+					</para>
+				</listitem>
+			</itemizedlist>
+		</para>
+		<para>
+			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</literal> generator (although it actually
+			functions much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal>) 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:
+			<itemizedlist spacing="compact">
+				<listitem>
+					<para>
+						<literal>table_name</literal> (optional, defaults to <literal>hibernate_sequences</literal>):
+						The name of the table to be used.
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>value_column_name</literal> (optional, defaults to <literal>next_val</literal>):
+						The name of the column on the table which is used to hold the value.
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>segment_column_name</literal> (optional, defaults to <literal>sequence_name</literal>):
+						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.
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>segment_value</literal> (optional, defaults to <literal>default</literal>):
+						The "segment key" value for the segment from which we want to pull increment values for
+						this generator.
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>segment_value_length</literal> (optional, defaults to <literal>255</literal>):
+						Used for schema generation; the column size to create this segment key column.
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>initial_value</literal> (optional, defaults to <literal>1</literal>):
+						The initial value to be retrieved from the table.
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>increment_size</literal> (optional, defaults to <literal>1</literal>):
+						The value by which subsequent calls to the table should differ.
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>optimizer</literal> (optional, defaults to <literal></literal>):
+						See <xref linkend="mapping-declaration-id-enhanced-optimizers"/>
+					</para>
+				</listitem>
+			</itemizedlist>
+		</para>
+	</sect2>
+	
+	<sect2 id="mapping-declaration-id-enhanced-optimizers">
+		<title>NOT TRANSLATED! Identifier generator optimization</title>
+		<para>
+			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.
+			<itemizedlist spacing="compact">
+				<listitem>
+					<para>
+						<literal>none</literal> (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.
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>hilo</literal>: 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</literal> is multiplied by that value in memory to define a group
+						"hi value".
+					</para>
+				</listitem>
+				<listitem>
+					<para>
+						<literal>pooled</literal>: like was discussed for <literal>hilo</literal>, 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</literal>
+						here refers to the values coming from the database.
+					</para>
+				</listitem>
+			</itemizedlist>
+		</para>
+	</sect2>
+	
 
+	
         <sect2 id="mapping-declaration-compositeid" revision="3">
             <title>composite-id</title>
 

documentation/manual/ko-KR/src/main/docbook/content/configuration.xml

@@ -581,8 +581,7 @@ hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]></programlisting>
                             <literal>hibernate.jdbc.use_streams_for_binary</literal>
                         </entry>
                         <entry>
-                            <literal>binary</literal> 또는 <literal>serializable</literal> 타입들을 JDBC로 기록하고
+                            FUZZY! <literal>binary</literal> 또는 <literal>serializable</literal> 타입들을 읽어들일 때 
-                            /JDBC로부터 <literal>binary</literal> 또는 <literal>serializable</literal> 타입들을 읽어들일 때 
                                                         스트림들을 사용한다(시스템-레벨 프로퍼티).
                             <para>
                                 <emphasis role="strong">예.</emphasis>

documentation/manual/ko-KR/src/main/docbook/content/events.xml

@@ -121,12 +121,7 @@ public class AuditInterceptor extends EmptyInterceptor {
 
         <programlisting><![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]></programlisting>
 
-        <para>
+
-                        당신은 또한 <literal>Configuration</literal>을 사용하여 인터셉터를 전역 레벨 상에 설정할 수도 있다. 
-                        이 경우에, 인터셉터는 threadsafe이어야 한다.
-        </para>
-    
-        <programlisting><![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]></programlisting>
         
         <para>
             <literal>SessionFactory</literal>-영역의 인터셉터는 <literal>SessionFactory</literal>을 빌드하기에 앞서 

documentation/manual/ko-KR/src/main/docbook/content/performance.xml

@@ -635,7 +635,7 @@ Cat fritz = (Cat) iter.next();]]></programlisting>
                 <entry>OSCache</entry>
                 <entry><literal>org.hibernate.cache.OSCacheProvider</literal></entry>
                 <entry>memory, disk</entry>
-                <entry>yes (clustered invalidation)</entry>
+                <entry></entry>
                 <entry>yes</entry>
             </row>
             <row>

documentation/manual/ko-KR/src/main/docbook/content/persistent_classes.xml

@@ -155,9 +155,7 @@ public class Cat {
                     <para>
                         <literal>Session.merge()</literal>
                     </para>
-                    <para>
+
-                                                를 보라 
-                    </para>
                 </listitem>
             </itemizedlist>
 

documentation/manual/ko-KR/src/main/docbook/content/session_api.xml

@@ -84,6 +84,28 @@ Long generatedId = (Long) sess.save(fritz);]]></programlisting>
                         호출하기 전에 그 식별자가<literal>cat</literal> 인스턴스에 할당될 것이다. 당신은 또한  EJB3 초기 드래프트에서 
                         정의된 의미로 <literal>save()</literal> 대신 <literal>persist()</literal>를 사용할 수도 있다.
         </para>
+	<itemizedlist spacing="compact">
+		<listitem>
+			<para> UNTRANSLATED!
+				<literal>persist()</literal> makes a transient instance persistent. 
+				However, it doesn't guarantee that the identifier value will be assigned to 
+				the persistent instance immediately, the assignment might happen at flush time. 
+				<literal>persist()</literal> also guarantees that it will not execute an 
+				<literal>INSERT</literal> statement if it is called outside of transaction 
+				boundaries. This is useful in long-running conversations with an extended 
+				Session/persistence context.
+			</para>
+		</listitem>
+		<listitem>
+			<para>
+				<literal>save()</literal> does guarantee to return an identifier. If an INSERT 
+				has to be executed to get the identifier ( e.g. "identity" generator, not 
+				"sequence"), this INSERT happens immediately, no matter if you are inside or 
+				outside of a transaction. This is problematic in a long-running conversation  
+				with an extended Session/persistence context.
+			</para>
+		</listitem>
+	</itemizedlist>        
         
         <para>
                         다른 방법으로, 당신은 <literal>save()</literal>의 오버로드된 버전을 사용하여 식별자를 할당할 수 있다.
@@ -279,8 +301,8 @@ while ( iter.hasNext() ) {
 
 while ( kittensAndMothers.hasNext() ) {
     Object[] tuple = (Object[]) kittensAndMothers.next();
-    Cat kitten = (Cat) tuple[0];
+    Cat kitten = (Cat) tuple[0];
-    Cat mother = (Cat) tuple[1];
+    Cat mother = (Cat) tuple[1];
     ....
 }]]></programlisting>
 
@@ -526,16 +548,16 @@ List cats = crit.list();]]></programlisting>
                                 중괄호들 속에 포함시켜야 한다:
             </para>
 
-            <programlisting><![CDATA[List cats = session.createSQLQuery("SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10")
+            <programlisting><![CDATA[List cats = session.createSQLQuery("SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10")
-    .addEntity("cat", Cat.class)
+    .addEntity("cat", Cat.class)
-.list();]]></programlisting>
+.list();]]></programlisting>
-                
+                
-            <programlisting><![CDATA[List cats = session.createSQLQuery(
+            <programlisting><![CDATA[List cats = session.createSQLQuery(
-    "SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, " +
+    "SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, " +
-           "{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... " +
+           "{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... " +
-    "FROM CAT {cat} WHERE ROWNUM<10")
+    "FROM CAT {cat} WHERE ROWNUM<10")
-    .addEntity("cat", Cat.class)
+    .addEntity("cat", Cat.class)
-.list()]]></programlisting>
+.list()]]></programlisting>
 
             <para>
                 SQL 질의들은 Hibernate 질의들처럼 명명된 파라미터들과 위치 파라미터들을 포함할 수도 있다. SQL 질의들에 대한