[jboss-cvs] JBossAS SVN: r96694 - projects/docs/enterprise/5.0/Hibernate/Hibernate_Annotations_Reference_Guide/es-ES.

[jboss-cvs-commits at lists.jboss.org]

Author: agarcia at jboss.com
Date: 2009-11-22 23:22:17 -0500 (Sun, 22 Nov 2009)
New Revision: 96694

Modified:
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Annotations_Reference_Guide/es-ES/entity.po
Log:
lundi

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Annotations_Reference_Guide/es-ES/entity.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Annotations_Reference_Guide/es-ES/entity.po	2009-11-23 01:38:00 UTC (rev 96693)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Annotations_Reference_Guide/es-ES/entity.po	2009-11-23 04:22:17 UTC (rev 96694)
@@ -10,7 +10,7 @@
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Last-Translator: Angela Garcia <agarcia at redhat.com>\n"
-"PO-Revision-Date: 2009-11-20 16:51+1000\n"
+"PO-Revision-Date: 2009-11-23 14:21+1000\n"
 "Project-Id-Version: entity\n"
 "Language-Team:  <en at li.org>\n"
 "X-Generator: KBabel 1.11.4\n"
@@ -1479,6 +1479,8 @@
 "literal> queries. It is commonly used for the top level of an inheritance "
 "hierarchy:"
 msgstr ""
+"Esta estrategia tiene muchos inconvenientes (especialmente con peticiones polimórficas y asociaciones) que se abordan en la especificación EJB3, la documentación de referencia de Hibernate, Hibernate en acción y muchos otros lugares. Hibernate funciona con la mayoría de ellos implementando esta estrategia usando peticiones <literal>SQL UNION</"
+"literal>. Se utiliza usualmente para el nivel superir de una jerarquía de herencias:"
 
 #. Tag: programlisting
 #: entity.xml:622
@@ -1502,6 +1504,9 @@
 "Consequently, when using this strategy, you should not use <literal>AUTO </"
 "literal>nor <literal>IDENTITY</literal>."
 msgstr ""
+"Esta estrategia soporta asociaciones uno a muchos dado que sean bidireccionales. Esta estrategia no soporta la estrategia del generador <literal>IDENTITY</"
+"literal>: el id se tiene que compartir entre varias tablas. Por lo tanto, al usar esta estrategia, no use <literal>AUTO </"
+"literal>ni <literal>IDENTITY</literal>."
 
 #. Tag: title
 #: entity.xml:633
@@ -1646,7 +1651,7 @@
 "business superclass without including it as a regular mapped entity (ie no "
 "specific table for this entity). For that purpose you can map them as "
 "<literal>@MappedSuperclass</literal>."
-msgstr ""
+msgstr "A veces es útil el compartir propiedades comunes por medio de una superclase empresarial o técnica sin incluirla como una entidad mapeada regular (es decir, ninguna tabla especifica para esta entidad). Con ese fin puede mapearlas como <literal>@MappedSuperclass</literal>."
 
 #. Tag: programlisting
 #: entity.xml:686
@@ -1690,6 +1695,9 @@
 "property mappings are copied into their entity subclasses. Remember that the "
 "embeddable superclass is not the root of the hierarchy though."
 msgstr ""
+"En la base de datos, esta jerarquía se representará como una tabla <literal>Order</"
+"literal> que tiene las columnas <literal>id</literal>, <literal>lastUpdate</"
+"literal> y <literal>lastUpdater</literal>. Los mapeos de propiedades superclase incluídos se copian en sus subclases de entidad. Recuerde que la superclase incluída no es la raíz de la jerarquía."
 
 #. Tag: para
 #: entity.xml:696
@@ -1994,6 +2002,10 @@
 "literal>. As you can see, you don't have to (must not) declare the join "
 "column since it has already been declared on the owners side."
 msgstr ""
+"La asociación puede sre bidireccional. En una relación bidireccional, uno de los lados (y solo uno) tiene que ser el propietario: el propietario es el responsable por la actualización de la(s) columna(s) de asociación. Para declarar un lado como <emphasis>no</"
+"emphasis> responsable por la relación, se utiliza el atributo <literal>mappedBy</"
+"literal>. <literal>mappedBy</literal> se refiere al nombre de la propiedad de la asociación en el lado del propietario. En nuestro caso, este es <literal>passport</"
+"literal>. Como lo puede ver, no tiene que declarar la columna de unión ya que ya se ha declarado del lado del propietario."
 
 #. Tag: para
 #: entity.xml:803
