激情久久久_欧美视频区_成人av免费_不卡视频一二三区_欧美精品在欧美一区二区少妇_欧美一区二区三区的

服務器之家：專注于服務器技術及軟件下載分享
分類導航

PHP教程|ASP.NET教程|JAVA教程|ASP教程|

香港云服务器
服務器之家 - 編程語言 - JAVA教程 - 詳解Java的Hibernat框架中的Map映射與SortedMap映射

詳解Java的Hibernat框架中的Map映射與SortedMap映射

2020-03-12 11:20goldensun JAVA教程

這篇文章主要介紹了Java的Hibernat框架中的Map映射與SortedMap映射,Hibernat是Java的SSH三大web開發框架之一,需要的朋友可以參考下

Map映射
Map映射是一個java集合存儲在鍵 - 值對的元素，并且不允許在列表中重復的元素。 Map接口提供三種collection視圖，允許Map內容看作是一組鍵-值集合，或者設置鍵 - 值映射關系。

Map被映射到映射表中一個<map>元素和無序的地圖可以在java.util.HashMap中被初始化。

定義RDBMS表：
考慮一個情況，我們需要員工記錄存儲在EMPLOYEE表，將有以下結構：

?
1
2
3
4
5
6
7
create table EMPLOYEE (
  id INT NOT NULL auto_increment,
  first_name VARCHAR(20) default NULL,
  last_name VARCHAR(20) default NULL,
  salary   INT default NULL,
  PRIMARY KEY (id)
);

此外，假設每個員工都可以有一個或多個與他/她相關的證書。我們將存儲證書的相關信息在一個單獨的表，該表具有以下結構：

?
1
2
3
4
5
6
7
create table CERTIFICATE (
  id INT NOT NULL auto_increment,
  certificate_type VARCHAR(40) default NULL,
  certificate_name VARCHAR(30) default NULL,
  employee_id INT default NULL,
  PRIMARY KEY (id)
);

有一個對多（one-to-many ）的關系在EMPLOYEE和證書對象之間。

定義POJO類：
讓我們實現一個POJO類員工將被用于保存與EMPLOYEE表中的對象和有證書的列表變量的集合。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import java.util.*;
 
public class Employee {
  private int id;
  private String firstName;
  private String lastName; 
  private int salary;
  private Map certificates;
 
  public Employee() {}
  public Employee(String fname, String lname, int salary) {
   this.firstName = fname;
   this.lastName = lname;
   this.salary = salary;
  }
  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() {
   return salary;
  }
  public void setSalary( int salary ) {
   this.salary = salary;
  }
 
  public Map getCertificates() {
   return certificates;
  }
  public void setCertificates( Map certificates ) {
   this.certificates = certificates;
  }
}

我們需要相應的證書表定義另一個POJO類，這樣的證書對象可以存儲和檢索到的證書表。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Certificate{
  private int id;
  private String name;
 
  public Certificate() {}
  public Certificate(String name) {
   this.name = name;
  }
  public int getId() {
   return id;
  }
  public void setId( int id ) {
   this.id = id;
  }
  public String getName() {
   return name;
  }
  public void setName( String name ) {
   this.name = name;
  }
}

定義Hibernate映射文件：
讓我們開發指示Hibernate如何定義的類映射到數據庫表的映射文件。<map>元素將被用于定義所使用的映射的規則。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD//EN"
 "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping>
  <class name="Employee" table="EMPLOYEE">
   <meta attribute="class-description">
     This class contains the employee detail.
   </meta>
   <id name="id" type="int" column="id">
     <generator class="native"/>
   </id>
   <map name="certificates" cascade="all">
     <key column="employee_id"/>
     <index column="certificate_type" type="string"/>
     <one-to-many class="Certificate"/>
   </map>
   <property name="firstName" column="first_name" type="string"/>
   <property name="lastName" column="last_name" type="string"/>
   <property name="salary" column="salary" type="int"/>
  </class>
 
  <class name="Certificate" table="CERTIFICATE">
   <meta attribute="class-description">
     This class contains the certificate records.
   </meta>
   <id name="id" type="int" column="id">
     <generator class="native"/>
   </id>
   <property name="name" column="certificate_name" type="string"/>
  </class>
 
</hibernate-mapping>

應該保存的映射文件中的格式<classname>.hbm.xml。我們保存映射文件中的文件Employee.hbm.xml。已經熟悉了大部分的映射細節，但讓我們再次看映射文件中的所有元素：

映射文檔是具有<hibernate-mapping>為對應于每一個類包含2個<class>元素的根元素的XML文檔。

