|
|
Hibernate example source code file (query_sql.po)
This example Hibernate source code file (query_sql.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.
The Hibernate query_sql.po source code
# translation of Collection_Mapping.po to
# translation of Collection_Mapping.po to
# translation of Collection_Mapping.po to
# translation of Collection_Mapping.po to
# translation of Collection_Mapping.po to
# translation of Collection_Mapping.po to
# Language /mnt/hgfs/base/Hibernate/Reference translations for PACKAGE package.
# Copyright (C) 2006, 2007 Free Software Foundation, Inc.
# Automatically generated, 2006.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
# , 2007.
#
msgid ""
msgstr ""
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-07-20 21:02+0000\n"
"PO-Revision-Date: 2007-02-26 10:27+1000\n"
"Last-Translator: \n"
"Language-Team: <de@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.9.1\n"
#. Tag: title
#: query_sql.xml:31
#, no-c-format
msgid "Native SQL"
msgstr "Native SQL"
#. Tag: para
#: query_sql.xml:33
#, fuzzy, no-c-format
msgid ""
"You can also express queries in the native SQL dialect of your database. "
"This is useful if you want to utilize database-specific features such as "
"query hints or the <literal>CONNECT keyword in Oracle. It also "
"provides a clean migration path from a direct SQL/JDBC based application to "
"Hibernate."
msgstr ""
"Sie können Anfragen im nativen SQL-Dialekt Ihrer Datenbank ausdrücken. Das "
"ist insbesondere dann von Nutzen, wenn Sie Datenbank-spezifische Features "
"wie Anfragetipps oder den <literal>CONNECT-Schlüsselbegriff in "
"Oracle verwenden wollen. Außerdem steht dadurch ein Migrationspfad von einer "
"direkten, auf SQL/JDBC basierenden Anwendung zu Hibernate zur Verfügung."
#. Tag: para
#: query_sql.xml:39
#, fuzzy, no-c-format
msgid ""
"Hibernate3 allows you to specify handwritten SQL, including stored "
"procedures, for all create, update, delete, and load operations."
msgstr ""
"Mit Hibernate3 können Sie per Hand geschriebene SQL (einschließlich "
"gespeicherter Prozeduren) für alle create, update, delete, und load Vorgänge "
"festlegen."
#. Tag: title
#: query_sql.xml:43
#, fuzzy, no-c-format
msgid "Using a <literal>SQLQuery"
msgstr "oder als eine <literal>List,"
#. Tag: para
#: query_sql.xml:45
#, fuzzy, no-c-format
msgid ""
"Execution of native SQL queries is controlled via the <literal>SQLQuerySession."
"createSQLQuery()</literal>. The following sections describe how to use this "
"API for querying."
msgstr ""
"Die Ausführung nativer SQL-Anfragen wird mittels <literal>SQLQuery-"
"Interface gesteuert, das man durch Aufruf von <literal>Session.createSQLQuery"
"()</literal> erhält. Nachfolgend erläutern wir die Verwendung dieser API für "
"Anfragen."
#. Tag: title
#: query_sql.xml:51
#, no-c-format
msgid "Scalar queries"
msgstr "Skalare Anfragen"
#. Tag: para
#: query_sql.xml:53
#, no-c-format
msgid "The most basic SQL query is to get a list of scalars (values)."
msgstr ""
"Die grundlegendste SQL-Anfrage erfolgt durch eine Liste von Skalaren "
"(Werten)."
#. Tag: programlisting
#: query_sql.xml:56
#, fuzzy, no-c-format
msgid ""
"sess.createSQLQuery(\"SELECT * FROM CATS\").list();\n"
"sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").list();"
msgstr ""
"sess.createSQLQuery(\"SELECT * FROM CATS\").list();\n"
"sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").list();"
#. Tag: para
#: query_sql.xml:58
#, fuzzy, no-c-format
msgid ""
"These will return a List of Object arrays (Object[]) with scalar values for "
"each column in the CATS table. Hibernate will use ResultSetMetadata to "
"deduce the actual order and types of the returned scalar values."
msgstr ""
"Beides reagiert mit einer Liste von Objekt-Datenelementen (Object[]) mit "
"skalaren Werten für jede Spalte der CATS-Tabelle. Hibernate wird unter "
"Verwendung von ResultSetMetadata die tatsächliche Anordnung und Typen der "
"erhaltenen Skalarwerte ableiten."
#. Tag: para
#: query_sql.xml:63
#, fuzzy, no-c-format
msgid ""
"To avoid the overhead of using <literal>ResultSetMetadata, or "
"simply to be more explicit in what is returned, one can use "
"<literal>addScalar():"
msgstr ""
"Um den Zusatz der Verwendung von <literal>ResultSetMetadata zu "
"vermeiden oder einfach expliziter zu sein, können Sie <literal>addScalar() but will instead explicitly get the ID, "
"NAME and BIRTHDATE column as respectively a Long, String and a Short from "
"the underlying resultset. This also means that only these three columns will "
"be returned, even though the query is using <literal>* and could "
"return more than the three listed columns."
msgstr ""
"Dadurch werden Objektreihen wiedergegeben, jedoch werden keine "
"<literal>ResultSetMetdata verwendet, sondern es wird explizit die "
"ID, NAME und BIRTHDATE Spalte als ein Long, String und ein Short vom zu "
"Grunde liegenden Ergebnissatz (\"result set\") geholt. Das bedeutet auch, "
"dass nur diese drei Spalten wiedergegeben werden, selbst wenn die Anfrage "
"<literal>* verwendet und mehr als die drei gelisteten Spalten "
"wiedergeben könnte."
#. Tag: para
#: query_sql.xml:89
#, no-c-format
msgid ""
"It is possible to leave out the type information for all or some of the "
"scalars."
msgstr ""
"Es ist möglich, die Typeninformationen für alle oder einige der Skalare "
"auszulassen."
#. Tag: programlisting
#: query_sql.xml:92
#, fuzzy, no-c-format
msgid ""
"sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
" .addScalar(\"ID\", Hibernate.LONG)\n"
" .addScalar(\"NAME\")\n"
" .addScalar(\"BIRTHDATE\")"
msgstr ""
"sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
" .addScalar(\"ID\", Hibernate.LONG)\n"
" .addScalar(\"NAME\")\n"
" .addScalar(\"BIRTHDATE\")"
#. Tag: para
#: query_sql.xml:94
#, fuzzy, no-c-format
msgid ""
"This is essentially the same query as before, but now "
"<literal>ResultSetMetaData is used to determine the type of NAME "
"and BIRTHDATE, where as the type of ID is explicitly specified."
msgstr ""
"Es handelt sich im Wesentlichen um diesselbe Anfrage wie zuvor, außer dass "
"jetzt <literal>ResultSetMetaData verwendet wurde, um den Typ von "
"NAME und BIRTHDATE zu bestimmen, während der ID-Typ explizit spezifiziert "
"wird."
#. Tag: para
#: query_sql.xml:99
#, fuzzy, no-c-format
msgid ""
"How the java.sql.Types returned from ResultSetMetaData is mapped to "
"Hibernate types is controlled by the Dialect. If a specific type is not "
"mapped, or does not result in the expected type, it is possible to customize "
"it via calls to <literal>registerHibernateType in the Dialect."
msgstr ""
"Der Dialekt steuert, wie die java.sql.Typen, die von ResultSetMetaData "
"erhalten werden, zu Hibernate Typen gemappt werden. Falls ein bestimmter Typ "
"nicht gemappt ist oder nicht den erwarteten Typ hervorbringt, so ist es "
"möglich, dies durch Anpassung an <literal>registerHibernateType im "
"Dialekt anzupassen."
#. Tag: title
#: query_sql.xml:107
#, no-c-format
msgid "Entity queries"
msgstr "Entity-Anfragen"
#. Tag: para
#: query_sql.xml:109
#, no-c-format
msgid ""
"The above queries were all about returning scalar values, basically "
"returning the \"raw\" values from the resultset. The following shows how to "
"get entity objects from a native sql query via <literal>addEntity() erhalten."
#. Tag: programlisting
#: query_sql.xml:114
#, fuzzy, no-c-format
msgid ""
"sess.createSQLQuery(\"SELECT * FROM CATS\").addEntity(Cat.class);\n"
"sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").addEntity(Cat."
"class);"
msgstr ""
"sess.createSQLQuery(\"SELECT * FROM CATS\").addEntity(Cat.class);\n"
"sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").addEntity(Cat."
"class);"
#. Tag: para
#: query_sql.xml:124
#, no-c-format
msgid "the entity returned by the query"
msgstr "die von der Anfrage wiedergegebene Entity"
#. Tag: para
#: query_sql.xml:128
#, no-c-format
msgid ""
"Assuming that Cat is mapped as a class with the columns ID, NAME and "
"BIRTHDATE the above queries will both return a List where each element is a "
"Cat entity."
msgstr ""
"Geht man davon aus, dass Cat als Klasse mit den Spalten ID, NAME und "
"BIRTHDATE gemappt ist, werden die Anfragen oben beide mit einer Liste "
"antworten, in der jedes Element eine Entity von Cat ist."
#. Tag: para
#: query_sql.xml:132
#, no-c-format
msgid ""
"If the entity is mapped with a <literal>many-to-one to another "
"entity it is required to also return this when performing the native query, "
"otherwise a database specific \"column not found\" error will occur. The "
"additional columns will automatically be returned when using the * notation, "
"but we prefer to be explicit as in the following example for a <literal>many-"
"to-one</literal> to a Dog:"
msgstr ""
"Falls die Entity mit <literal>many-to-one zu einer anderen Entity "
"gemappt ist, so ist dies ebenfalls erforderlich wenn die native Anfrage "
"durchgeführt wird, da sonst eine Datenbank-spezifische \"Spalte nicht "
"gefunden\"-Fehlermeldung (\"column not found\") erscheint. Die zusätzlichen "
"Spalten werden bei Verwendung der * Notation automatisch wiedergegeben, aber "
"wie im folgenden Beispiel für eine <literal>many-to-one zu "
"<literal>Dog wollen wir lieber explizit sein:"
#. Tag: programlisting
#: query_sql.xml:140
#, fuzzy, no-c-format
msgid ""
"sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS\")."
"addEntity(Cat.class);"
msgstr ""
"sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS\")."
"addEntity(Cat.class);"
#. Tag: para
#: query_sql.xml:142
#, no-c-format
msgid "This will allow cat.getDog() to function properly."
msgstr "Dies ermöglicht die ordnungsgemäße Funktion von cat.getDog()."
#. Tag: title
#: query_sql.xml:146
#, no-c-format
msgid "Handling associations and collections"
msgstr "Umgang mit Assoziationen und Collections"
#. Tag: para
#: query_sql.xml:148
#, no-c-format
msgid ""
"It is possible to eagerly join in the <literal>Dog to avoid the "
"possible extra roundtrip for initializing the proxy. This is done via the "
"<literal>addJoin() method, which allows you to join in an "
"association or collection."
msgstr ""
"Es ist möglich \"eager Join\" in <literal>Dog anzuwenden, um den "
"Extra-Weg zur Datenbank zur Initialisierung des Proxy zu vermeiden. Dies "
"geschieht mittels der <literal>addJoin()-Methode, die es Ihnen "
"ermöglicht, eine Assoziation oder Collection zu verbinden."
#. Tag: programlisting
#: query_sql.xml:153
#, fuzzy, no-c-format
msgid ""
"sess.createSQLQuery(\"SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, D_NAME "
"FROM CATS c, DOGS d WHERE c.DOG_ID = d.D_ID\")\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addJoin(\"cat.dog\");"
msgstr ""
"sess.createSQLQuery(\"SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, D_NAME "
"FROM CATS c, DOGS d \n"
" WHERE c.DOG_ID = d.D_ID\")\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addJoin(\"cat.dog\");"
#. Tag: para
#: query_sql.xml:155
#, fuzzy, no-c-format
msgid ""
"In this example, the returned <literal>Cat's will have their "
"<literal>dog property fully initialized without any extra "
"roundtrip to the database. Notice that you added an alias name (\"cat\") to "
"be able to specify the target property path of the join. It is possible to "
"do the same eager joining for collections, e.g. if the <literal>CatDog instead."
msgstr ""
"In diesem Beispiel ist die <literal>dog-Property der "
"wiedergegebenen <literal>Cat's voll initialisiert, ohne dass ein "
"Extra-Weg zur Datenbank nötig ist. Beachten Sie, dass wir einen Alias-Namen "
"(\"cat\") hinzugefügt haben, um den Pfad der Ziel-Property der Verbindung "
"spezifizieren zu können. Es ist möglich, dasselbe für das \"eager Joining\" "
"von Collections zu tun, z.B. wenn <literal>Cat satt dessen eine "
"\"One-to-many\" zu <literal>Dog hätte."
#. Tag: programlisting
#: query_sql.xml:163
#, fuzzy, no-c-format
msgid ""
"sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, CAT_ID FROM "
"CATS c, DOGS d WHERE c.ID = d.CAT_ID\")\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addJoin(\"cat.dogs\");"
msgstr ""
"sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, CAT_ID FROM "
"CATS c, DOGS d\n"
" WHERE c.ID = d.CAT_ID\")\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addJoin(\"cat.dogs\");"
#. Tag: para
#: query_sql.xml:165
#, fuzzy, no-c-format
msgid ""
"At this stage you are reaching the limits of what is possible with native "
"queries, without starting to enhance the sql queries to make them usable in "
"Hibernate. Problems can arise when returning multiple entities of the same "
"type or when the default alias/column names are not enough."
msgstr ""
"Wir erreichen nun den Punkt, an dem wir an die Grenzen dessen stoßen, was "
"mit nativen Anfragen möglich ist, ohne die sql-Anfragen weiterzuentwickeln, "
"um sie in Hibernate verwendbar zu machen. Das Problem zeigt sich erstmals, "
"wenn mehrere Entities desselben Typs auftauchen oder wenn die Standard "
"Alias-/Spaltennamen nicht ausreichen."
#. Tag: title
#: query_sql.xml:173
#, no-c-format
msgid "Returning multiple entities"
msgstr "Wiedergabe mehrerer Entities"
#. Tag: para
#: query_sql.xml:175
#, fuzzy, no-c-format
msgid ""
"Until now, the result set column names are assumed to be the same as the "
"column names specified in the mapping document. This can be problematic for "
"SQL queries that join multiple tables, since the same column names can "
"appear in more than one table."
msgstr ""
"Bis jetzt wird angenommen, dass die Spaltennamen des Ergebnissatzes "
"dieselben wie die im Mapping-Dokument spezifizierten Spaltennamen sind. Dies "
"kann problematisch für SQL-Anfragen sein, die mehrere Tabellen verbinden, da "
"dieselben Spaltennamen stets in mehr als einer Tabelle vorkommen."
#. Tag: para
#: query_sql.xml:180
#, no-c-format
msgid ""
"Column alias injection is needed in the following query (which most likely "
"will fail):"
msgstr ""
"Spalten Alias-Einspeisung wird bei der folgenden Anfrage benötigt (die aller "
"Wahrscheinlichkeit nach fehlschlagen wird):"
#. Tag: programlisting
#: query_sql.xml:183
#, fuzzy, no-c-format
msgid ""
"sess.createSQLQuery(\"SELECT c.*, m.* FROM CATS c, CATS m WHERE c.MOTHER_ID "
"= c.ID\")\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addEntity(\"mother\", Cat.class)"
msgstr ""
"sess.createSQLQuery(\"SELECT c.*, m.* FROM CATS c, CATS m WHERE c.MOTHER_ID "
"= c.ID\")\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addEntity(\"mother\", Cat.class)"
#. Tag: para
#: query_sql.xml:185
#, fuzzy, no-c-format
msgid ""
"The query was intended to return two Cat instances per row: a cat and its "
"mother. The query will, however, fail because there is a conflict of names; "
"the instances are mapped to the same column names. Also, on some databases "
"the returned column aliases will most likely be on the form \"c.ID\", \"c."
"NAME\", etc. which are not equal to the columns specified in the mappings "
"(\"ID\" and \"NAME\")."
msgstr ""
"Die Absicht dieser Anfrage ist es, das diese zwei Cat-Instanzen pro Reihe "
"wiedergibt, einer \"Cat\" und deren \"Mother\". Dies wird fehlschlagen, da "
"ein Namenskonflikt existiert, weil diese zu denselben Spaltennamen gemappt "
"sind; in manchen Datenbanken haben die wiedergegebenen Spalten-Aliasse aller "
"Wahrscheinlichkeit nach die Form \"c.ID\", \"c.NAME\", usw. die nicht "
"dieselbe wie die in den Mappings (\"ID\" und \"NAME\") spezifizierten "
"Spalten besitzt."
#. Tag: para
#: query_sql.xml:192
#, no-c-format
msgid "The following form is not vulnerable to column name duplication:"
msgstr ""
"Die folgende Form ist nicht anfällig für die Duplizierung von Spaltennamen:"
#. Tag: programlisting
#: query_sql.xml:195
#, fuzzy, no-c-format
msgid ""
"sess.createSQLQuery(\"SELECT {cat.*}, {mother.*} FROM CATS c, CATS m WHERE "
"c.MOTHER_ID = c.ID\")\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addEntity(\"mother\", Cat.class)"
msgstr ""
"sess.createSQLQuery(\"SELECT {cat.*}, {mother.*} FROM CATS c, CATS m WHERE "
"c.MOTHER_ID = c.ID\")\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addEntity(\"mother\", Cat.class)"
#. Tag: para
#: query_sql.xml:201
#, no-c-format
msgid ""
"the SQL query string, with placeholders for Hibernate to inject column "
"aliases"
msgstr ""
"der SQL Anfragen-String mit Platzhaltern für die durch Hibernate "
"eingespeisten Aliasse"
#. Tag: para
#: query_sql.xml:206
#, no-c-format
msgid "the entities returned by the query"
msgstr "die von der Anfrage erhaltenen Entities"
#. Tag: para
#: query_sql.xml:210
#, fuzzy, no-c-format
msgid ""
"The {cat.*} and {mother.*} notation used above is a shorthand for \"all "
"properties\". Alternatively, you can list the columns explicitly, but even "
"in this case Hibernate injects the SQL column aliases for each property. The "
"placeholder for a column alias is just the property name qualified by the "
"table alias. In the following example, you retrieve Cats and their mothers "
"from a different table (cat_log) to the one declared in the mapping "
"metadata. You can even use the property aliases in the where clause."
msgstr ""
"Die oben verwendete {cat.*} und {mother.*} Notation ist eine Kurzschrift für "
"\"alle Properties\". Alternativ können Sie die Spalten direkt auflisten, "
"wobei wir aber selbst in diesem Fall Hibernate die SQL Spalten-Aliasse für "
"jede Property einspeisen lassen. Der Platzhalter für einen Spalten-Alias ist "
"einfach der durch den Tabellen-Alias definierte Property-Name. Im folgenden "
"Beispiel erhalten wir \"Cats\" und deren \"Mothers\" von einer anderen "
"Tabelle (cat_log) als der in den Mapping-Metadata deklarierten. Beachten "
"Sie, dass wir sogar die Property-Aliasse in der \"where\"-Klausel verwenden "
"können, wenn wir das möchten."
#. Tag: programlisting
#: query_sql.xml:219
#, fuzzy, no-c-format
msgid ""
"String sql = \"SELECT ID as {c.id}, NAME as {c.name}, \" +\n"
" \"BIRTHDATE as {c.birthDate}, MOTHER_ID as {c.mother}, {mother.*} "
"\" +\n"
" \"FROM CAT_LOG c, CAT_LOG m WHERE {c.mother} = c.ID\";\n"
"\n"
"List loggedCats = sess.createSQLQuery(sql)\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addEntity(\"mother\", Cat.class).list()"
msgstr ""
"String sql = \"SELECT ID as {c.id}, NAME as {c.name}, \" + \n"
" \"BIRTHDATE as {c.birthDate}, MOTHER_ID as {c.mother}, {mother.*} "
"\" +\n"
" \"FROM CAT_LOG c, CAT_LOG m WHERE {c.mother} = c.ID\";\n"
"\n"
"List loggedCats = sess.createSQLQuery(sql)\n"
" .addEntity(\"cat\", Cat.class)\n"
" .addEntity(\"mother\", Cat.class).list()"
#. Tag: title
#: query_sql.xml:222
#, no-c-format
msgid "Alias and property references"
msgstr "Alias- und Property-Referenzen"
#. Tag: para
#: query_sql.xml:224
#, fuzzy, no-c-format
msgid ""
"In most cases the above alias injection is needed. For queries relating to "
"more complex mappings, like composite properties, inheritance "
"discriminators, collections etc., you can use specific aliases that allow "
"Hibernate to inject the proper aliases."
msgstr ""
"In den meisten Fällen wird die obige Alias-Einspeisung benötigt, jedoch "
"müssen für komplexere Mappings betreffende Anfragen wie zusammengesetzte "
"Properties, Vererbungsdiskriminatoren, Collections usw. spezielle Aliasse "
"verwendet werden, die es Hibernate erlauben, die korrekten Aliasse "
"einzuspeisen."
#. Tag: para
#: query_sql.xml:229
#, fuzzy, no-c-format
msgid ""
"The following table shows the different ways you can use the alias "
"injection. Please note that the alias names in the result are simply "
"examples; each alias will have a unique and probably different name when "
"used."
msgstr ""
"Die folgende Tabelle zeigt die verschiedenen Möglichkeiten wie die Alias-"
"Einspeisung verwendet werden kann. Hinweis: Die Alias-Namen im Ergebnis sind "
"Beispiele, jeder Alias wird bei seiner Anwendung einen eindeutigen und "
"wahrscheinlich unterschiedlichen Namen besitzen."
#. Tag: title
#: query_sql.xml:235
#, no-c-format
msgid "Alias injection names"
msgstr "Alias-Einspeisungsnamen"
#. Tag: entry
#: query_sql.xml:246
#, no-c-format
msgid "Description"
msgstr "Beschreibung"
#. Tag: entry
#: query_sql.xml:248
#, no-c-format
msgid "Syntax"
msgstr "Syntax"
#. Tag: entry
#: query_sql.xml:250
#, no-c-format
msgid "Example"
msgstr "Beispiel"
#. Tag: entry
#: query_sql.xml:256
#, no-c-format
msgid "A simple property"
msgstr "Eine einfache Property"
#. Tag: literal
#: query_sql.xml:258
#, fuzzy, no-c-format
msgid "{[aliasname].[propertyname]"
msgstr "{[aliasname].[propertyname]"
#. Tag: literal
#: query_sql.xml:260
#, fuzzy, no-c-format
msgid "A_NAME as {item.name}"
msgstr "A_NAME as {item.name}"
#. Tag: entry
#: query_sql.xml:264
#, no-c-format
msgid "A composite property"
msgstr "Eine zusammengesetzte Property"
#. Tag: literal
#: query_sql.xml:266
#, fuzzy, no-c-format
msgid "{[aliasname].[componentname].[propertyname]}"
msgstr "{[aliasname].[componentname].[propertyname]}"
#. Tag: literal
#: query_sql.xml:268
#, fuzzy, no-c-format
msgid "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
msgstr "CURRENCY als {item.amount.currency}, VALUE als {item.amount.value}"
#. Tag: entry
#: query_sql.xml:273
#, no-c-format
msgid "Discriminator of an entity"
msgstr "Diskriminator einer Entity"
#. Tag: literal
#: query_sql.xml:275
#, fuzzy, no-c-format
msgid "{[aliasname].class}"
msgstr "{[aliasname].class}"
#. Tag: literal
#: query_sql.xml:277
#, fuzzy, no-c-format
msgid "DISC as {item.class}"
msgstr "DISC as {item.class}"
#. Tag: entry
#: query_sql.xml:281
#, no-c-format
msgid "All properties of an entity"
msgstr "Alle Properties einer Entity"
#. Tag: literal
#: query_sql.xml:283 query_sql.xml:331
#, fuzzy, no-c-format
msgid "{[aliasname].*}"
msgstr "{[aliasname].*}"
#. Tag: literal
#: query_sql.xml:285
#, no-c-format
msgid "{item.*}"
msgstr "{item.*}"
#. Tag: entry
#: query_sql.xml:289
#, no-c-format
msgid "A collection key"
msgstr "Ein Collection-Schlüssel"
#. Tag: literal
#: query_sql.xml:291
#, fuzzy, no-c-format
msgid "{[aliasname].key}"
msgstr "{[aliasname].key}"
#. Tag: literal
#: query_sql.xml:293
#, fuzzy, no-c-format
msgid "ORGID as {coll.key}"
msgstr "ORGID als {coll.key}"
#. Tag: entry
#: query_sql.xml:297
#, no-c-format
msgid "The id of an collection"
msgstr "Die id einer Collection"
#. Tag: literal
#: query_sql.xml:299
#, fuzzy, no-c-format
msgid "{[aliasname].id}"
msgstr "{[aliasname].id}"
#. Tag: literal
#: query_sql.xml:301
#, fuzzy, no-c-format
msgid "EMPID as {coll.id}"
msgstr "EMPID als {coll.id}"
#. Tag: entry
#: query_sql.xml:305
#, no-c-format
msgid "The element of an collection"
msgstr "Das Element einer Collection"
#. Tag: literal
#: query_sql.xml:307
#, fuzzy, no-c-format
msgid "{[aliasname].element}"
msgstr "{[aliasname].element}"
#. Tag: literal
#: query_sql.xml:309
#, fuzzy, no-c-format
msgid "XID as {coll.element}"
msgstr "XID als {coll.element}"
#. Tag: entry
#: query_sql.xml:313
#, fuzzy, no-c-format
msgid "property of the element in the collection"
msgstr "Property des Elements in der Collection"
#. Tag: literal
#: query_sql.xml:315
#, fuzzy, no-c-format
msgid "{[aliasname].element.[propertyname]}"
msgstr "{[aliasname].element.[propertyname]}"
#. Tag: literal
#: query_sql.xml:317
#, fuzzy, no-c-format
msgid "NAME as {coll.element.name}"
msgstr "NAME als {coll.element.name}"
#. Tag: entry
#: query_sql.xml:321
#, no-c-format
msgid "All properties of the element in the collection"
msgstr "Alle Properties des Elements in der Collection"
#. Tag: literal
#: query_sql.xml:323
#, fuzzy, no-c-format
msgid "{[aliasname].element.*}"
msgstr "{[aliasname].element.*}"
#. Tag: literal
#: query_sql.xml:325
#, fuzzy, no-c-format
msgid "{coll.element.*}"
msgstr "{coll.*}"
#. Tag: entry
#: query_sql.xml:329
#, fuzzy, no-c-format
msgid "All properties of the collection"
msgstr "Alle Properties der Collection"
#. Tag: literal
#: query_sql.xml:333
#, no-c-format
msgid "{coll.*}"
msgstr "{coll.*}"
#. Tag: title
#: query_sql.xml:342
#, no-c-format
msgid "Returning non-managed entities"
msgstr "Wiedergabe nicht gemanagter Entities"
#. Tag: para
#: query_sql.xml:344
#, fuzzy, no-c-format
msgid ""
"It is possible to apply a ResultTransformer to native SQL queries, allowing "
"it to return non-managed entities."
msgstr ""
"Es ist möglich, einen ResultTransformer (Ergebnistransformer) an nativen SQL-"
"Anfragen anzuwenden, der die Wiedergabe nicht gemanagter Entities ermöglicht."
#. Tag: programlisting
#: query_sql.xml:347
#, fuzzy, no-c-format
msgid ""
"sess.createSQLQuery(\"SELECT NAME, BIRTHDATE FROM CATS\")\n"
" .setResultTransformer(Transformers.aliasToBean(CatDTO.class))"
msgstr ""
"sess.createSQLQuery(\"SELECT NAME, BIRTHDATE FROM CATS\")\n"
" .setResultTransformer(Transformers.aliasToBean(CatDTO.class))"
#. Tag: para
#: query_sql.xml:357
#, no-c-format
msgid "a result transformer"
msgstr "ein Ergebnistransformer"
#. Tag: para
#: query_sql.xml:361
#, no-c-format
msgid ""
"The above query will return a list of <literal>CatDTO which has "
"been instantiated and injected the values of NAME and BIRTHNAME into its "
"corresponding properties or fields."
msgstr ""
"Die Anfrage oben wird eine Liste von <literal>CatDTO wiedergeben, "
"die instantiiert wurde und die Werte für NAME und BIRTHNAME in die "
"entsprechenden Properties oder Felder eingespeist hat."
#. Tag: title
#: query_sql.xml:367
#, no-c-format
msgid "Handling inheritance"
msgstr "Umgang mit Vererbung"
#. Tag: para
#: query_sql.xml:369
#, fuzzy, no-c-format
msgid ""
"Native SQL queries which query for entities that are mapped as part of an "
"inheritance must include all properties for the baseclass and all its "
"subclasses."
msgstr ""
"Native SQL-Anfragen für Entities, die als Teil einer Vererbung gemappt sind, "
"müssen sämtliche Properties für die Stammklasse und alle Subklassen "
"enthalten."
#. Tag: title
#: query_sql.xml:375
#, no-c-format
msgid "Parameters"
msgstr "Parameter"
#. Tag: para
#: query_sql.xml:377
#, fuzzy, no-c-format
msgid "Native SQL queries support positional as well as named parameters:"
msgstr ""
"Native SQL-Anfragen unterstützen sowohl positionelle als auch benannte "
"Parameter:"
#. Tag: programlisting
#: query_sql.xml:380
#, fuzzy, no-c-format
msgid ""
"Query query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like ?\")."
"addEntity(Cat.class);\n"
"List pusList = query.setString(0, \"Pus%\").list();\n"
" \n"
"query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like :name\")."
"addEntity(Cat.class);\n"
"List pusList = query.setString(\"name\", \"Pus%\").list();"
msgstr ""
"Query query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like ?\")."
"addEntity(Cat.class);\n"
"List pusList = query.setString(0, \"Pus%\").list();\n"
" \n"
"query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like :name\")."
"addEntity(Cat.class);\n"
"List pusList = query.setString(\"name\", \"Pus%\").list();"
#. Tag: title
#: query_sql.xml:385
#, no-c-format
msgid "Named SQL queries"
msgstr "Benannte SQL-Anfragen"
#. Tag: para
#: query_sql.xml:387
#, fuzzy, no-c-format
msgid ""
"Named SQL queries can also be defined in the mapping document and called in "
"exactly the same way as a named HQL query (see <xref linkend=\"objectstate-"
"querying-executing-named\"/>). In this case, you do <emphasis>not "
"need to call <literal>addEntity()."
msgstr ""
"Benannte SQL-Anfragen können im Mapping-Dokument definiert und auf dieselbe "
"Weise wie eine benannte HQL-Anfrage benannt werden. In diesem Fall muss "
"<emphasis>nicht der Aufruf addEntity() "
"erfolgen."
#. Tag: title
#: query_sql.xml:394
#, no-c-format
msgid "Named sql query using the <sql-query> maping element"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:397
#, fuzzy, no-c-format
msgid ""
"<sql-query name=\"persons\">\n"
" <return alias=\"person\" class=\"eg.Person\"/>\n"
" SELECT person.NAME AS {person.name},\n"
" person.AGE AS {person.age},\n"
" person.SEX AS {person.sex}\n"
" FROM PERSON person\n"
" WHERE person.NAME LIKE :namePattern\n"
"</sql-query>"
msgstr ""
"<sql-query name=\"persons\">\n"
" <return alias=\"person\" class=\"eg.Person\"/>\n"
" SELECT person.NAME AS {person.name},\n"
" person.AGE AS {person.age},\n"
" person.SEX AS {person.sex}\n"
" FROM PERSON person\n"
" WHERE person.NAME LIKE :namePattern\n"
"</sql-query>"
#. Tag: title
#: query_sql.xml:401
#, no-c-format
msgid "Execution of a named query"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:403
#, fuzzy, no-c-format
msgid ""
"List people = sess.getNamedQuery(\"persons\")\n"
" .setString(\"namePattern\", namePattern)\n"
" .setMaxResults(50)\n"
" .list();"
msgstr ""
"List people = sess.getNamedQuery(\"persons\")\n"
" .setString(\"namePattern\", namePattern)\n"
" .setMaxResults(50)\n"
" .list();"
#. Tag: para
#: query_sql.xml:406
#, fuzzy, no-c-format
msgid ""
"The <literal><return-join> element is use to join "
"associations and the <literal><load-collection> element is "
"used to define queries which initialize collections,"
msgstr ""
"Die <literal><return-join> und <load-"
"collection></literal>-Elemente werden verwendet, um Assoziationen zu "
"verbinden bzw. Anfragen, die Collections definieren, zu initialisieren."
#. Tag: title
#: query_sql.xml:411
#, no-c-format
msgid "Named sql query with association"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:413
#, fuzzy, no-c-format
msgid ""
"<sql-query name=\"personsWith\">\n"
" <return alias=\"person\" class=\"eg.Person\"/>\n"
" <return-join alias=\"address\" property=\"person.mailingAddress\"/"
">\n"
" SELECT person.NAME AS {person.name},\n"
" person.AGE AS {person.age},\n"
" person.SEX AS {person.sex},\n"
" address.STREET AS {address.street},\n"
" address.CITY AS {address.city},\n"
" address.STATE AS {address.state},\n"
" address.ZIP AS {address.zip}\n"
" FROM PERSON person\n"
" JOIN ADDRESS address\n"
" ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
" WHERE person.NAME LIKE :namePattern\n"
"</sql-query>"
msgstr ""
"<sql-query name=\"personsWith\">\n"
" <return alias=\"person\" class=\"eg.Person\"/>\n"
" <return-join alias=\"address\" property=\"person.mailingAddress\"/"
">\n"
" SELECT person.NAME AS {person.name},\n"
" person.AGE AS {person.age},\n"
" person.SEX AS {person.sex},\n"
" adddress.STREET AS {address.street},\n"
" adddress.CITY AS {address.city},\n"
" adddress.STATE AS {address.state},\n"
" adddress.ZIP AS {address.zip}\n"
" FROM PERSON person\n"
" JOIN ADDRESS adddress\n"
" ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
" WHERE person.NAME LIKE :namePattern\n"
"</sql-query>"
#. Tag: para
#: query_sql.xml:416
#, no-c-format
msgid ""
"A named SQL query may return a scalar value. You must declare the column "
"alias and Hibernate type using the <literal><return-scalar> "
"element:"
msgstr ""
"Eine benannte SQL-Anfrage kann einen Skalarwert wiedergeben. Sie müssen "
"unter Verwendung des <literal><return-scalar>-Elements den "
"Spalten-Alias und den Hibernate-Typ deklarieren:"
#. Tag: title
#: query_sql.xml:421
#, no-c-format
msgid "Named query returning a scalar"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:423
#, fuzzy, no-c-format
msgid ""
"<sql-query name=\"mySqlQuery\">\n"
" <return-scalar column=\"name\" type=\"string\"/>\n"
" <return-scalar column=\"age\" type=\"long\"/>\n"
" SELECT p.NAME AS name, \n"
" p.AGE AS age,\n"
" FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
"</sql-query>"
msgstr ""
"<sql-query name=\"mySqlQuery\">\n"
" <return-scalar column=\"name\" type=\"string\"/>\n"
" <return-scalar column=\"age\" type=\"long\"/>\n"
" SELECT p.NAME AS name,\n"
" p.AGE AS age,\n"
" FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
"</sql-query>"
#. Tag: para
#: query_sql.xml:426
#, fuzzy, no-c-format
msgid ""
"You can externalize the resultset mapping information in a <literal><"
"resultset></literal> element which will allow you to either reuse them "
"across several named queries or through the <literal>setResultSetMapping()-Element externalisieren, um diese "
"entweder über mehrere benannte Anfragen hinweg oder durch die "
"<literal>setResultSetMapping()-API wiederzuverwenden."
#. Tag: title
#: query_sql.xml:432
#, no-c-format
msgid "<resultset> mapping used to externalize mapping information"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:435
#, fuzzy, no-c-format
msgid ""
"<resultset name=\"personAddress\">\n"
" <return alias=\"person\" class=\"eg.Person\"/>\n"
" <return-join alias=\"address\" property=\"person.mailingAddress\"/"
">\n"
"</resultset>\n"
"\n"
"<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
" SELECT person.NAME AS {person.name},\n"
" person.AGE AS {person.age},\n"
" person.SEX AS {person.sex},\n"
" address.STREET AS {address.street},\n"
" address.CITY AS {address.city},\n"
" address.STATE AS {address.state},\n"
" address.ZIP AS {address.zip}\n"
" FROM PERSON person\n"
" JOIN ADDRESS address\n"
" ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
" WHERE person.NAME LIKE :namePattern\n"
"</sql-query>"
msgstr ""
"<resultset name=\"personAddress\">\n"
" <return alias=\"person\" class=\"eg.Person\"/>\n"
" <return-join alias=\"address\" property=\"person.mailingAddress\"/"
">\n"
"</resultset>\n"
"\n"
"<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
" SELECT person.NAME AS {person.name},\n"
" person.AGE AS {person.age},\n"
" person.SEX AS {person.sex},\n"
" adddress.STREET AS {address.street},\n"
" adddress.CITY AS {address.city},\n"
" adddress.STATE AS {address.state},\n"
" adddress.ZIP AS {address.zip}\n"
" FROM PERSON person\n"
" JOIN ADDRESS adddress\n"
" ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
" WHERE person.NAME LIKE :namePattern\n"
"</sql-query>"
#. Tag: para
#: query_sql.xml:438
#, fuzzy, no-c-format
msgid ""
"You can, alternatively, use the resultset mapping information in your hbm "
"files directly in java code."
msgstr ""
"Alternativ können Sie Mapping-Informationen des Ergebnissatzes in Ihren hbm-"
"Dateien direkt in Java Code verwenden."
#. Tag: title
#: query_sql.xml:442
#, no-c-format
msgid "Programmatically specifying the result mapping information"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:445
#, fuzzy, no-c-format
msgid ""
"List cats = sess.createSQLQuery(\n"
" \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten."
"mother = cat.id\"\n"
" )\n"
" .setResultSetMapping(\"catAndKitten\")\n"
" .list();"
msgstr ""
"List cats = sess.createSQLQuery(\n"
" \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten."
"mother = cat.id\"\n"
" )\n"
" .setResultSetMapping(\"catAndKitten\")\n"
" .list();"
#. Tag: para
#: query_sql.xml:448
#, no-c-format
msgid ""
"So far we have only looked at externalizing SQL queries using Hibernate "
"mapping files. The same concept is also available with anntations and is "
"called named native queries. You can use <classname>@NamedNativeQuery@NamedNativeQueries) in conjunction with "
"<literal>@SqlResultSetMapping (@SqlResultSetMappings@NamedQuery, "
"<classname>@NamedNativeQuery and @SqlResultSetMapping parameter is defined in "
"<literal>@NamedNativeQuery. It represents the name of a defined "
"<literal>@SqlResultSetMapping. The resultset mapping declares the "
"entities retrieved by this native query. Each field of the entity is bound "
"to an SQL alias (or column name). All fields of the entity including the "
"ones of subclasses and the foreign key columns of related entities have to "
"be present in the SQL query. Field definitions are optional provided that "
"they map to the same column name as the one declared on the class property. "
"In the example 2 entities, <literal>Night and Area element should be used for each "
"foreign key column. The <literal>@FieldResult name is composed of "
"the property name for the relationship, followed by a dot (\".\"), followed "
"by the name or the field or property of the primary key. This can be seen in "
"<xref linkend=\"example-field-result-annotation-with-associations\"/>."
msgstr ""
#. Tag: title
#: query_sql.xml:490
#, no-c-format
msgid ""
"Named SQL query using <classname>@NamedNativeQuery together with "
"<classname>@SqlResultSetMapping"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:493
#, no-c-format
msgid ""
"@NamedNativeQuery(name=\"night&area\", query=\"select night.id nid, "
"night.night_duration, \"\n"
" + \" night.night_date, area.id aid, night.area_id, area.name \"\n"
" + \"from Night night, Area area where night.area_id = area.id\", \n"
" resultSetMapping=\"joinMapping\")\n"
"@SqlResultSetMapping(name=\"joinMapping\", entities={\n"
" @EntityResult(entityClass=Night.class, fields = {\n"
" @FieldResult(name=\"id\", column=\"nid\"),\n"
" @FieldResult(name=\"duration\", column=\"night_duration\"),\n"
" @FieldResult(name=\"date\", column=\"night_date\"),\n"
" @FieldResult(name=\"area\", column=\"area_id\"),\n"
" discriminatorColumn=\"disc\"\n"
" }),\n"
" @EntityResult(entityClass=org.hibernate.test.annotations.query.Area."
"class, fields = {\n"
" @FieldResult(name=\"id\", column=\"aid\"),\n"
" @FieldResult(name=\"name\", column=\"name\")\n"
" })\n"
" }\n"
")"
msgstr ""
#. Tag: title
#: query_sql.xml:497
#, no-c-format
msgid "Implicit result set mapping"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:499
#, no-c-format
msgid ""
"@Entity\n"
"@SqlResultSetMapping(name=\"implicit\",\n"
" entities=@EntityResult(entityClass=SpaceShip.class))\n"
"@NamedNativeQuery(name=\"implicitSample\", \n"
" query=\"select * from SpaceShip\", \n"
" resultSetMapping=\"implicit\")\n"
"public class SpaceShip {\n"
" private String name;\n"
" private String model;\n"
" private double speed;\n"
"\n"
" @Id\n"
" public String getName() {\n"
" return name;\n"
" }\n"
"\n"
" public void setName(String name) {\n"
" this.name = name;\n"
" }\n"
"\n"
" @Column(name=\"model_txt\")\n"
" public String getModel() {\n"
" return model;\n"
" }\n"
"\n"
" public void setModel(String model) {\n"
" this.model = model;\n"
" }\n"
"\n"
" public double getSpeed() {\n"
" return speed;\n"
" }\n"
"\n"
" public void setSpeed(double speed) {\n"
" this.speed = speed;\n"
" }\n"
"}"
msgstr ""
#. Tag: title
#: query_sql.xml:503
#, no-c-format
msgid "Using dot notation in @FieldResult for specifying associations"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:506
#, no-c-format
msgid ""
"@Entity\n"
"@SqlResultSetMapping(name=\"compositekey\",\n"
" entities=@EntityResult(entityClass=SpaceShip.class,\n"
" fields = {\n"
" @FieldResult(name=\"name\", column = \"name\"),\n"
" @FieldResult(name=\"model\", column = \"model\"),\n"
" @FieldResult(name=\"speed\", column = \"speed\"),\n"
" @FieldResult(name=\"captain.firstname\", column = "
"\"firstn\"),\n"
" @FieldResult(name=\"captain.lastname\", column = \"lastn"
"\"),\n"
" @FieldResult(name=\"dimensions.length\", column = "
"\"length\"),\n"
" @FieldResult(name=\"dimensions.width\", column = \"width"
"\")\n"
" }),\n"
" columns = { @ColumnResult(name = \"surface\"),\n"
" @ColumnResult(name = \"volume\") } )\n"
"\n"
"@NamedNativeQuery(name=\"compositekey\",\n"
" query=\"select name, model, speed, lname as lastn, fname as firstn, "
"length, width, length * width as surface from SpaceShip\", \n"
" resultSetMapping=\"compositekey\")\n"
"} )\n"
"public class SpaceShip {\n"
" private String name;\n"
" private String model;\n"
" private double speed;\n"
" private Captain captain;\n"
" private Dimensions dimensions;\n"
"\n"
" @Id\n"
" public String getName() {\n"
" return name;\n"
" }\n"
"\n"
" public void setName(String name) {\n"
" this.name = name;\n"
" }\n"
"\n"
" @ManyToOne(fetch= FetchType.LAZY)\n"
" @JoinColumns( {\n"
" @JoinColumn(name=\"fname\", referencedColumnName = \"firstname"
"\"),\n"
" @JoinColumn(name=\"lname\", referencedColumnName = \"lastname"
"\")\n"
" } )\n"
" public Captain getCaptain() {\n"
" return captain;\n"
" }\n"
"\n"
" public void setCaptain(Captain captain) {\n"
" this.captain = captain;\n"
" }\n"
"\n"
" public String getModel() {\n"
" return model;\n"
" }\n"
"\n"
" public void setModel(String model) {\n"
" this.model = model;\n"
" }\n"
"\n"
" public double getSpeed() {\n"
" return speed;\n"
" }\n"
"\n"
" public void setSpeed(double speed) {\n"
" this.speed = speed;\n"
" }\n"
"\n"
" public Dimensions getDimensions() {\n"
" return dimensions;\n"
" }\n"
"\n"
" public void setDimensions(Dimensions dimensions) {\n"
" this.dimensions = dimensions;\n"
" }\n"
"}\n"
"\n"
"@Entity\n"
"@IdClass(Identity.class)\n"
"public class Captain implements Serializable {\n"
" private String firstname;\n"
" private String lastname;\n"
"\n"
" @Id\n"
" public String getFirstname() {\n"
" return firstname;\n"
" }\n"
"\n"
" public void setFirstname(String firstname) {\n"
" this.firstname = firstname;\n"
" }\n"
"\n"
" @Id\n"
" public String getLastname() {\n"
" return lastname;\n"
" }\n"
"\n"
" public void setLastname(String lastname) {\n"
" this.lastname = lastname;\n"
" }\n"
"}"
msgstr ""
#. Tag: para
#: query_sql.xml:510
#, no-c-format
msgid ""
"If you retrieve a single entity using the default mapping, you can specify "
"the <literal>resultClass attribute instead of "
"<literal>resultSetMapping:"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:514
#, no-c-format
msgid ""
"@NamedNativeQuery(name=\"implicitSample\", query=\"select * from SpaceShip"
"\", resultClass=SpaceShip.class)\n"
"public class SpaceShip {"
msgstr ""
#. Tag: para
#: query_sql.xml:517
#, no-c-format
msgid ""
"In some of your native queries, you'll have to return scalar values, for "
"example when building report queries. You can map them in the "
"<literal>@SqlResultsetMapping through @ColumnResult"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:527
#, no-c-format
msgid ""
"@SqlResultSetMapping(name=\"scalar\", columns=@ColumnResult(name=\"dimension"
"\"))\n"
"@NamedNativeQuery(name=\"scalar\", query=\"select length*width as dimension "
"from SpaceShip\", resultSetMapping=\"scalar\")"
msgstr ""
#. Tag: para
#: query_sql.xml:530
#, no-c-format
msgid ""
"An other query hint specific to native queries has been introduced: "
"<literal>org.hibernate.callable which can be true or false "
"depending on whether the query is a stored procedure or not."
msgstr ""
#. Tag: title
#: query_sql.xml:535
#, no-c-format
msgid "Using return-property to explicitly specify column/alias names"
msgstr ""
"Die Verwendung der Return-Property zur expliziten Spezifizierung von "
"Spalten-/Aliasnamen"
#. Tag: para
#: query_sql.xml:538
#, fuzzy, no-c-format
msgid ""
"You can explicitly tell Hibernate what column aliases to use with "
"<literal><return-property>, instead of using the {}"
"</literal>-syntax to let Hibernate inject its own aliases.For example:"
msgstr ""
"Mit <literal><return-property> können Sie Hibernate explizit "
"anweisen, welche Aliasse es verwenden soll, statt die <literal>{}-"
"Syntax zu verwenden, bei der Hibernate seine eigenen Aliasse einspeist."
#. Tag: programlisting
#: query_sql.xml:543
#, fuzzy, no-c-format
msgid ""
"<sql-query name=\"mySqlQuery\">\n"
" <return alias=\"person\" class=\"eg.Person\">\n"
" <return-property name=\"name\" column=\"myName\"/>\n"
" <return-property name=\"age\" column=\"myAge\"/>\n"
" <return-property name=\"sex\" column=\"mySex\"/>\n"
" </return>\n"
" SELECT person.NAME AS myName,\n"
" person.AGE AS myAge,\n"
" person.SEX AS mySex,\n"
" FROM PERSON person WHERE person.NAME LIKE :name\n"
"</sql-query>"
msgstr ""
"<sql-query name=\"mySqlQuery\">\n"
" <return alias=\"person\" class=\"eg.Person\">\n"
" <return-property name=\"name\" column=\"myName\"/>\n"
" <return-property name=\"age\" column=\"myAge\"/>\n"
" <return-property name=\"sex\" column=\"mySex\"/>\n"
" </return>\n"
" SELECT person.NAME AS myName,\n"
" person.AGE AS myAge,\n"
" person.SEX AS mySex,\n"
" FROM PERSON person WHERE person.NAME LIKE :name\n"
"</sql-query>"
#. Tag: para
#: query_sql.xml:545
#, fuzzy, no-c-format
msgid ""
"<literal><return-property> also works with multiple columns. "
"This solves a limitation with the <literal>{}-syntax which cannot "
"allow fine grained control of multi-column properties."
msgstr ""
"<literal><return-property> funktioniert auch mit mehreren "
"Spalten. Dies löst die Einschränkungen der <literal>{}-Syntax, die "
"keine feinstufige Steuerung mehrspaltiger Properties erlaubt."
#. Tag: programlisting
#: query_sql.xml:550
#, fuzzy, no-c-format
msgid ""
"<sql-query name=\"organizationCurrentEmployments\">\n"
" <return alias=\"emp\" class=\"Employment\">\n"
" <return-property name=\"salary\">\n"
" <return-column name=\"VALUE\"/>\n"
" <return-column name=\"CURRENCY\"/>\n"
" </return-property>\n"
" <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
" </return>\n"
" SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
" STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
" REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
" FROM EMPLOYMENT\n"
" WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
" ORDER BY STARTDATE ASC\n"
"</sql-query>"
msgstr ""
"<sql-query name=\"organizationCurrentEmployments\">\n"
" <return alias=\"emp\" class=\"Employment\">\n"
" <return-property name=\"salary\">\n"
" <return-column name=\"VALUE\"/>\n"
" <return-column name=\"CURRENCY\"/>\n"
" </return-property>\n"
" <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
" </return>\n"
" SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
" STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
" REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
" FROM EMPLOYMENT\n"
" WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
" ORDER BY STARTDATE ASC\n"
"</sql-query>"
#. Tag: para
#: query_sql.xml:552
#, fuzzy, no-c-format
msgid ""
"In this example <literal><return-property> was used in "
"combination with the <literal>{}-syntax for injection. This allows "
"users to choose how they want to refer column and properties."
msgstr ""
"Bitte beachten Sie, dass wir in diesem Beispiel <literal><return-"
"property></literal> in Verbindung mit der {}-Syntax "
"für die Einspeisung verwendet haben. Dadurch ist es Benutzern möglich zu "
"entscheiden, wie auf Spalten und Properties verwiesen werden soll."
#. Tag: para
#: query_sql.xml:557
#, no-c-format
msgid ""
"If your mapping has a discriminator you must use <literal><return-"
"discriminator></literal> to specify the discriminator column."
msgstr ""
"Falls Ihr Mapping über einen Diskriminator verfügt, so müssen Sie "
"<literal><return-discriminator> verwenden, um die "
"Diskriminator-Spalte festzulegen."
#. Tag: title
#: query_sql.xml:563
#, no-c-format
msgid "Using stored procedures for querying"
msgstr "Die Verwendung gespeicherter Prozeduren für Anfragen"
#. Tag: para
#: query_sql.xml:565
#, fuzzy, no-c-format
msgid ""
"Hibernate3 provides support for queries via stored procedures and functions. "
"Most of the following documentation is equivalent for both. The stored "
"procedure/function must return a resultset as the first out-parameter to be "
"able to work with Hibernate. An example of such a stored function in Oracle "
"9 and higher is as follows:"
msgstr ""
"Hibernate 3 bietet Support für Anfragen via gespeicherter Prozeduren und "
"Funktionen. Die meisten Teile der nachfolgenden Dokumentation sind für beide "
"gleich. Die gespeicherte Prozedur/Funktion muss einen Ergebnissatz als "
"ersten \"out-Parameter\" wiedergeben, um mit Hibernate arbeiten zu können. "
"Ein Beispiel für eine solche gespeicherte Funktion in Oracle 9 und späteren "
"Versionen lautet wie folgt:"
#. Tag: programlisting
#: query_sql.xml:571
#, fuzzy, no-c-format
msgid ""
"CREATE OR REPLACE FUNCTION selectAllEmployments\n"
" RETURN SYS_REFCURSOR\n"
"AS\n"
" st_cursor SYS_REFCURSOR;\n"
"BEGIN\n"
" OPEN st_cursor FOR\n"
" SELECT EMPLOYEE, EMPLOYER,\n"
" STARTDATE, ENDDATE,\n"
" REGIONCODE, EID, VALUE, CURRENCY\n"
" FROM EMPLOYMENT;\n"
" RETURN st_cursor;\n"
" END;"
msgstr ""
"CREATE OR REPLACE FUNCTION selectAllEmployments\n"
" RETURN SYS_REFCURSOR\n"
"AS\n"
" st_cursor SYS_REFCURSOR;\n"
"BEGIN\n"
" OPEN st_cursor FOR\n"
" SELECT EMPLOYEE, EMPLOYER,\n"
" STARTDATE, ENDDATE,\n"
" REGIONCODE, EID, VALUE, CURRENCY\n"
" FROM EMPLOYMENT;\n"
" RETURN st_cursor;\n"
" END;"
#. Tag: para
#: query_sql.xml:573
#, no-c-format
msgid "To use this query in Hibernate you need to map it via a named query."
msgstr ""
"Um diese Anfrage in Hibernate zu verwenden, müssen Sie sie durch eine "
"benannte Anfrage mappen."
#. Tag: programlisting
#: query_sql.xml:576
#, fuzzy, no-c-format
msgid ""
"<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
" <return alias=\"emp\" class=\"Employment\">\n"
" <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
" <return-property name=\"employer\" column=\"EMPLOYER\"/>\n"
" <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
" <return-property name=\"endDate\" column=\"ENDDATE\"/>\n"
" <return-property name=\"regionCode\" column=\"REGIONCODE\"/>\n"
" <return-property name=\"id\" column=\"EID\"/>\n"
" <return-property name=\"salary\">\n"
" <return-column name=\"VALUE\"/>\n"
" <return-column name=\"CURRENCY\"/>\n"
" </return-property>\n"
" </return>\n"
" { ? = call selectAllEmployments() }\n"
"</sql-query>"
msgstr ""
"<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
" <return alias=\"emp\" class=\"Employment\">\n"
" <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
" <return-property name=\"employer\" column=\"EMPLOYER\"/>\n"
" <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
" <return-property name=\"endDate\" column=\"ENDDATE\"/>\n"
" <return-property name=\"regionCode\" column=\"REGIONCODE\"/>\n"
" <return-property name=\"id\" column=\"EID\"/>\n"
" <return-property name=\"salary\">\n"
" <return-column name=\"VALUE\"/>\n"
" <return-column name=\"CURRENCY\"/>\n"
" </return-property>\n"
" </return>\n"
" { ? = call selectAllEmployments() }\n"
"</sql-query>"
#. Tag: para
#: query_sql.xml:578
#, fuzzy, no-c-format
msgid ""
"Stored procedures currently only return scalars and entities. <literal><"
"return-join></literal> and <load-collection> are "
"not supported."
msgstr ""
"Bitte beachten Sie, dass gespeicherte Prozeduren gegenwärtig nur Skalare und "
"Entities wiedergeben. <literal><return-join> und "
"<literal><load-collection> werden nicht unterstützt."
#. Tag: title
#: query_sql.xml:583
#, no-c-format
msgid "Rules/limitations for using stored procedures"
msgstr "Regeln/Einschränkungen bei der Verwendung gespeicherter Prozeduren"
#. Tag: para
#: query_sql.xml:585
#, fuzzy, no-c-format
msgid ""
"You cannot use stored procedures with Hibernate unless you follow some "
"procedure/function rules. If they do not follow those rules they are not "
"usable with Hibernate. If you still want to use these procedures you have to "
"execute them via <literal>session.connection(). The rules are "
"different for each database, since database vendors have different stored "
"procedure semantics/syntax."
msgstr ""
"Um gespeicherte Prozeduren mit Hibernate zu verwenden, müssen die Prozeduren/"
"Funktionen einigen Regeln folgen. Falls sie diese nicht berücksichtigen, "
"können sie nicht mit Hibernate verwendet werden. Falls Sie diese Prozeduren "
"dennoch benutzen wollen, so müssen Sie sie mittels <literal>session."
"connection()</literal> ausführen. Die Regeln sind für jede Datenbank anders, "
"da Datenbankanbieter jeweils über verschiedene gespeicherte Semantik/Syntax "
"für Prozeduren verfügen."
#. Tag: para
#: query_sql.xml:593
#, fuzzy, no-c-format
msgid ""
"Stored procedure queries cannot be paged with <literal>setFirstResult()/"
"setMaxResults()</literal>."
msgstr ""
"Gespeicherte Prozeduren können nicht mit <literal>setFirstResult()/"
"setMaxResults()</literal> seitenweise umgespeichert werden."
#. Tag: para
#: query_sql.xml:596
#, fuzzy, no-c-format
msgid ""
"The recommended call form is standard SQL92: <literal>{ ? = call functionName"
"(<parameters>) }</literal> or { ? = call procedureName(<"
"parameters>}</literal>. Native call syntax is not supported."
msgstr ""
"Die empfohlen Form für den Aufruf ist Standard SQL92: <literal>{ ? = call "
"functionName (<parameters>) }</literal> oder { ? = call "
"procedureName(<parameters>}</literal>. Native Aufrufsyntax wird nicht "
"unterstützt."
#. Tag: para
#: query_sql.xml:601
#, no-c-format
msgid "For Oracle the following rules apply:"
msgstr "Für Oracle gelten die folgenden Regeln:"
#. Tag: para
#: query_sql.xml:605
#, fuzzy, no-c-format
msgid ""
"A function must return a result set. The first parameter of a procedure must "
"be an <literal>OUT that returns a result set. This is done by "
"using a <literal>SYS_REFCURSOR type in Oracle 9 or 10. In Oracle "
"you need to define a <literal>REF CURSOR type. See Oracle "
"literature for further information."
msgstr ""
"Eine Funktion muss mit einem Ergebnissatz (\"result set\") reagieren. Der "
"erste Parameter einer Prozedur muss ein <literal>OUT sein, das "
"einen Satz von Ergenissen liefert. Dies geschieht unter Verwendung eines "
"<literal>SYS_REFCURSOR-Typs in Oracle 9 oder 10. In Oracle müssen "
"Sie einen <literal>REF CURSOR-Typ definieren, siehe auch in "
"Literatur zu Oracle."
#. Tag: para
#: query_sql.xml:614
#, no-c-format
msgid "For Sybase or MS SQL server the following rules apply:"
msgstr "Für Sybase oder MS SQL Server gelten die folgenden Regeln:"
#. Tag: para
#: query_sql.xml:618
#, fuzzy, no-c-format
msgid ""
"The procedure must return a result set. Note that since these servers can "
"return multiple result sets and update counts, Hibernate will iterate the "
"results and take the first result that is a result set as its return value. "
"Everything else will be discarded."
msgstr ""
"Eine Prozedur muss mit einem Ergebnissatz (\"result set\") reagieren. Bitte "
"beachten Sie, dass - da diese Server mit mehreren Ergebnissätzen reagieren "
"können/werden und Zählungen aktualisieren - Hibernate die Ergebnisse "
"wiederholt und das erste Ergebnis als Wiedergabewert nimmt, das einen "
"Ergebnissatz darstellt. Alles andere wird verworfen."
#. Tag: para
#: query_sql.xml:626
#, no-c-format
msgid ""
"If you can enable <literal>SET NOCOUNT ON in your procedure it "
"will probably be more efficient, but this is not a requirement."
msgstr ""
"Falls Sie <literal>SET NOCOUNT ON in Ihrer Prozedur aktivieren "
"können, so würde sie wahrscheinlich effizienter. Dies ist jedoch keine "
"Voraussetzung."
#. Tag: title
#: query_sql.xml:636
#, no-c-format
msgid "Custom SQL for create, update and delete"
msgstr ""
"Anwenderspezifische SQL für \"create\" (erstellen), \"update"
"\" (aktualisieren) und \"delete\" (löschen)"
#. Tag: para
#: query_sql.xml:638
#, no-c-format
msgid ""
"Hibernate3 can use custom SQL for create, update, and delete operations. The "
"SQL can be overridden at the statement level or inidividual column level. "
"This section describes statement overrides. For columns, see <xref linkend="
"\"mapping-column-read-and-write\"/>. <xref linkend=\"example-custom-crdu-via-"
"annotations\"/> shows how to define custom SQL operatons using annotations."
msgstr ""
#. Tag: title
#: query_sql.xml:646
#, no-c-format
msgid "Custom CRUD via annotations"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:648
#, no-c-format
msgid ""
"@Entity\n"
"@Table(name=\"CHAOS\")\n"
"@SQLInsert( sql=\"INSERT INTO CHAOS(size, name, nickname, id) VALUES(?,upper"
"(?),?,?)\")\n"
"@SQLUpdate( sql=\"UPDATE CHAOS SET size = ?, name = upper(?), nickname = ? "
"WHERE id = ?\")\n"
"@SQLDelete( sql=\"DELETE CHAOS WHERE id = ?\")\n"
"@SQLDeleteAll( sql=\"DELETE CHAOS\")\n"
"@Loader(namedQuery = \"chaos\")\n"
"@NamedNativeQuery(name=\"chaos\", query=\"select id, size, name, lower"
"( nickname ) as nickname from CHAOS where id= ?\", resultClass = Chaos."
"class)\n"
"public class Chaos {\n"
" @Id\n"
" private Long id;\n"
" private Long size;\n"
" private String name;\n"
" private String nickname;"
msgstr ""
#. Tag: para
#: query_sql.xml:651
#, no-c-format
msgid ""
"<literal>@SQLInsert, @SQLUpdate, "
"<literal>@SQLDelete, @SQLDeleteAll respectively "
"override the INSERT, UPDATE, DELETE, and DELETE all statement. The same can "
"be achieved using Hibernate mapping files and the <literal><sql-insert>"
"</literal>, <sql-update> and <sql-"
"delete></literal> nodes. This can be seen in attribute to true. In "
"annotations as well as in xml."
msgstr ""
#. Tag: para
#: query_sql.xml:670
#, no-c-format
msgid ""
"To check that the execution happens correctly, Hibernate allows you to "
"define one of those three strategies:"
msgstr ""
#. Tag: para
#: query_sql.xml:675
#, no-c-format
msgid ""
"none: no check is performed: the store procedure is expected to fail upon "
"issues"
msgstr ""
#. Tag: para
#: query_sql.xml:680
#, no-c-format
msgid "count: use of rowcount to check that the update is successful"
msgstr ""
#. Tag: para
#: query_sql.xml:685
#, no-c-format
msgid ""
"param: like COUNT but using an output parameter rather that the standard "
"mechanism"
msgstr ""
#. Tag: para
#: query_sql.xml:690
#, no-c-format
msgid ""
"To define the result check style, use the <literal>check parameter "
"which is again available in annoations as well as in xml."
msgstr ""
#. Tag: para
#: query_sql.xml:693
#, no-c-format
msgid ""
"You can use the exact same set of annotations respectively xml nodes to "
"override the collection related statements -see <xref linkend=\"example-"
"overriding-sql-collections-annotations\"/>."
msgstr ""
#. Tag: title
#: query_sql.xml:698
#, no-c-format
msgid "Overriding SQL statements for collections using annotations"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:701
#, no-c-format
msgid ""
"@OneToMany\n"
"@JoinColumn(name=\"chaos_fk\")\n"
"@SQLInsert( sql=\"UPDATE CASIMIR_PARTICULE SET chaos_fk = ? where id = ?\")\n"
"@SQLDelete( sql=\"UPDATE CASIMIR_PARTICULE SET chaos_fk = null where id = ?"
"\")\n"
"private Set<CasimirParticle> particles = new HashSet<"
"CasimirParticle>();"
msgstr ""
#. Tag: para
#: query_sql.xml:705
#, fuzzy, no-c-format
msgid ""
"The parameter order is important and is defined by the order Hibernate "
"handles properties. You can see the expected order by enabling debug logging "
"for the <literal>org.hibernate.persister.entity level. With this "
"level enabled Hibernate will print out the static SQL that is used to "
"create, update, delete etc. entities. (To see the expected sequence, "
"remember to not include your custom SQL through annotations or mapping files "
"as that will override the Hibernate generated static sql)"
msgstr ""
"Sie können die erwartete Reihenfolge sehen, indem Sie Debug-Protokollierung "
"für die<literal>org.hibernate.persister.entity-Ebene aktivieren. "
"Wenn diese Ebene aktiviert ist, druckt Hibernate die statische SQL aus, die "
"zur Erstellung, Aktualisierung, Löschung usw. von Entities verwendet wird. "
"(Um die erwartete Sequenz zu sehen, denken Sie daran, Ihre angepasste SQL "
"nicht in die Mapping-Dateien einzuschließen, da diese die durch Hibernate "
"generierte statische sql außer Kraft setzt)."
#. Tag: para
#: query_sql.xml:715
#, no-c-format
msgid ""
"Overriding SQL statements for secondary tables is also possible using "
"<literal>@org.hibernate.annotations.Table and either (or all) "
"attributes <literal>sqlInsert, sqlUpdate, "
"<literal>sqlDelete:"
msgstr ""
#. Tag: title
#: query_sql.xml:721
#, no-c-format
msgid "Overriding SQL statements for secondary tables"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:723
#, no-c-format
msgid ""
"@Entity\n"
"@SecondaryTables({\n"
" @SecondaryTable(name = \"`Cat nbr1`\"),\n"
" @SecondaryTable(name = \"Cat2\"})\n"
"@org.hibernate.annotations.Tables( {\n"
" @Table(appliesTo = \"Cat\", comment = \"My cat table\" ),\n"
" @Table(appliesTo = \"Cat2\", foreignKey = @ForeignKey(name=\"FK_CAT2_CAT"
"\"), fetch = FetchMode.SELECT,\n"
" sqlInsert=@SQLInsert(sql=\"insert into Cat2(storyPart2, id) values"
"(upper(?), ?)\") )\n"
"} )\n"
"public class Cat implements Serializable {"
msgstr ""
#. Tag: para
#: query_sql.xml:726
#, no-c-format
msgid ""
"The previous example also shows that you can give a comment to a given table "
"(primary or secondary): This comment will be used for DDL generation."
msgstr ""
#. Tag: para
#: query_sql.xml:731
#, fuzzy, no-c-format
msgid ""
"The SQL is directly executed in your database, so you can use any dialect "
"you like. This will, however, reduce the portability of your mapping if you "
"use database specific SQL."
msgstr ""
"Die SQL wird direkt in Ihrer Datenbank ausgeführt, Sie können daher jeden "
"beliebigen Dialekt verwenden. Dies wird natürlich die Übertragbarkeit Ihres "
"Mappings reduzieren, wenn Sie Datenbank-spezifische SQL benutzen."
#. Tag: para
#: query_sql.xml:736
#, fuzzy, no-c-format
msgid ""
"Last but not least, stored procedures are in most cases required to return "
"the number of rows inserted, updated and deleted. Hibernate always registers "
"the first statement parameter as a numeric output parameter for the CUD "
"operations:"
msgstr ""
"Die gespeicherten Prozeduren sind in den meisten Fällen (bzw. fast immer) "
"für die Wiedergabe der Anzahl von eingefügten/aktualisierten/gelöschten "
"Reihen erforderlich, da Hibernate einige Runtime-Überprüfungen hinsichtlich "
"des Erfolgs der Anweisung durchführt. Hibernate registriert immer den ersten "
"Anweisungsparameter als numerischen Ausgabeparameter für die CUD-Vorgänge:"
#. Tag: title
#: query_sql.xml:742
#, no-c-format
msgid "Stored procedures and their return value"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:744
#, fuzzy, no-c-format
msgid ""
"CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
" RETURN NUMBER IS\n"
"BEGIN\n"
"\n"
" update PERSON\n"
" set\n"
" NAME = uname,\n"
" where\n"
" ID = uid;\n"
"\n"
" return SQL%ROWCOUNT;\n"
"\n"
"END updatePerson;"
msgstr ""
"CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
" RETURN NUMBER IS\n"
"BEGIN\n"
"\n"
" update PERSON\n"
" set\n"
" NAME = uname,\n"
" where\n"
" ID = uid;\n"
"\n"
" return SQL%ROWCOUNT;\n"
"\n"
"END updatePerson;"
#. Tag: title
#: query_sql.xml:749
#, no-c-format
msgid "Custom SQL for loading"
msgstr "Angepasste SQL für das Laden"
#. Tag: para
#: query_sql.xml:751
#, no-c-format
msgid ""
"You can also declare your own SQL (or HQL) queries for entity loading. As "
"with inserts, updates, and deletes, this can be done at the individual "
"column level as described in <xref linkend=\"mapping-column-read-and-write\"/"
"> or at the statement level. Here is an example of a statement level "
"override:"
msgstr ""
#. Tag: programlisting
#: query_sql.xml:757
#, fuzzy, no-c-format
msgid ""
"<sql-query name=\"person\">\n"
" <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
" SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
" FROM PERSON\n"
" WHERE ID=?\n"
" FOR UPDATE\n"
"</sql-query>"
msgstr ""
"<sql-query name=\"person\">\n"
" <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
" SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
" FROM PERSON\n"
" WHERE ID=?\n"
" FOR UPDATE\n"
"</sql-query>"
#. Tag: para
#: query_sql.xml:759
#, fuzzy, no-c-format
msgid ""
"This is just a named query declaration, as discussed earlier. You can "
"reference this named query in a class mapping:"
msgstr ""
"Hier handelt es sich lediglich um eine Anfragendeklaration, wie zuvor "
"erläutert. Sie können auf diese benannte Anfrage in einem Klassen-Mapping "
"verweisen:"
#. Tag: programlisting
#: query_sql.xml:762
#, fuzzy, no-c-format
msgid ""
"<class name=\"Person\">\n"
" <id name=\"id\">\n"
" <generator class=\"increment\"/>\n"
" </id>\n"
" <property name=\"name\" not-null=\"true\"/>\n"
" <loader query-ref=\"person\"/>\n"
"</class>"
msgstr ""
"<class name=\"Person\">\n"
" <id name=\"id\">\n"
" <generator class=\"increment\"/>\n"
" </id>\n"
" <property name=\"name\" not-null=\"true\"/>\n"
" <loader query-ref=\"person\"/>\n"
"</class>"
#. Tag: para
#: query_sql.xml:764
#, no-c-format
msgid "This even works with stored procedures."
msgstr "Das funktioniert sogar mit gespeicherten Prozeduren."
#. Tag: para
#: query_sql.xml:766
#, fuzzy, no-c-format
msgid "You can even define a query for collection loading:"
msgstr ""
"Sie können sogar eine Anfrage für das Laden von Collections definieren:"
#. Tag: programlisting
#: query_sql.xml:768
#, fuzzy, no-c-format
msgid ""
"<set name=\"employments\" inverse=\"true\">\n"
" <key/>\n"
" <one-to-many class=\"Employment\"/>\n"
" <loader query-ref=\"employments\"/>\n"
"</set>"
msgstr ""
"<set name=\"employments\" inverse=\"true\">\n"
" <key/>\n"
" <one-to-many class=\"Employment\"/>\n"
" <loader query-ref=\"employments\"/>\n"
"</set>"
#. Tag: programlisting
#: query_sql.xml:770
#, fuzzy, no-c-format
msgid ""
"<sql-query name=\"employments\">\n"
" <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
" SELECT {emp.*}\n"
" FROM EMPLOYMENT emp\n"
" WHERE EMPLOYER = :id\n"
" ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
"</sql-query>"
msgstr ""
"<sql-query name=\"employments\">\n"
" <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
" SELECT {emp.*}\n"
" FROM EMPLOYMENT emp\n"
" WHERE EMPLOYER = :id\n"
" ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
"</sql-query>"
#. Tag: para
#: query_sql.xml:772
#, fuzzy, no-c-format
msgid ""
"You can also define an entity loader that loads a collection by join "
"fetching:"
msgstr ""
"Sie könnten sogar einen Entity-Loader definieren, der eine Collection "
"mittels \"Join-Fetching\" lädt:"
#. Tag: programlisting
#: query_sql.xml:775
#, fuzzy, no-c-format
msgid ""
"<sql-query name=\"person\">\n"
" <return alias=\"pers\" class=\"Person\"/>\n"
" <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
" SELECT NAME AS {pers.*}, {emp.*}\n"
" FROM PERSON pers\n"
" LEFT OUTER JOIN EMPLOYMENT emp\n"
" ON pers.ID = emp.PERSON_ID\n"
" WHERE ID=?\n"
"</sql-query>"
msgstr ""
"<sql-query name=\"person\">\n"
" <return alias=\"pers\" class=\"Person\"/>\n"
" <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
" SELECT NAME AS {pers.*}, {emp.*}\n"
" FROM PERSON pers\n"
" LEFT OUTER JOIN EMPLOYMENT emp\n"
" ON pers.ID = emp.PERSON_ID\n"
" WHERE ID=?\n"
"</sql-query>"
#. Tag: para
#: query_sql.xml:777
#, no-c-format
msgid ""
"The annotation equivalent <literal><loader> is the @Loader "
"annotation as seen in <xref linkend=\"example-custom-crdu-via-annotations\"/"
">."
msgstr ""
#, fuzzy
#~ msgid "<literal>A_NAME as {item.name}"
#~ msgstr "oder als eine <literal>List,"
#, fuzzy
#~ msgid "<literal>{[aliasname].class}"
#~ msgstr "oder als eine <literal>List,"
#, fuzzy
#~ msgid "<literal>DISC as {item.class}"
#~ msgstr "oder als eine <literal>List,"
#, fuzzy
#~ msgid "<literal>{[aliasname].*}"
#~ msgstr "oder als eine <literal>List,"
#, fuzzy
#~ msgid "<literal>{item.*}"
#~ msgstr "oder als eine <literal>List,"
#, fuzzy
#~ msgid "<literal>{[aliasname].key}"
#~ msgstr "oder als eine <literal>List,"
#, fuzzy
#~ msgid "<literal>ORGID as {coll.key}"
#~ msgstr "oder als eine <literal>List,"
#, fuzzy
#~ msgid "<literal>{[aliasname].id}"
#~ msgstr "oder als eine <literal>List,"
#, fuzzy
#~ msgid "<literal>EMPID as {coll.id}"
#~ msgstr "oder als eine <literal>List,"
#, fuzzy
#~ msgid "<literal>{[aliasname].element}"
#~ msgstr "{coll.element.*}"
#, fuzzy
#~ msgid "<literal>XID as {coll.element}"
#~ msgstr "{coll.element.*}"
#, fuzzy
#~ msgid "<literal>NAME as {coll.element.name}"
#~ msgstr "{coll.element.*}"
#, fuzzy
#~ msgid "<literal>{[aliasname].element.*}"
#~ msgstr "{coll.element.*}"
#, fuzzy
#~ msgid "<literal>{coll.element.*}"
#~ msgstr "{coll.element.*}"
#, fuzzy
#~ msgid "<literal>{coll.*}"
#~ msgstr "oder als eine <literal>List,"
#, fuzzy
#~ msgid ""
#~ "The class and collection persisters in Hibernate already contain a set of "
#~ "configuration time generated strings (insertsql, deletesql, updatesql "
#~ "etc.). The mapping tags <literal><sql-insert>, "
#~ "<literal><sql-delete>, and <sql-update>, <sql-delete><sql-update> setzen diese Strings "
#~ "außer Kraft:"
#~ msgid ""
#~ "Stored procedures are supported if the <literal>callable "
#~ "attribute is set:"
#~ msgstr ""
#~ "Gespeicherte Prozeduren werden unterstützt, wenn das <literal>callable"
#~ msgstr ""
#~ "<class name=\"Person\">\n"
#~ " <id name=\"id\">\n"
#~ " <generator class=\"increment\"/>\n"
#~ " </id>\n"
#~ " <property name=\"name\" not-null=\"true\"/>\n"
#~ " <sql-insert callable=\"true\">{call createPerson (?, ?)}</"
#~ "sql-insert>\n"
#~ " <sql-delete callable=\"true\">{? = call deletePerson (?)}</"
#~ "sql-delete>\n"
#~ " <sql-update callable=\"true\">{? = call updatePerson (?, ?)}"
#~ "</sql-update>\n"
#~ "</class>"
Other Hibernate examples (source code examples)
Here is a short list of links related to this Hibernate query_sql.po source code file:
|
The search page
Other Hibernate source code examples at this package level
Click here to learn more about this project
