xml.po

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

msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2007-10-25 07:48+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <[e-mail]>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#. Tag: title
#: xml.xml:5
#, no-c-format
msgid "XML Mapping"
msgstr "XML 매핑"

#. Tag: emphasis
#: xml.xml:7
#, no-c-format
msgid ""
"Note that this is an experimental feature in Hibernate 3.0 and is under "
"extremely active development."
msgstr ""
"이것은 Hibernate3.0에서 실험적인 특징이고 매우 활동적으로 개발 중에 있음을 노"
"트하라."

#. Tag: title
#: xml.xml:13
#, no-c-format
msgid "Working with XML data"
msgstr "XML 데이터로 작업하기"

#. Tag: para
#: xml.xml:15
#, no-c-format
msgid ""
"Hibernate lets you work with persistent XML data in much the same way you "
"work with persistent POJOs. A parsed XML tree can be thought of as just "
"another way to represent the relational data at the object level, instead of "
"POJOs."
msgstr ""
"Hibernate는 당신이 영속 POJO들로 작업하는 것과 아주 동일한 방법으로 영속 XML "
"데이터에 작업하도록 해준다. 파싱된 XML 트리는 단지 객체 레벨에서 관계형 데이"
"터를 나타내는 또 다른 방법으로 간주될 수 있다. 하나의 파싱된 XML 트리는 POJO"
"들 대신, 객체 레벨에서 관계형 데이터를 표현하는 단지 또 다른 방법으로 간주될 "
"수 있다."

#. Tag: para
#: xml.xml:22
#, no-c-format
msgid ""
"Hibernate supports dom4j as API for manipulating XML trees. You can write "
"queries that retrieve dom4j trees from the database and have any "
"modification you make to the tree automatically synchronized to the "
"database. You can even take an XML document, parse it using dom4j, and write "
"it to the database with any of Hibernate's basic operations: <literal>persist"
"(), saveOrUpdate(), merge(), delete(), replicate()</literal> (merging is not "
"yet supported)."
msgstr ""
"Hibernate는 XML 트리들을 처리하는 API로서 dom4j를 지원한다. 당신은 데이터베이"
"스로부터 dom4j 트리들을 검색하고 당신이 그 트리를 데이터베이스와 자동적으로 "
"동기화시키기 위해 어떤 변경을 행하도록 하는 질의들을 작성할 수 있다. 당신은 "
"심지어 XML 문서를 취하고, dom4j를 사용하여 그것을 파싱하고, Hibernate의 다음 "
"기본적인 오퍼레이션들 중 어떤 것으로서 그것을 데이터베이스에 저장시킬 수 있"
"다: <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</"
"literal>(merging(병합)은 아직 지원되지 않는다)."

#. Tag: para
#: xml.xml:32
#, no-c-format
msgid ""
"This feature has many applications including data import/export, "
"externalization of entity data via JMS or SOAP and XSLT-based reporting."
msgstr ""
"이 특징은 데이터 가져오기/내보내기,JMS 또는 SOAP 그리고 XSLT-기반의 레포팅을 "
"통한 엔티티 데이터의 구체화를 포함하는 많은 어플리케이션들을 갖는다."

#. Tag: para
#: xml.xml:37
#, no-c-format
msgid ""
"A single mapping may be used to simultaneously map properties of a class and "
"nodes of an XML document to the database, or, if there is no class to map, "
"it may be used to map just the XML."
msgstr ""
"하나의 매핑은 클래스들의 프로퍼티들과 XML 문서의 노드들을 데이터베이스로 동시"
"에 매핑시키는데 사용될 수 있거나, 만일 매핑할 클래스가 존재하지 않을 경우, 그"
"것은 단지 XML을 매핑시키는데 사용될 수도 있다."

#. Tag: title
#: xml.xml:44
#, no-c-format
msgid "Specifying XML and class mapping together"
msgstr "XML과 클래스 매핑을 함께 지정하기"

#. Tag: para
#: xml.xml:46
#, no-c-format
msgid "Here is an example of mapping a POJO and XML simultaneously:"
msgstr "다음은 POJO와 XML을 동시에 매핑시키는 예제이다 :"