<class>元素被用于定義數據庫表從一個Java類特定的映射。 Java類名指定使用class元素的name屬性和使用表屬性數據庫表名指定。

<meta>元素是可選元素，可以用來創建類的描述。

<id>元素映射在類中的唯一ID屬性到數據庫表的主鍵。 id元素的name屬性是指屬性的類和column屬性是指在數據庫表中的列。 type屬性保存了Hibernate映射類型，這種類型的映射將會從Java轉換為SQL數據類型。

id元素內的<generator>元素被用來自動生成的主鍵值。將生成元素的class屬性設置為原產于讓Hibernate拿起無論是identity，sequence或者hilo中的算法來創建主鍵根據底層數據庫的支持能力。

<property>元素用于一個Java類的屬性映射到數據庫表中的列。元素的name屬性是指屬性的類和column屬性是指在數據庫表中的列。 type屬性保存了Hibernate映射類型，這種類型的映射將會從Java轉換為SQL數據類型。

<map>元素用于設置證書和Employee類之間的關系。我們使用cascade屬性的<map>元素來告訴Hibernate來保存證書的對象，同時為Employee對象。 name屬性設置為定義Mapvariable在父類中，在我們的案例中是證書。

<index>的元素用于表示鍵/值對地圖的關鍵部位。該鍵將使用一個字符串類型的存儲在列certificate_type。

<key>元素是包含外鍵的父對象，即在證書表中的列。表EMPLOYEE。

<one-to-many>元素表示一個Employee對象涉及到很多證書的對象，并因此，證書對象必須有與Employee父類有關。可以根據需要使用<one-to-one>，<many-to-one>或<many-to-many>這個元素。

創建應用程序類：
最后，創建應用程序類的main（）方法來運行應用程序。使用這個應用程序來保存員工記錄地連同證書列表，然后在應用上執行CRUD操作上的記錄。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
import java.util.*;
 
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 
public class ManageEmployee {
  private static SessionFactory factory;
  public static void main(String[] args) {
   try{
     factory = new Configuration().configure().buildSessionFactory();
   }catch (Throwable ex) {
     System.err.println("Failed to create sessionFactory object." + ex);
     throw new ExceptionInInitializerError(ex);
   }
   ManageEmployee ME = new ManageEmployee();
   /* Let us have a set of certificates for the first employee */
   HashMap set = new HashMap();
   set.put("ComputerScience", new Certificate("MCA"));
   set.put("BusinessManagement", new Certificate("MBA"));
   set.put("ProjectManagement", new Certificate("PMP"));
   
   /* Add employee records in the database */
   Integer empID = ME.addEmployee("Manoj", "Kumar", 4000, set);
 
   /* List down all the employees */
   ME.listEmployees();
 
   /* Update employee's salary records */
   ME.updateEmployee(empID, 5000);
 
   /* List down all the employees */
   ME.listEmployees();
 
  }
 
