Colocar
Un conjunto de colecciones es una colección Java que no contiene ningún elemento duplicado. Más formalmente, SET no contiene ningún elemento en E1 y E2, de modo que E1.Equals (E2), y como máximo un elemento vacío. Por lo tanto, ser agregado a un conjunto de objetos debe implementar métodos iguales () y hashcode () para que Java pueda determinar si dos elementos/objetos son los mismos.
Los conjuntos se asignan a elementos <set> en la tabla de mapas y se inicializan en java.util.hashset. Puede usar colecciones establecidas para tener elementos en la colección que no necesitan repetirse al usar la clase.
Defina la tabla RDBMS:
Considere un caso en el que necesitamos que los registros de nuestros empleados se almacenen en la tabla de empleados, con la siguiente estructura:
Crear tabla empleado (id int no null auto_incement, first_name varchar (20) predeterminado NULL, last_name varchar (20) predeterminado nulo, salario int predeterminado nulo, clave primaria (id));
Además, se supone que cada empleado puede tener uno o más certificados relacionados con él/ella. Por lo tanto, almacenamos la información relevante del certificado en una tabla separada con la siguiente estructura:
Crear certificado de tabla (ID int no nulo auto_incement, certificate_name varchar (30) predeterminado nulo, empleado_id int predeterminado nulo, clave primaria (id));
Habrá una relación entre un empleado de muchos y un objeto de certificado:
Defina la clase POJO:
Implementemos que nuestro personal de clase POJO se utilizará para mantener una colección de objetos en la tabla de empleados y variables de conjunto acreditadas.
import java.util.*; empleado de clase pública {private int id; cadena privada FirstName; cadena privada lastname; salario privado int; certificados de conjunto privado; Public Employee () {} Public Employee (String fname, String lname, int salario) {this.firstname = fname; this.lastName = lname; this.salary = salario; } public int getId () {return id; } public void setid (int id) {this.id = id; } public String getFirstName () {return FirstName; } public void setFirstName (String First_Name) {this.firstname = first_name; } public String getLastName () {return LastName; } public void setLastName (string last_name) {this.lastName = last_name; } public int getSalary () {salario de retorno; } public void setSalary (int salario) {this.salary = salary; } Public set getCertificates () {return certificados; } public void setCertificates (establecer certificados) {this.certificates = certificados; }} Ahora definamos el certificado de otra clase de POJO correspondiente a la tabla, dicho objeto de certificado puede almacenar y recuperar la tabla de certificados. Esta clase también debe implementar los métodos Equals () y HashCode () al mismo tiempo, para que Java pueda determinar si dos elementos/objetos son los mismos.
Certificado de clase pública {private int id; nombre de cadena privada; Certificado público () {} Certificado público (nombre de cadena) {this.name = name; } public int getId () {return id; } public void setid (int id) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public boolean iguales (objeto obj) {if (obj == null) return false; if (! this.getClass (). Equals (obj.getClass ())) return false; Certificado obj2 = (certificado) obj; if ((this.id == obj2.getid ()) && (this.name.equals (obj2.getName ())) {return true; } return false; } public int hashcode () {int tmp = 0; tmp = (id + nombre) .hashcode (); return tmp; }} Definir el archivo de mapeo de hibernación:
Desarrolle un archivo de asignación que especifique cómo Hibernate define un archivo de asignación que se asigna a una tabla de base de datos. El elemento <set> se usará para definir las reglas utilizadas para establecer la colección.
<? xml versión = "1.0" encoding = "utf-8"?> <! DOCTYPE Hibernate-Mapping público "-// Hibernate/Hibernate Mapping dtd // en" "http://wwww.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <HiCercnate-mapping> <calse name = "empleado" table = "Empleado"> <meta attribute = "clase-descripción"> Esta clase contiene el detalle del empleado. </meta> <id name = "id" type = "int" column = "id"> <generador/> </id> <set name = "certificados" cascade = "all"> <key column = "empleado_id"/> <uno-to-many/> </set> <sperty name = "firstName" column = "first_name" type = "string"/> <propiedad de propiedad = "LastName" columna "columna" columna "columna" " type = "String"/> <Property Name = "Salario" Columna = "Salario" type = "int"/> </class> <class name = "certificado" table = "certificado"> <meta atribute = "-descripción de clases"> Esta clase contiene los registros de certificado. </meta> <id name = "id" type = "int" column = "id"> <generador/> </id> <propiedad name = "name" column = "certate_name" type = "string"/> </sclass> </ hibernate-mapping>
El formato <classname> .hbm.xml en el archivo de asignación que debe guardar. Guarde el archivo empleado.hbm.xml en el archivo de asignación. Ya está familiarizado con la mayoría de los detalles de mapeo, asignando todos los elementos en el archivo:
Un documento mapeado es un documento XML con <Hibernate-Mapping> como un elemento raíz correspondiente a cada clase que contiene 2 elementos <class>.
El elemento <class> se usa para definir una mapeo específica de la tabla de la base de datos de una clase Java. El nombre de la clase Java especifica el atributo de nombre del elemento de clase y el nombre de la base de datos de atributos de la tabla especifica el nombre de la tabla.
El elemento <seta> es un elemento opcional que se puede usar para crear una descripción de la clase.
El elemento <id> mapea el atributo de identificación único en la clase a la clave principal de la tabla de la base de datos. El atributo de nombre del elemento ID se refiere a la clase del atributo y el atributo de columna se refiere a las columnas en la tabla de la base de datos. El atributo de tipo guarda el tipo de mapeo de hibernación, que se convertirá de Java a tipo de datos SQL.
El elemento <Generator> dentro del elemento ID se usa para generar automáticamente el valor de clave principal. Establezca el atributo de clase del elemento generado en el original para dejar que Hibernate lo recoja, ya sea identidad, secuencia o algoritmo Hilo para crear claves primarias de acuerdo con las capacidades de soporte de la base de datos subyacente.
El elemento <Protey> se utiliza para mapear las propiedades de una clase Java a columnas en una tabla de base de datos. El atributo de nombre de un elemento se refiere a la clase del atributo y el atributo de columna se refiere a las columnas en la tabla de la base de datos. El atributo de tipo guarda el tipo de mapeo de hibernación, que se convertirá de Java a tipo de datos SQL.
El elemento <set> es nuevo y se ha introducido para establecer la relación entre el certificado y la clase de empleados. Usamos el elemento <Set> en el atributo Cascade para decirle a Hibernate que guarde el objeto Certificado y el objeto del empleado. El atributo de nombre se establece para establecer la variable en la definición en la clase principal, en nuestro caso es un certificado. Para cada conjunto de variables, necesitamos definir un conjunto separado de elementos en el archivo de mapeo.
El elemento <Key> es el objeto principal que contiene una clave externa, es decir, la columna en la tabla de certificados. Empleado de la tabla.
El elemento <One to-Many> indica que un objeto de empleado involucra muchos certificados y, por lo tanto, el objeto de certificado debe estar relacionado con el empleado principal. Puede usar cualquier elemento y <One to-One>, <nleing-to-One> o <nlegy-Many> según sea necesario.
Crear una clase de aplicación:
Finalmente, crearemos el método Main () de la clase de aplicación para ejecutar la aplicación. Usaremos esta aplicación para guardar algunos registros de empleados junto con las credenciales, y luego solicitaremos registros en la operación RUD.
import java.util.*; importar org.hibernate.HibernateException; importar org.hibernate.session; importar org.hibernate.transaction; import org.hibernate.sessionFactory; import org.hibernate.cfg.configuration; public class Managementee {private sessionfactory factory; public static void main (string [] args) {try {factory = new Configuration (). configure (). BuildSessionFactory (); } catch (showable EX) {System.err.println ("No se pudo crear el objeto SessionFactory." + EX); arrojar nuevos excepcionios de excepcionios (ex); } ManageMloyee ME = new ManageMloyee (); / * Tengamos un conjunto de certificados para el primer empleado */ hashset set1 = new Hashset (); set1.add (nuevo certificado ("mcA")); set1.add (nuevo certificado ("MBA")); set1.add (nuevo certificado ("MBA")); set1.Add (nuevo certificado ("PMP")); / * Agregar registros de empleados en la base de datos */ integer empid1 = me.addemployee ("manoj", "kumar", 4000, set1); / * Otro conjunto de certificados para el segundo empleado */ hashset set2 = new Hashset (); set2.Add (nuevo certificado ("BCA")); set2.Add (nuevo certificado ("BA")); / * Agregue otro registro de empleados en la base de datos */ Integer Empid2 = me.addemployee ("Dilip", "Kumar", 3000, set2); / * Enumere a todos los empleados */ me.listEmployee (); / * Actualizar los registros salariales del empleado */ me.updateeMployee (Empid1, 5000); / * Eliminar a un empleado de la base de datos */ me.deleteEmployee (Empid2); / * Enumere a todos los empleados */ me.listEmployee (); } / * Método para agregar un registro de empleado en la base de datos * / public Integer AddEmployee (String fName, String lname, int salario, set cert) {session session = factory.opensession (); Transacción tx = nulo; Integer EmployeeId = NULL; intente {tx = session.beGinTransaction (); Empleado empleado empleado = nuevo empleado (fname, lname, salario); empleado.setCertificates (cert); EmployeeId = (Integer) Session.save (Empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); } return EmployeeId; } / * Método para enumerar todos los detalles de los empleados * / public void listEmployees () {session session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Lista de empleados = session.createQuery ("del empleado"). List (); para (iterator iterator1 = empleado.iterator (); iterator1.hasnext ();) {empleado empleado = (empleado) iterator1.next (); System.out.print ("Nombre:" + Empleado.getFirstName ()); System.out.print ("apellido:" + empleado.getLastName ()); System.out.println ("Salario:" + Empleado.getSalary ()); Establecer certificados = empleado.getCertificates (); for (iterator iterator2 = certates.iterator (); iterator2.hasnext ();) {certificado certName = (certificado) iterator2.next (); System.out.println ("certificado:" + certname.getName ()); }} tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para actualizar el salario para un empleado * / public void UpdateEmployee (Integer EmployeeId, int salario) {sesión session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Empleado Empleado Empleado = (Empleado) Session.get (Employee.Class, EmployeeId); empleado. Setsalary (salario); sesión.update (empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para eliminar a un empleado de los registros * / public void DeleteEmployee (Integer EmployeeItId) {Session Session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Empleado Empleado Empleado = (Empleado) Session.get (Employee.Class, EmployeeId); session.delete (empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }}} Compilar y ejecutar:
Estos son los pasos para compilar y ejecutar la aplicación anterior. Asegúrese de que la ruta y la classpath se establezcan adecuadamente antes de compilar y ejecutar.
Los siguientes resultados se obtendrán en la pantalla y los registros se crearán en las tablas de empleados y certificados.
$ Java ManagementEmployee
.....VARIOUS LOG MESSAGES WILL DISPLAY HERE.........First Name: Manoj Last Name: Kumar Salary: 4000Certificate: MBACertificate: PMPCertificate: MCAFirst Name: Dilip Last Name: Kumar Salary: 3000Certificate: BCACertificate: BAFirst Name: Manoj Last Name: Kumar Salary: 5000Certificate: MBACertificate: PMPCertificate: MCA
Si verifica el formulario de empleado y certificado, debe registrarlo:
mysql> select * de empleado;
+----------------------------+----------+| ID | First_Name | Last_Name | Salario |+------------------------------------+------------+-----------+| 1 | Manoj | Kumar | 5000 |+--------------------------------+---------+1 fila en el set (0.00 segundos)
mysql> seleccionar * de certificado;
+----+------------------+-------------+| ID | certificado_name | Employee_id |+----+------------------+-------------+| 1 | MBA | 1 || 2 | PMP | 1 || 3 | MCA | 1 |+----+------------------+-------------+3 filas en el set (0.00 segundos)
mysql>
Mortero
SortedSet es una colección Java que no contiene ningún elemento y elemento duplicados que usan proporcionan su orden natural, o se clasifican mediante un comparador.
Un mapa SortedSet, inicializado en la tabla de mapeo <Set> Element y Java.util.treeset. El atributo de clasificación se puede establecer en un comparador o orden natural. Si se usa un orden natural, entonces su iterador atraviesa los elementos establecidos dispuestos en orden ascendente.
Todavía usamos la tabla RDBMS definida en el ejemplo anterior, y habrá una relación entre los objetos de múltiples empleados y certificados, y la clase POJO también se define anteriormente.
Implementemos que el empleado de la clase POJO se utilizará para mantener una colección de objetos en la tabla de empleados y una variable Certificada de SortedSet.
Ahora definamos el certificado para otra clase de POJO correspondiente a la tabla de certificados, dicho objeto de certificado puede almacenar y recuperar la tabla de certificados. Esta clase también debe implementar la interfaz comparable y el método Compareto se utilizará para establecer sort = "natural" en el caso de mapeo de archivos (consulte los archivos de mapa a continuación), los elementos se clasifican.
Certificado de clase pública implementa comparable <Certate> {private int id; nombre de cadena privada; Certificado público () {} Certificado público (nombre de cadena) {this.name = name; } public int getId () {return id; } public void setid (int id) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public int Compareto (certificado that) {final int antes = -1; Final int After = 1; if (that == null) {return antes; } Comparable thisCertificate = this.getName (); Comparable thatCertificate = that.getName (); if (thisCertificate == null) {return después; } else if (thatCertificate == null) {return antes; } else {return thisCertificate.compareto (thatCertificate); }}} Definir el archivo de mapeo de hibernación:
Desarrolle un archivo de asignación que especifique cómo Hibernate define un archivo de asignación que se asigna a una tabla de base de datos. El elemento <set> se usará para definir las reglas para la colección SortedSet utilizada.
<? xml versión = "1.0" encoding = "utf-8"?> <! DOCTYPE Hibernate-Mapping público "-// Hibernate/Hibernate Mapping dtd // en" "http://wwww.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <HiCercnate-mapping> <calse name = "empleado" table = "Empleado"> <meta attribute = "clase-descripción"> Esta clase contiene el detalle del empleado. </meta> <id name = "id" type = "int" columna = "id"> <generador/> </d> <set name = "certificados" cascade = "all" sort = "myclass"> <key column = "empleado_id"/> <One-to-Many/> </set> <name de propiedad = "Primera" columna "columna =" Primer_name "type =" String "/> <nombre de propiedad name" columna = "last_name" type = "String"/> <Property Name = "Salary" Column = "Salario" type = "int"/> </sclass> <class name = "certificado" table = "certificado"> <meta attribute = "-descripción de clases"> Esta clase contiene los registros de certificado. </meta> <id name = "id" type = "int" column = "id"> <generador/> </id> <propiedad name = "name" column = "certate_name" type = "string"/> </sclass> </ hibernate-mapping>
El formato <classname> .hbm.xml En el archivo de mapa, guarde el archivo empleado.hbm.xml en el archivo de mapa. Ya he estado familiarizado con la mayoría de los detalles de mapeo, pero veamos todos los elementos en el archivo de asignación:
Un documento mapeado es un documento XML con <Hibernate-Mapping> como un elemento raíz correspondiente a cada clase que contiene 2 elementos <class>.
El elemento <class> se usa para definir una mapeo específica de la tabla de la base de datos de una clase Java. El nombre de la clase Java especifica el atributo de nombre del elemento de clase y el nombre de la base de datos de atributos de la tabla especifica el nombre de la tabla.
El elemento <seta> es un elemento opcional que se puede usar para crear una descripción de la clase.
El elemento <id> mapea el atributo de identificación único en la clase a la clave principal de la tabla de la base de datos. El atributo de nombre del elemento ID se refiere a la clase del atributo y el atributo de columna se refiere a las columnas en la tabla de la base de datos. El atributo de tipo guarda el tipo de mapeo de hibernación, que se convertirá de Java a tipo de datos SQL.
El elemento <Generator> dentro del elemento ID se usa para generar automáticamente el valor de clave principal. Establezca el atributo de clase del elemento generado para que hibernate de forma nativa elija el algoritmo en identidad, secuencia o hilo para crear claves primarias de acuerdo con las capacidades de soporte de la base de datos subyacente.
El elemento <Protey> se utiliza para mapear las propiedades de una clase Java a columnas en una tabla de base de datos. El atributo de nombre de un elemento se refiere a la clase del atributo y el atributo de columna se refiere a las columnas en la tabla de la base de datos. El atributo de tipo guarda el tipo de mapeo de hibernación, que se convertirá de Java a tipo de datos SQL.
El elemento <set> se usa para establecer la relación entre el certificado y la clase de empleados. Usamos el elemento <Set> en el atributo Cascade para decirle a Hibernate que guarde el objeto Certificado y también al objeto del empleado. El atributo de nombre se establece en la variable del sortedset definido en la clase principal, en nuestro caso es un certificado. La propiedad de clasificación se puede configurar en clasificación natural, o se puede establecer en implementación de clase personalizada como java.util.comparator. Hemos utilizado una clase MyClass que lo implementa como Java.util.comparador para revertir el orden de clasificación de la implementación de la clase de certificado.
El elemento <Key> es el objeto principal que contiene una clave externa, es decir, la columna en la tabla de certificados. Empleado de la tabla.
El elemento <One-Many> indica que un objeto de empleado involucra muchos objetos de certificado y, por lo tanto, el objeto de certificado debe estar relacionado con el empleado principal. Puede usar cualquier elemento y <One to-One>, <nleing-to-One> o <nlegy-Many> según sea necesario.
Si usa la configuración Sort = "Natural", no necesita crear una clase separada, porque la clase de certificado ha implementado la interfaz comparable y Hibernate usará el Compareto (definido como el nombre del certificado de comparación en la clase de certificado). Sin embargo, estamos utilizando una clase de comparación personalizada MyClass en nuestro archivo de asignación, por lo que debemos crear esta clase basada en el algoritmo de clasificación. Use esta clase para ordenar en orden descendente.
import java.util.comparator; Public Class MyClass Implements Comparator <Certate> {public int Compare (Certificado O1, Certificado O2) {final int antes = -1; Final int After = 1; / * Para revertir el orden de clasificación, múltiple por -1 */ if (o2 == null) {return antes * -1; } Comparable thisCertificate = o1.getName (); Comparable thatCertificate = o2.getName (); if (thisCertificate == null) {return después * 1; } else if (thatCertificate == null) {return antes * -1; } else {return thisCertificate.compareto (thatCertificate) * -1; }}} Crear una clase de aplicación:
Finalmente, crearemos el método Main () de la clase de aplicación para ejecutar la aplicación. Utilizaremos esta aplicación para guardar algunos registros de empleados junto con el certificado, y luego solicitaremos registros en la operación RUD.
import java.util.*; importar org.hibernate.HibernateException; importar org.hibernate.session; importar org.hibernate.transaction; import org.hibernate.sessionFactory; import org.hibernate.cfg.configuration; public class Managementee {private sessionfactory factory; public static void main (string [] args) {try {factory = new Configuration (). configure (). BuildSessionFactory (); } catch (showable EX) {System.err.println ("No se pudo crear el objeto SessionFactory." + EX); arrojar nuevos excepcionios de excepcionios (ex); } ManageMloyee ME = new ManageMloyee (); / * Tengamos un conjunto de certificados para el primer empleado */ TreeSet set1 = new TreeSet (); set1.add (nuevo certificado ("mcA")); set1.add (nuevo certificado ("MBA")); set1.add (nuevo certificado ("MBA")); set1.Add (nuevo certificado ("PMP")); / * Agregar registros de empleados en la base de datos */ integer empid1 = me.addemployee ("manoj", "kumar", 4000, set1); / * Otro conjunto de certificados para el segundo empleado */ TreeSet set2 = new TreeSet (); set2.Add (nuevo certificado ("BCA")); set2.Add (nuevo certificado ("BA")); / * Agregue otro registro de empleados en la base de datos */ Integer Empid2 = me.addemployee ("Dilip", "Kumar", 3000, set2); / * Enumere a todos los empleados */ me.listEmployee (); / * Actualizar los registros salariales del empleado */ me.updateeMployee (Empid1, 5000); / * Eliminar a un empleado de la base de datos */ me.deleteEmployee (Empid2); / * Enumere a todos los empleados */ me.listEmployee (); } / * Método para agregar un registro de empleado en la base de datos * / public Integer AddEmployee (String fname, String lname, int salario, sortedset cert) {session session = factory.opensession (); Transacción tx = nulo; Integer EmployeeId = NULL; intente {tx = session.beGinTransaction (); Empleado empleado empleado = nuevo empleado (fname, lname, salario); empleado.setCertificates (cert); EmployeeId = (Integer) Session.save (Empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); } return EmployeeId; } / * Método para enumerar todos los detalles de los empleados * / public void listEmployees () {session session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Lista de empleados = session.createQuery ("del empleado"). List (); para (iterator iterator1 = empleado.iterator (); iterator1.hasnext ();) {empleado empleado = (empleado) iterator1.next (); System.out.print ("Nombre:" + Empleado.getFirstName ()); System.out.print ("apellido:" + empleado.getLastName ()); System.out.println ("Salario:" + Empleado.getSalary ()); Certificados SortedSet = Empleado.getCertificates (); for (iterator iterator2 = certates.iterator (); iterator2.hasnext ();) {certificado certName = (certificado) iterator2.next (); System.out.println ("certificado:" + certname.getName ()); }} tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para actualizar el salario para un empleado * / public void UpdateEmployee (Integer EmployeeId, int salario) {sesión session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Empleado Empleado Empleado = (Empleado) Session.get (Employee.Class, EmployeeId); empleado. Setsalary (salario); sesión.update (empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para eliminar a un empleado de los registros * / public void DeleteEmployee (Integer EmployeeItId) {Session Session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Empleado Empleado Empleado = (Empleado) Session.get (Employee.Class, EmployeeId); session.delete (empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }}}Después de compilar y ejecutar, los siguientes resultados se obtienen en la pantalla, y los registros se crean tanto en las tablas de empleados como de certificado. Puede ver que los certificados se han ordenado en el orden opuesto. Puede probarlo cambiando el archivo de mapeo, simplemente establezca sort = "natural" y ejecute el programa y compare los resultados.
$ Java ManagementEmployee
..... Varios mensajes de registro se mostrarán aquí ......... Nombre: Manoj Apellido: Kumar Salario: 4000Certificate: PMPCertificate: McAcertificate: MBAFIRST Nombre: Dilip Apellido: Kumar Salario: 3000Certificate: BCAcertificate: Bafirst Name: Manoj Apellido: Kumar Salario: 5000Certificate: McAcertificate: MBACERTITE: MACATIMA: MACA: MACA: MACA: KUMAR SALAR
Si verifica el formulario de empleado y certificado, debe registrarlo:
mysql> select * de empleado;
+----------------------------+----------+| ID | First_Name | Last_Name | Salario |+------------------------------------+------------+-----------+| 1 | Manoj | Kumar | 5000 |+--------------------------------+---------+1 fila en el set (0.00 segundos)
mysql> seleccionar * de certificado;
+----+------------------+-------------+| ID | certificado_name | Employee_id |+----+------------------+-------------+| 1 | MBA | 1 || 2 | PMP | 1 || 3 | MCA | 1 |+----+------------------+-------------+3 filas en el set (0.00 segundos)