#. Tag: programlisting
#: xml.xml:50
#, no-c-format
msgid ""
"<![CDATA[<class name=\"Account\" \n"
"        table=\"ACCOUNTS\" \n"
"        node=\"account\">\n"
"        \n"
"    <id name=\"accountId\" \n"
"            column=\"ACCOUNT_ID\" \n"
"            node=\"@id\"/>\n"
"            \n"
"    <many-to-one name=\"customer\" \n"
"            column=\"CUSTOMER_ID\" \n"
"            node=\"customer/@id\" \n"
"            embed-xml=\"false\"/>\n"
"            \n"
"    <property name=\"balance\" \n"
"            column=\"BALANCE\" \n"
"            node=\"balance\"/>\n"
"            \n"
"    ...\n"
"    \n"
"</class>]]>"
msgstr ""

#. Tag: title
#: xml.xml:54
#, no-c-format
msgid "Specifying only an XML mapping"
msgstr "XML 매핑만을 지정하기"

#. Tag: para
#: xml.xml:56
#, no-c-format
msgid "Here is an example where there is no POJO class:"
msgstr "다음은 POJO 클래스가 존재하지 않는 예제이다:"

#. Tag: programlisting
#: xml.xml:60
#, no-c-format
msgid ""
"<![CDATA[<class entity-name=\"Account\" \n"
"        table=\"ACCOUNTS\" \n"
"        node=\"account\">\n"
"        \n"
"    <id name=\"id\" \n"
"            column=\"ACCOUNT_ID\" \n"
"            node=\"@id\" \n"
"            type=\"string\"/>\n"
"            \n"
"    <many-to-one name=\"customerId\" \n"
"            column=\"CUSTOMER_ID\" \n"
"            node=\"customer/@id\" \n"
"            embed-xml=\"false\" \n"
"            entity-name=\"Customer\"/>\n"
"            \n"
"    <property name=\"balance\" \n"
"            column=\"BALANCE\" \n"
"            node=\"balance\" \n"
"            type=\"big_decimal\"/>\n"
"            \n"
"    ...\n"
"    \n"
"</class>]]>"
msgstr ""

#. Tag: para
#: xml.xml:62
#, no-c-format
msgid ""
"This mapping allows you to access the data as a dom4j tree, or as a graph of "
"property name/value pairs (java <literal>Map</literal>s). The property names "
"are purely logical constructs that may be referred to in HQL queries."
msgstr ""
"이 매핑은 dom4j 트리로서 또는 프로퍼티 name/value 쌍들(java <literal>Map</"
"literal>들)의 그래프로서 데이터에 접근하는 것을 당신에게 허용해준다. 프로퍼"
"티 이름들은 HQL 질의들 내에서 참조될 수도 있는 순수하게 논리적인 구조체들이"
"다."

#. Tag: title
#: xml.xml:73
#, no-c-format
msgid "XML mapping metadata"
msgstr "XML 매핑 메타데이터"

#. Tag: para
#: xml.xml:75
#, no-c-format
msgid ""
"Many Hibernate mapping elements accept the <literal>node</literal> "
"attribute. This let's you specify the name of an XML attribute or element "
"that holds the property or entity data. The format of the <literal>node</"
"literal> attribute must be one of the following:"
msgstr ""
"많은 Hibernate 매핑 요소들은 <literal>node</literal> 속성을 수용한다. 이것은 "
"당신이 프로퍼티 또는 엔티티 데이터를 소유하는 XML 속성이나 요소의 이름을 지정"
"하도록 한다. <literal>node</literal> 속성의 포맷은 다음 중 하나이어야 한다:"

#. Tag: para
#: xml.xml:84
#, no-c-format
msgid "<literal>\"element-name\"</literal> - map to the named XML element"
msgstr "<literal>\"element-name\"</literal> - 명명된 XML 요소로 매핑시킨다"

#. Tag: para
#: xml.xml:87
#, no-c-format
msgid "<literal>\"@attribute-name\"</literal> - map to the named XML attribute"
msgstr ""
"<literal>\"@attribute-name\"</literal> - 명명된 XML 속성으로 매핑시킨다"

#. Tag: para
#: xml.xml:90
#, no-c-format
msgid "<literal>\".\"</literal> - map to the parent element"
msgstr "<literal>\".\"</literal> - 부모 요소로 매핑 시킨다"