  /* Method to add an employee record in the database */
  public Integer addEmployee(String fname, String lname,
                   int salary, HashMap cert){
   Session session = factory.openSession();
   Transaction tx = null;
   Integer employeeID = null;
   try{
     tx = session.beginTransaction();
     Employee employee = new Employee(fname, lname, salary);
     employee.setCertificates(cert);
     employeeID = (Integer) session.save(employee);
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
   return employeeID;
  }
 
  /* Method to list all the employees detail */
  public void listEmployees( ){
   Session session = factory.openSession();
   Transaction tx = null;
   try{
     tx = session.beginTransaction();
     List employees = session.createQuery("FROM Employee").list();
     for (Iterator iterator1 =
              employees.iterator(); iterator1.hasNext();){
      Employee employee = (Employee) iterator1.next();
      System.out.print("First Name: " + employee.getFirstName());
      System.out.print(" Last Name: " + employee.getLastName());
      System.out.println(" Salary: " + employee.getSalary());
      Map ec = employee.getCertificates();
      System.out.println("Certificate: " +
       (((Certificate)ec.get("ComputerScience")).getName()));
      System.out.println("Certificate: " +
       (((Certificate)ec.get("BusinessManagement")).getName()));
      System.out.println("Certificate: " +
       (((Certificate)ec.get("ProjectManagement")).getName()));
     }
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
  }
  /* Method to update salary for an employee */
  public void updateEmployee(Integer EmployeeID, int salary ){
   Session session = factory.openSession();
   Transaction tx = null;
   try{
     tx = session.beginTransaction();
     Employee employee =
          (Employee)session.get(Employee.class, EmployeeID);
     employee.setSalary( salary );
     session.update(employee);
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
  }
  /* Method to delete an employee from the records */
  public void deleteEmployee(Integer EmployeeID){
   Session session = factory.openSession();
   Transaction tx = null;
   try{
     tx = session.beginTransaction();
     Employee employee =
          (Employee)session.get(Employee.class, EmployeeID);
     session.delete(employee);
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
  }
}

編譯和執行：
下面是步驟來編譯并運行上述應用程序。請確保您已在進行的編譯和執行之前，已經適當地設置PATH和CLASSPATH。

  • 創建hibernate.cfg.xml配置文件,在配置章節已經解釋和學習。
  • 創建Employee.hbm.xml映射文件，如上圖所示。
  • 創建Employee.java源文件，如上圖所示，并編譯它。
  • 創建Certificate.java源文件，如上圖所示，并編譯它。
  • 創建ManageEmployee.java源文件，如上圖所示，并編譯它。
  • 執行ManageEmployee二進制文件來運行程序。

會在屏幕上獲得以下結果，并同時創建記錄在員工和證書表。

?
1
$java ManageEmployee

.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........

?
1
2
3
4
5
6
7
8
First Name: Manoj Last Name: Kumar Salary: 4000
Certificate: MCA
Certificate: MBA
Certificate: PMP
First Name: Manoj Last Name: Kumar Salary: 5000
Certificate: MCA
Certificate: MBA
Certificate: PMP

如果檢查員工和證書表，就應該記錄下了：

?
1
mysql> select * from EMPLOYEE;
?
1
2
3
4
5
6
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 60 | Manoj   | Kumar   |  5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)
?
1
mysql>select * from CERTIFICATE;
?
1
2
3
4
5
6
7
8
+----+--------------------+------------------+-------------+
| id | certificate_type  | certificate_name | employee_id |
+----+--------------------+------------------+-------------+
| 16 | ProjectManagement | PMP       |     60 |
| 17 | BusinessManagement | MBA       |     60 |
| 18 | ComputerScience  | MCA       |     60 |
+----+--------------------+------------------+-------------+
3 rows in set (0.00 sec)


SortedMap映射
SortedMap是存儲在鍵 - 值對的元素，并提供鍵的總體排序類似java的集合作為映射。重復的元素未在映射不允許的。該映射是根據其鍵的自然順序進行排序，或者通過提供通常在有序映射的創建時間比較。

SortedMap被映射在該映射表中的<map>元素和有序映射可以在java.util.TreeMap中被初始化。
我們依然使用上面定義的RDBMS表和POJO類來講下面的例子：
定義Hibernate映射文件：
讓我們開發指示Hibernate如何定義的類映射到數據庫表的映射文件。<map>元素將被用于定義所使用的映射的規則。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD//EN"
 "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping>
  <class name="Employee" table="EMPLOYEE">
   <meta attribute="class-description">
     This class contains the employee detail.
   </meta>
   <id name="id" type="int" column="id">
     <generator class="native"/>
   </id>
   <map name="certificates" cascade="all" sort="MyClass">
     <key column="employee_id"/>
     <index column="certificate_type" type="string"/>
     <one-to-many class="Certificate"/>
   </map>
   <property name="firstName" column="first_name" type="string"/>
   <property name="lastName" column="last_name" type="string"/>
   <property name="salary" column="salary" type="int"/>
  </class>
 
  <class name="Certificate" table="CERTIFICATE">
   <meta attribute="class-description">
     This class contains the certificate records.
   </meta>
   <id name="id" type="int" column="id">
     <generator class="native"/>
   </id>
   <property name="name" column="certificate_name" type="string"/>
  </class>
 
</hibernate-mapping>

應該保存的映射文件中的格式<classname>.hbm.xml。我們保存映射文件Employee.hbm.xml。前面已經熟悉了大部分的映射細節，但讓我們再次看看映射文件中的所有元素：

映射文檔是具有<hibernate-mapping>對應于每一個類包含2個<class>元素的根元素的XML文檔。

<class>元素被用于定義數據庫表從一個Java類特定的映射。 Java類名指定使用class元素的name屬性和使用表屬性數據庫表名指定。

<meta>元素是可選元素，可以用來創建類的描述。

<id>元素映射在類中的唯一ID屬性到數據庫表的主鍵。 id元素的name屬性是指屬性的類和column屬性是指在數據庫表中的列。 type屬性保存了Hibernate映射類型，這種類型的映射將會從Java轉換為SQL數據類型。

id元素內的<generator>元素被用來自動生成的主鍵值。將生成元素的class屬性設置讓Hibernate對應于identity，sequence或者hilo中的算法來創建主鍵根據底層數據庫的支持能力。

<property>元素用于一個Java類的屬性映射到數據庫表中的列。元素的name屬性是指屬性的類和column屬性是指在數據庫表中的列。 type屬性保存了Hibernate映射類型，這種類型的映射將會從Java轉換為SQL數據類型。

<map>元素用于設置證書和Employee類之間的關系。我們使用cascade屬性的<map>元素來告訴Hibernate來保存證書的對象，同時為Employee對象。 name屬性被設置為在父類中的定義的SortedMap變量，在我們的情況下，它是證書。排序屬性可以設置為自然有自然排序，也可以設置為自定義類實現為java.util.Comparator。我們已經使用了一個類MyClass，它實現為java.util.Comparator扭轉證書類實現的排序順序。

<index>元素用于表示鍵/值對映射的鍵部分。該鍵將使用一個字符串類型的存儲在列certificate_type。

<key>元素是包含外鍵的父對象，即在證書表中的列。表EMPLOYEE。

<one-to-many>元素表示一個Employee對象涉及到很多證書的對象，并因此，證書對象必須有與Employee父有關聯。可以根據需要使用<one-to-one>，<many-to-one>或<many-to-many>這個元素。

如果使用sort="natural"，然后我們并不需要創建一個單獨的類，因為證書類已經實現了Comparable接口和hibernate會使用compareTo在證書類定義為比較的SortedMap（）方法。但是，我們使用的是在我們的映射文件自定義的比較器類MyClass，所以我們必須創建這個類的基礎上我們的排序算法。讓我們做降在映射上可用的按鍵排序。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Comparator;
 
public class MyClass implements Comparator <String>{
  public int compare(String o1, String o2) {
   final int BEFORE = -1;
   final int AFTER = 1;
 
   /* To reverse the sorting order, multiple by -1 */
   if (o2 == null) {
     return BEFORE * -1;
   }
 
   Comparable thisCertificate = o1;
   Comparable thatCertificate = o2;
 
   if(thisCertificate == null) {
     return AFTER * 1;
   } else if(thatCertificate == null) {
     return BEFORE * -1;
   } else {
     return thisCertificate.compareTo(thatCertificate) * -1;
   }
  }
}

最后，我們將創建應用程序類的main（）方法來運行應用程序。我們將使用這個應用程序，以節省一些員工的記錄地連同的證書，然后我們將提交CRUD操作上面的記錄。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
import java.util.*;
 
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 
public class ManageEmployee {
  private static SessionFactory factory;
  public static void main(String[] args) {
   try{
     factory = new Configuration().configure().buildSessionFactory();
   }catch (Throwable ex) {
     System.err.println("Failed to create sessionFactory object." + ex);
     throw new ExceptionInInitializerError(ex);
   }
   ManageEmployee ME = new ManageEmployee();
   /* Let us have a set of certificates for the first employee */
   TreeMap set1 = new TreeMap();
   set1.put("ComputerScience", new Certificate("MCA"));
   set1.put("BusinessManagement", new Certificate("MBA"));
   set1.put("ProjectManagement", new Certificate("PMP"));
 
   /* Add employee records in the database */
   Integer empID1 = ME.addEmployee("Manoj", "Kumar", 4000, set1);
 
   /* Another set of certificates for the second employee */
   TreeMap set2 = new TreeMap();
   set2.put("ComputerScience", new Certificate("MCA"));
   set2.put("BusinessManagement", new Certificate("MBA"));
 
   /* Add another employee record in the database */
   Integer empID2 = ME.addEmployee("Dilip", "Kumar", 3000, set2);
 
   /* List down all the employees */
   ME.listEmployees();
 
   /* Update employee's salary records */
   ME.updateEmployee(empID1, 5000);
 
   /* Delete an employee from the database */
   ME.deleteEmployee(empID2);
 
   /* List down all the employees */
   ME.listEmployees();
 
  }
 
  /* Method to add an employee record in the database */
  public Integer addEmployee(String fname, String lname,
                   int salary, TreeMap cert){
   Session session = factory.openSession();
   Transaction tx = null;
   Integer employeeID = null;
   try{
     tx = session.beginTransaction();
     Employee employee = new Employee(fname, lname, salary);
     employee.setCertificates(cert);
     employeeID = (Integer) session.save(employee);
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
   return employeeID;
  }
 
  /* Method to list all the employees detail */
  public void listEmployees( ){
   Session session = factory.openSession();
   Transaction tx = null;
   try{
     tx = session.beginTransaction();
     List employees = session.createQuery("FROM Employee").list();
     for (Iterator iterator1 =
              employees.iterator(); iterator1.hasNext();){
      Employee employee = (Employee) iterator1.next();
      System.out.print("First Name: " + employee.getFirstName());
      System.out.print(" Last Name: " + employee.getLastName());
      System.out.println(" Salary: " + employee.getSalary());
      SortedMap<String, Certificate> map =
                        employee.getCertificates();
      for(Map.Entry<String,Certificate> entry : map.entrySet()){
        System.out.print("\tCertificate Type: " + entry.getKey());
        System.out.println(", Name: " +
                    (entry.getValue()).getName());
      }
     }
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
  }
  /* Method to update salary for an employee */
  public void updateEmployee(Integer EmployeeID, int salary ){
   Session session = factory.openSession();
   Transaction tx = null;
   try{
     tx = session.beginTransaction();
     Employee employee =
          (Employee)session.get(Employee.class, EmployeeID);
     employee.setSalary( salary );
     session.update(employee);
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
  }
  /* Method to delete an employee from the records */
  public void deleteEmployee(Integer EmployeeID){
   Session session = factory.openSession();
   Transaction tx = null;
   try{
     tx = session.beginTransaction();
     Employee employee =
          (Employee)session.get(Employee.class, EmployeeID);
     session.delete(employee);
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
  }
}

編譯和執行： 
可以看到證書已排序順序相反。可以通過改變映射文件試試，只需設置sort="natural"和執行程序，并比較結果。

?
1
$java ManageEmployee
?
1
2
3
4
5
6
7
8
9
10
11
12
13
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........
 
First Name: Manoj Last Name: Kumar Salary: 4000
 Certificate Type: ProjectManagement, Name: PMP
 Certificate Type: ComputerScience, Name: MCA
 Certificate Type: BusinessManagement, Name: MBA
First Name: Dilip Last Name: Kumar Salary: 3000
 Certificate Type: ComputerScience, Name: MCA
 Certificate Type: BusinessManagement, Name: MBA
First Name: Manoj Last Name: Kumar Salary: 5000
 Certificate Type: ProjectManagement, Name: PMP
 Certificate Type: ComputerScience, Name: MCA
 Certificate Type: BusinessManagement, Name: MBA

如果檢查員工和證書表，就應該記錄下了：

?
1
mysql> select * from EMPLOYEE;
?
1
2
3
4
5
6
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 74 | Manoj   | Kumar   |  5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)
?
1
mysql> select * from CERTIFICATE;
?
1
2
3
4
5
6
7
8
+----+--------------------+------------------+-------------+
| id | certificate_type  | certificate_name | employee_id |
+----+--------------------+------------------+-------------+
| 52 | BusinessManagement | MBA       |     74 |
| 53 | ComputerScience  | MCA       |     74 |
| 54 | ProjectManagement | PMP       |     74 |
+----+--------------------+------------------+-------------+
3 rows in set (0.00 sec)

延伸 · 閱讀

精彩推薦
553
Weibo Article 1 Weibo Article 2 Weibo Article 3 Weibo Article 4 Weibo Article 5 Weibo Article 6 Weibo Article 7 Weibo Article 8 Weibo Article 9 Weibo Article 10 Weibo Article 11 Weibo Article 12 Weibo Article 13 Weibo Article 14 Weibo Article 15 Weibo Article 16 Weibo Article 17 Weibo Article 18 Weibo Article 19 Weibo Article 20 Weibo Article 21 Weibo Article 22 Weibo Article 23 Weibo Article 24 Weibo Article 25
主站蜘蛛池模板： 黄色免费大片 | 久久国产精品小视频 | 国产乱一区二区三区视频 | 麻豆视频免费网站 | 一级免费| 国产一区毛片 | 成人网在线观看 | 成人激情综合网 | 在线观看免费毛片视频 | 草莓视频久久 | 亚洲第一成av人网站懂色 | 成人毛片免费 | 久久免费视频7 | 摸逼逼视频 | 在线看一区二区三区 | 欧美成人精品欧美一级 | 久久综合色区 | 国产精品午夜小视频观看 | 国产成人高清在线 | 国产一区二区三区网站 | 2023av在线视频 | 国产成年人网站 | 成年毛片 | 亚洲精品av在线 | 黄色7777| 丰满年轻岳中文字幕一区二区 | 黄色特级视频 | 国产视频第一区 | 亚洲精品久久久久久久久久久 | 久久国产一二三 | 久久精品视频网站 | 4399一级成人毛片 | 91看片网页版 | 热99在线视频 | 法国性xxx精品hd专区 | 精国产品一区二区三区 | 精品国产91久久久久久久妲己 | 国产成人高清成人av片在线看 | 亚洲精品久久久久久 | 国产精品国产三级国产aⅴ无密码 | 一级成人免费 |