@@ -2007,6 +2019,8 @@
 "because the property name is <literal>passport</literal> and the column id "
 "of <literal>Passport </literal>is <literal>id</literal>."
 msgstr ""
+"Si no se declara una <literal>@JoinColumn</literal> en el lado del propietario, entonces los valores predeterminados aplican. Se creará(n) una(s) columna(s) de unión en la tabla propietaria y su nombre será la concatenación del nombre de la relación del lado del propietario, <keycap>_</keycap> (guión abajo) y el nombre de la columna de la clave principal en el otro lado. En este ejemplo <literal>passport_id</literal> "
+"ya que el nombre de la propiedad es <literal>passport</literal> y el id de columna de <literal>Passport </literal> es <literal>id</literal>."
 
 #. Tag: para
 #: entity.xml:812
@@ -2132,6 +2146,8 @@
 "literal> because the property name is <literal>company</literal> and the "
 "column id of Company is <literal>id</literal>."
 msgstr ""
+"El atributo <literal>@JoinColumn</literal> es opcional, el valor predeterminado es como en uno a uno, la concatenación del nombre de la relación en el lado del propietario, <keycap>_</keycap> (guión abajo) y el nombre de la columna de la clave principal en el otro lado. En este ejemplo <literal>company_id</"
+"literal> ya que el nombre de la propiedad es <literal>company</literal> y el id de columna de Company es <literal>id</literal>."
 
 #. Tag: para
 #: entity.xml:847
@@ -2143,6 +2159,9 @@
 "association) is good in almost all cases. However this is useful when you "
 "want to use interfaces as the return type instead of the regular entity."
 msgstr ""
+"<literal>@ManyToOne</literal> tiene un parámetro llamado <literal>targetEntity</"
+"literal>, el cual describe el nombre de la entidad destino. Usualmente no necesita este parámetro ya que el valor predeterminado (the type of the property that stores the "
+"association) está bien en casi todos los casos. Sin embargo, esto es útil cuando quiere usar interfaces como tipo de retorno en lugar de la entidad regular."
 
 #. Tag: programlisting
 #: entity.xml:854
@@ -2189,6 +2208,8 @@
 "referencing the target entity table (through <literal>@JoinTable."
 "inverseJoinColumns</literal>)."
 msgstr ""
+"También puede mapear una asociación muchos a uno por medio de una tabla de asociaciones. Esta tabla de asociaciones descrita por la anotación <literal>@JoinTable</literal> contendrá una referencia de clave foránea a la tabla de entidades (por medio de <literal>@JoinTable.joinColumns</literal>) y una clave foránea referenciando la tabla de entidades destino (por medio de <literal>@JoinTable."
+"inverseJoinColumns</literal>)."
 
 #. Tag: programlisting
 #: entity.xml:864
@@ -2260,6 +2281,10 @@
 "<literal>@MapKey</literal> still has some limitations, please check the "
 "forum or the JIRA tracking system for more informations."
 msgstr ""