#. Tag: para
#: xml.xml:93
#, no-c-format
msgid ""
"<literal>\"element-name/@attribute-name\"</literal> - map to the named "
"attribute of the named element"
msgstr ""
"<literal>\"element-name/@attribute-name\"</literal> - 명명된 요소의 명명된 속"
"성으로 매핑시킨다"

#. Tag: para
#: xml.xml:100
#, no-c-format
msgid ""
"For collections and single valued associations, there is an additional "
"<literal>embed-xml</literal> attribute. If <literal>embed-xml=\"true\"</"
"literal>, the default, the XML tree for the associated entity (or collection "
"of value type) will be embedded directly in the XML tree for the entity that "
"owns the association. Otherwise, if <literal>embed-xml=\"false\"</literal>, "
"then only the referenced identifier value will appear in the XML for single "
"point associations and collections will simply not appear at all."
msgstr ""
"콜렉션들과 단일 값 콜렉션들의 경우, 추가적인 <literal>embed-xml</literal> 속"
"성이 존재한다. 만일 <literal>embed-xml=\"true\"</literal> 일 경우, 연관된 엔"
"티티(또는 value 타입을 가진 콜렉션)에 대한 디폴트 XML 트리는 그 연관을 소유하"
"는 엔티티에 대한 XML 트리 속에 직접 삽입될 것이다. 그 밖의 경우 "
"<literal>embed-xml=\"false\"</literal> 일 경우, 참조된 식별자 값 만이 단일 포"
"인트 연관들에 대해 나타날 것이고 콜렉션들은 단순히 전혀 나타나지 않을 것이다."

#. Tag: para
#: xml.xml:110
#, no-c-format
msgid ""
"You should be careful not to leave <literal>embed-xml=\"true\"</literal> for "
"too many associations, since XML does not deal well with circularity!"
msgstr ""
"당신은 너무 많은 연관들에 대해 <literal>embed-xml=\"true\"</literal>로 남겨두"
"지 말도록 주의해야 한다. 왜냐하면 XML이 순환적으로 잘 처리하지 못하기 때문이"
"다!"

#. Tag: programlisting
#: xml.xml:115
#, no-c-format
msgid ""
"<![CDATA[<class name=\"Customer\" \n"
"        table=\"CUSTOMER\" \n"
"        node=\"customer\">\n"
"        \n"
"    <id name=\"id\" \n"
"            column=\"CUST_ID\" \n"
"            node=\"@id\"/>\n"
"            \n"
"    <map name=\"accounts\" \n"
"            node=\".\" \n"
"            embed-xml=\"true\">\n"
"        <key column=\"CUSTOMER_ID\" \n"
"                not-null=\"true\"/>\n"
"        <map-key column=\"SHORT_DESC\" \n"
"                node=\"@short-desc\" \n"
"                type=\"string\"/>\n"
"        <one-to-many entity-name=\"Account\"\n"
"                embed-xml=\"false\" \n"
"                node=\"account\"/>\n"
"    </map>\n"
"    \n"
"    <component name=\"name\" \n"
"            node=\"name\">\n"
"        <property name=\"firstName\" \n"
"                node=\"first-name\"/>\n"
"        <property name=\"initial\" \n"
"                node=\"initial\"/>\n"
"        <property name=\"lastName\" \n"
"                node=\"last-name\"/>\n"
"    </component>\n"
"    \n"
"    ...\n"
"    \n"
"</class>]]>"
msgstr ""

#. Tag: para
#: xml.xml:117
#, no-c-format
msgid ""
"in this case, we have decided to embed the collection of account ids, but "
"not the actual account data. The following HQL query:"
msgstr ""
"이 경우에, 우리는 실제 account 데이터가 아닌, account id들을 가진 콜렉션을 삽"
"입시키기로 결정했다. 다음 HQL 질의:"

#. Tag: programlisting
#: xml.xml:122
#, no-c-format
msgid ""
"<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :"
"lastName]]>"
msgstr ""

#. Tag: para
#: xml.xml:124
#, no-c-format
msgid "Would return datasets such as this:"
msgstr "는 다음과 같은 데이터셋들을 반환할 것이다:"

#. Tag: programlisting
#: xml.xml:128
#, no-c-format
msgid ""
"<![CDATA[<customer id=\"123456789\">\n"
"    <account short-desc=\"Savings\">987632567</account>\n"
"    <account short-desc=\"Credit Card\">985612323</account>\n"
"    <name>\n"
"        <first-name>Gavin</first-name>\n"
"        <initial>A</initial>\n"
"        <last-name>King</last-name>\n"
"    </name>\n"
"    ...\n"
"</customer>]]>"
msgstr ""

#. Tag: para
#: xml.xml:130
#, no-c-format
msgid ""
"If you set <literal>embed-xml=\"true\"</literal> on the <literal>&lt;one-to-"
"many&gt;</literal> mapping, the data might look more like this:"
msgstr ""
"만일 당신이 <literal>&lt;one-to-many&gt;</literal> 매핑에 대해 "
"<literal>embed-xml=\"true\"</literal>를 설정할 경우, 데이터는 다음과 같이 보"
"일 수도 있다:"

#. Tag: programlisting
#: xml.xml:135
#, no-c-format
msgid ""
"<![CDATA[<customer id=\"123456789\">\n"
"    <account id=\"987632567\" short-desc=\"Savings\">\n"
"        <customer id=\"123456789\"/>\n"
"        <balance>100.29</balance>\n"
"    </account>\n"
"    <account id=\"985612323\" short-desc=\"Credit Card\">\n"
"        <customer id=\"123456789\"/>\n"
"        <balance>-2370.34</balance>\n"
"    </account>\n"
"    <name>\n"
"        <first-name>Gavin</first-name>\n"
"        <initial>A</initial>\n"
"        <last-name>King</last-name>\n"
"    </name>\n"
"    ...\n"
"</customer>]]>"
msgstr ""

#. Tag: title
#: xml.xml:141
#, no-c-format
msgid "Manipulating XML data"
msgstr "XML 데이터 처리하기"

#. Tag: para
#: xml.xml:143
#, no-c-format
msgid ""
"Let's rearead and update XML documents in the application. We do this by "
"obtaining a dom4j session:"
msgstr ""
"우리의 어플리케이션 내에서 XML 문서들을 다시 읽어들이고 업데이트 시키자. 우리"
"는 dom4j 세션을 얻어서 이것을 행한다:"

#. Tag: programlisting
#: xml.xml:148
#, no-c-format
msgid ""
"<![CDATA[Document doc = ....;\n"
"       \n"
"Session session = factory.openSession();\n"
"Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
"Transaction tx = session.beginTransaction();\n"
"\n"
"List results = dom4jSession\n"
"    .createQuery(\"from Customer c left join fetch c.accounts where c."
"lastName like :lastName\")\n"
"    .list();\n"
"for ( int i=0; i<results.size(); i++ ) {\n"
"    //add the customer data to the XML document\n"
"    Element customer = (Element) results.get(i);\n"
"    doc.add(customer);\n"
"}\n"
"\n"
"tx.commit();\n"
"session.close();]]>"
msgstr ""

#. Tag: programlisting
#: xml.xml:150
#, no-c-format
msgid ""
"<![CDATA[Session session = factory.openSession();\n"
"Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
"Transaction tx = session.beginTransaction();\n"
"\n"
"Element cust = (Element) dom4jSession.get(\"Customer\", customerId);\n"
"for ( int i=0; i<results.size(); i++ ) {\n"
"    Element customer = (Element) results.get(i);\n"
"    //change the customer name in the XML and database\n"
"    Element name = customer.element(\"name\");\n"
"    name.element(\"first-name\").setText(firstName);\n"
"    name.element(\"initial\").setText(initial);\n"
"    name.element(\"last-name\").setText(lastName);\n"
"}\n"
"\n"
"tx.commit();\n"
"session.close();]]>"
msgstr ""

#. Tag: para
#: xml.xml:152
#, no-c-format
msgid ""
"It is extremely useful to combine this feature with Hibernate's "
"<literal>replicate()</literal> operation to implement XML-based data import/"
"export."
msgstr ""
"XML 기반의 데이터 가져오기/내보내기를 구현하는데 이 특징과 Hibernate의 "
"<literal>replicate()</literal> 오퍼레이션을 결합시키는 것이 매우 유용하다."