+"Puede mapear <classname>Collection</classname>, <literal>List</literal> (es decir listas ordenadas, no listas con índices), <literal>Map</literal> y <classname>Set</classname>. La especificación EJB3 describe la manera de mapear una lista ordenada (es decir una lista ordenada en tiempo de carga) usando la anotación <literal>@javax."
+"persistence.OrderBy</literal>: esta anotación toma como parámetro una lista de propiedades separadas por comas (entidad destino) para ordenar la colección (por ejemplo, <code>firstname asc, age desc</code>), si la cadena está vacía, la colección se ordenará por id. Para colecciones con índices verdaderas, consulte el <xref linkend=\"entity-hibspec\"/>. EJB3 le permite mapear Maps usando como clave una de las propiedades de entidad destino usando <literal>@MapKey(name=\"myProperty\")</literal> (myProperty es un nombre de una propiedad en la entidad destino). Al usar <literal>@MapKey</literal> (sin el nombre de la propiedad), se utiliza la clave principal de la entidad destino. La clave de mapeo usa la misma columna como la propiedad lo señaló: no hay una columna adicional definida para mantener la clave de mapeo y esto tiene sentido ya que la clave de mapeo de hecho representa una propiedad destino. Tenga en cuenta que una vez cargado, la clave ya no se mantiene e!
 n sincronización con la propiedad, en otras palabras, si cambia el valor de la propiedad, la clave no cambiará automáticamente en su modelo Java (para soporte de mapeo verdadero consulte <xref linkend=\"entity-hibspec\"/>). "
+"Muchas personas confunden las funcionalidades de <literal>&lt;map&gt;</literal> y las de <literal>@MapKey</literal>. Estas son dos funcionalidades diferentes. "
+"<literal>@MapKey</literal> todavía tiene algunas limitaciones, consulte el foro el sistema de rastreo JIRA para obtener mayor información."
 
 #. Tag: para
 #: entity.xml:902
@@ -2409,6 +2434,9 @@
 "@ManyToMany) and (nothing or @org.hibernate.annotations.MapKey/"
 "MapKeyManyToMany for true map support, OR @javax.persistence.MapKey"
 msgstr ""
+"(@org.hibernate.annotations.CollectionOfElements o @OneToMany o "
+"@ManyToMany) y (nada o @org.hibernate.annotations.MapKey/"
+"MapKeyManyToMany para soporte de mapeo verdadero o @javax.persistence.MapKey"
 
 #. Tag: remark
 #: entity.xml:978
@@ -2417,6 +2445,8 @@
 "So specifically, java.util.List collections without @org.hibernate."
 "annotations.IndexColumn are going to be considered as bags."
 msgstr ""
+"Así que especificamente, las colecciones java.util.List sin @org.hibernate."
+"annotations.IndexColumn se considerarán como bags."
 
 #. Tag: para
 #: entity.xml:982
@@ -2426,6 +2456,8 @@
 "the EJB3 specification. Hibernate Annotations allows them however (see <xref "
 "linkend=\"entity-hibspec\"/>)."
 msgstr ""
+"La especificación EJB3 no soporta la colección de objetos primitivos, de tipo central o incluído. Sin embargo, Hibernate Annotations los permite (consulte <xref "
+"linkend=\"entity-hibspec\"/>)."
 
 #. Tag: programlisting
 #: entity.xml:986
@@ -2525,6 +2557,10 @@
 "map of <literal>Version</literal>s which key is the <literal>Version</"
 "literal> <literal>codeName</literal>."
 msgstr ""
+"Así que <literal>City</literal> tiene una colección de <literal>Street</literal>s "
+"que están ordenas por <literal>streetName</literal> (de <literal>Street</"
+"literal>) cuando la colección se carga. <literal>Software</literal> tiene un mapa de <literal>Version</literal>es, cuya clave es la <literal>Version</"
+"literal> <literal>codeName</literal>."
 
 #. Tag: para
 #: entity.xml:995
@@ -2669,6 +2705,92 @@
 "literal> to <literal>Monkey</literal> (property name, <keycap>_</keycap>, "
 "Tiger primary column).</para> </sect5>"
 msgstr ""
+"<sect5> <title>Bidirectional</title> <para>Ya que muchos a uno son (casi) "
+"siempre el lado propietario de una relación bidireccional en la especificación EJB3, la asociación uno a muchos es anotada por <literal>@OneToMany( mappedBy=... )</"
+"literal></para> <programlisting>@Entity\n"
+"public class Troop {\n"
+"    @OneToMany(mappedBy=\"troop\")\n"
+"    public Set&lt;Soldier&gt; getSoldiers() {\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Soldier {\n"
+"    @ManyToOne\n"
+"    @JoinColumn(name=\"troop_fk\")\n"
+"    public Troop getTroop() {\n"
+"    ...\n"
+"}              </programlisting> <para><classname>Troop</classname> tiene una relación bidireccional uno a muchos con <literal>Soldier</literal> por medio de la propiedad <literal>troop</literal>. No tiene que "
+"definir ningún mapeo físico en el lado <literal>mappedBy</literal>.</para> "
+"<para>Para mapear una a muchos bidireccional, con el lado uno-a-muchos como el lado propietario, tiene que borrar el elemento <literal>mappedBy</literal> y configurar la <literal>@JoinColumn</literal> muchos a uno como insertable y actualizable como falso. Esta solución claramente no está optimizada y producirá algunas declaraciones  UPDATE adicionales.</para> <programlisting>@Entity\n"
+"public class Troop {\n"
+"    @OneToMany\n"
+"    @JoinColumn(name=\"troop_fk\") //necesitamos duplicar la información física\n"
+"    public Set&lt;Soldier&gt; getSoldiers() {\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Soldier {\n"
+"    @ManyToOne\n"
+"    @JoinColumn(name=\"troop_fk\", insertable=false, updatable=false)\n"
+"    public Troop getTroop() {\n"
+"    ...\n"
+"}</programlisting> </sect5> <sect5> <title>Unidirectional</title> <para>Una una a muchos unidireccional usando una columna de clave foránea en la entidad apropiada no es tan común y realmente no se recomienda. Le aconsejamos que use una tabla de unión para esta clase de asociación (como lo vamos a explicar en la siguiente sección). Esta clase de asociación se describe por medio de una <literal>@JoinColumn</"
+"literal></para> <programlisting>\n"
+"@Entity\n"
+"public class Customer implements Serializable {\n"
+"    @OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)\n"
+"    @JoinColumn(name=\"CUST_ID\")\n"
+"    public Set&lt;Ticket&gt; getTickets() {\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Ticket implements Serializable {\n"
+"    ... //no bidir\n"
+"}\n"
+"               </programlisting> <para><literal>Customer</literal> describe una relación unidireccional con <literal>Ticket</literal> usando la columna de unión <literal>CUST_ID</literal>.</para> </sect5> <sect5> "
+"<title>Unidireccional con tabla de unión</title> <para>Se prefiere una una a muchos unidireccional con tabla de unión. Esta asociación se describe por medio de un <literal>@JoinTable</literal>.</para> <programlisting>\n"
+"@Entity\n"
+"public class Trainer {\n"
+"    @OneToMany\n"
+"    @JoinTable(\n"
+"            name=\"TrainedMonkeys\",\n"
+"            joinColumns = @JoinColumn( name=\"trainer_id\"),\n"
+"            inverseJoinColumns = @JoinColumn( name=\"monkey_id\")\n"
+"    )\n"
+"    public Set&lt;Monkey&gt; getTrainedMonkeys() {\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Monkey {\n"
+"    ... //no bidir\n"
+"}\n"
+"               </programlisting> <para><literal>Trainer</literal> describe una relación unidireccional con <classname>Monkey</classname> usando la tabla de unión <classname>TrainedMonkeys</classname>, con una clave foránea <literal>trainer_id</literal> a <literal>Trainer</literal> "
+"(<literal>joinColumns</literal>) y una clave foránea <literal>monkey_id</"
+"literal> a <literal>Monkey</literal> (<literal>inversejoinColumns</"
+"literal>).</para> </sect5> <sect5 id=\"entity-mapping-association-collection-"
+"manytomany-default\" revision=\"1\"> <title>Predeterminados</title> <para>Sin describir ningun mapeo físico, se utiliza un uno a muchos unidireccional con tabla de unión. El nombre de la tabla es la concatenación del nombre de la tabla del propietario, "
+"<keycap>_</keycap>, y el nombre de la tabla del otro lado. Los nombres de la clave foránea que referencia la tabla propietaria es la concatenación de la tabla propietaria, "
+"<keycap>_</keycap>, y el nombre de la(s) columna(s) clave principal. El nombre de la clave foránea referenciando el otro lado es la concatenación del nombre de la propiedad del propietario, <keycap>_</keycap>, y el nombre de la(s) columna(s) de clave principal del otro lado. Se agrega una restricción única a la clave foránea que referencia el otro lado de la tabla para reflejar el uno a muchos.</para> <programlisting>\n"
+"@Entity\n"
+"public class Trainer {\n"
+"    @OneToMany\n"
+"    public Set&lt;Tiger&gt; getTrainedTigers() {\n"
+"    ...\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Tiger {\n"
+"    ... //no bidir\n"
+"}\n"
+"               </programlisting> <para><classname>Trainer</classname> "
+"describe una relación unidireccional con <classname>Tiger</classname> usando la tabla de unión <literal>Trainer_Tiger</literal>, con una clave foránea <literal>trainer_id</literal> a <literal>Trainer</literal> (nombre de la tabla, "
+"<keycap>_</keycap>, id de entrenador -trainer) y una clave foránea <literal>trainedTigers_id</"
+"literal> a <literal>Monkey</literal> (nombre de la propiedad, <keycap>_</keycap>, "
+"columna principal Tiger).</para> </sect5>"
 
 #. Tag: title
 #: entity.xml:1099
@@ -2782,6 +2904,76 @@
 "<literal>customers_id</literal> column is a foreign key to the "
 "<literal>Customer</literal> table.</para> </sect5>"
 msgstr ""
+"<sect5> <title>Definition</title> <para>Una asociación muchos a muchos se define lógicamente usando la anotación <literal>@ManyToMany</literal>. Tmabién tiene que describir la tabla de asociación y las condiciones de unión usando la anotación <literal>@JoinTable</literal>. Si la asociación es "
+"bidireccional, un lado tiene que ser el dueño y otro lado tiene que ser el inverso (es decir que será ignorado al actualizar los valores de la relación en la tabla de asociaciones):</para> <programlisting>\n"
+"@Entity\n"
+"public class Employer implements Serializable {\n"
+"    @ManyToMany(\n"
+"        targetEntity=org.hibernate.test.metadata.manytomany.Employee.class,\n"
+"        cascade={CascadeType.PERSIST, CascadeType.MERGE}\n"
+"    )\n"
+"    @JoinTable(\n"
+"        name=\"EMPLOYER_EMPLOYEE\",\n"
+"        joinColumns=@JoinColumn(name=\"EMPER_ID\"),\n"
+"        inverseJoinColumns=@JoinColumn(name=\"EMPEE_ID\")\n"
+"    )\n"
+"    public Collection getEmployees() {\n"
+"        return employees;\n"
+"    }\n"
+"    ...\n"
+"}\n"
+"               </programlisting> <programlisting>\n"
+"@Entity\n"
+"public class Employee implements Serializable {\n"
+"    @ManyToMany(\n"
+"        cascade = {CascadeType.PERSIST, CascadeType.MERGE},\n"
+"        mappedBy = \"employees\",\n"
+"        targetEntity = Employer.class\n"
+"    )\n"
+"    public Collection getEmployers() {\n"
+"        return employers;\n"
+"    }\n"
+"}\n"
+"               </programlisting> <para>Ya hemos mostrado las muchas declaraciones y los atributos detallados para las asociaciones. Vamos a profundizar en la descripción <literal>@JoinTable</literal>, define un "
+"<literal>name</literal>, un array de columnas de unión (un array en anotación se "
+"define usando { A, B, C }), y un array de columnas de unión inversas. Las últimas son las columnas de la tabla de asociación, las cuales se refieren a la clave principal <classname>Employee</classname> (el \"otro lado\").</para> "
+"<para>Como lo vimos anteriormente, el otro lado no tiene que describir el mapeo físico: un argumento <literal>mappedBy</literal> simple que contiene el nombre de la propiedad del lado del propietario enlaza a los dos.</para> </sect5> "
+"<sect5> <title>Valores predeterminados</title> <para>Como cualquier otra anotacións, la mayoría de los "
+"valores se advinan en una relación muchos a muchos. Sin describir ningun mapeo físico en un muchos a muchos unidireccional las siguientes reglas se aplican. El nombre de la tabla es la concatenación del nombre de la tabla propietaria, "
+"<keycap>_</keycap> y el nombre de la tabla del otro lado. Los nombres de la clave foránea referenciando la tabla propietaria es la concatenación del nombre de la tabla propietaria, "
+"<keycap>_</keycap> y las columnas de la clave principal propietaria. El nombre de la clave foránea referenciando el otro lado es la concatenación del nombre de la propiedad propietaria, <keycap>_</keycap>, y las columnas de la clave principal del otro lado. Estas son las mismas reglas que se utilizan para una relación unidireccional uno a muchos.</"
+"para> <programlisting>\n"
+"@Entity\n"
+"public class Store {\n"
+"    @ManyToMany(cascade = CascadeType.PERSIST)\n"
+"    public Set&lt;City&gt; getImplantedIn() {\n"
+"        ...\n"
+"    }\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class City {\n"
+"    ... //relación no bidireccional\n"
+"}\n"
+"               </programlisting> <para>Un <literal>Store_City</literal> se utiliza como la tabla de unión. La columna <literal>Store_id</literal> es una clave foránea a la tabla <literal>Store</literal>. La columna <literal>implantedIn_id</"
+"literal> es una clave foránea a la tabla <literal>City</literal>.</"
+"para> <para>Sin describir ningun mapeo físico en un muchos a muchos bidireccional las siguientes reglas aplican. El nombre de la tabla es la concatenación del nombre de la tabla del propietario, <keycap>_</keycap> y el nombre de la tabla del otro lado. El nombre de la clave foránea referenciando la tabla propietaria es la concatenación del nombre de la propiedad del otro lado, <keycap>_</keycap>, y las columnas de la clave principal propietaria. Los nombres de clave foránea referenciando el otro lado es la concatenación del nombre de la propiedad propietaria, <keycap>_</keycap>, y el otro lado de las columas de la clave principal. Estas son las mismas reglas utilizadas para una relación uno a muchos unidireccional.</para> <programlisting>\n"
+"@Entity\n"
+"public class Store {\n"
+"    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})\n"
+"    public Set&lt;Customer&gt; getCustomers() {\n"
+"        ...\n"
+"    }\n"
+"}\n"
+"\n"
+"@Entity\n"
+"public class Customer {\n"
+"    @ManyToMany(mappedBy=\"customers\")\n"
+"    public Set&lt;Store&gt; getStores() {\n"
+"        ...\n"
+"    }\n"
+"}\n"
+"               </programlisting> <para>Un <literal>Store_Customer</literal> se utiliza como la tabla de unión. La columna <literal>stores_id</literal> es una clave foránea a la tabla <literal>Store</literal>. La columna <literal>customers_id</literal> es una clave foránea a la tabla <literal>Customer</literal> table.</para> </sect5>"
 
 #. Tag: title
 #: entity.xml:1177
@@ -2799,6 +2991,8 @@
 "operations in Hibernate, but with slightly different semantics and cascading "
 "types:"
 msgstr ""
+"Probablemente habrá notado que el atributo <literal>cascade</literal> toma un "
+"array de <classname>CascadeType</classname> como valor. El concepto de cascada en EJB3 es muy similar a la persistencia transitiva y el uso de cascadas de las operaciones en Hibernate, pero con una semántica y tipos de cascadas un poco diferentes:"
 
 #. Tag: para
 #: entity.xml:1187
@@ -2806,7 +3000,7 @@
 msgid ""
 "CascadeType.PERSIST: cascades the persist (create) operation to associated "
 "entities persist() is called or if the entity is managed"
-msgstr ""
+msgstr "CascadeType.PERSIST: usa cascadas para la operación de persistencia (crear) a las entidades asociadas se llama a persist() o si la entidad es administrada"
 
 #. Tag: para
 #: entity.xml:1192
@@ -2814,7 +3008,7 @@
 msgid ""
 "CascadeType.MERGE: cascades the merge operation to associated entities if "
 "merge() is called or if the entity is managed"
-msgstr ""
+msgstr "CascadeType.MERGE: usa cascadas para la operación merge a las entidades asociadas si se llama a merge() o si la entidad es administrada"
 
 #. Tag: para
 #: entity.xml:1197
@@ -2822,7 +3016,7 @@
 msgid ""
 "CascadeType.REMOVE: cascades the remove operation to associated entities if "
 "delete() is called"
-msgstr ""
+msgstr "CascadeType.REMOVE: usa cascadas en la operación de eliminación a las entidades asociadas si se llama a delete()"
 
 #. Tag: para
 #: entity.xml:1202
@@ -2830,7 +3024,7 @@
 msgid ""
 "CascadeType.REFRESH: cascades the refresh operation to associated entities "
 "if refresh() is called"
-msgstr ""
+msgstr "CascadeType.REFRESH: usa cascadas para la operación de actualización a las entidades asociadas si se llama a refresh()"
 
 #. Tag: para
 #: entity.xml:1207