ฐานข้อมูล H2 - คู่มือฉบับย่อ

H2 เป็นฐานข้อมูล Java น้ำหนักเบาแบบโอเพนซอร์ส สามารถฝังอยู่ในแอ็พพลิเคชัน Java หรือรันในโหมดไคลเอนต์เซิร์ฟเวอร์ โดยทั่วไปฐานข้อมูล H2 สามารถกำหนดค่าให้ทำงานเป็นฐานข้อมูลในหน่วยความจำซึ่งหมายความว่าข้อมูลจะไม่อยู่ในดิสก์ เนื่องจากฐานข้อมูลแบบฝังจึงไม่ได้ใช้สำหรับการพัฒนาการผลิต แต่ส่วนใหญ่ใช้สำหรับการพัฒนาและการทดสอบ

ฐานข้อมูลนี้สามารถใช้ในโหมดฝังตัวหรือในโหมดเซิร์ฟเวอร์ ต่อไปนี้เป็นคุณสมบัติหลักของฐานข้อมูล H2 -

• JDBC API แบบโอเพ่นซอร์สที่รวดเร็วมาก
• พร้อมใช้งานในโหมดฝังตัวและเซิร์ฟเวอร์ ฐานข้อมูลในหน่วยความจำ
• แอปพลิเคชันคอนโซลบนเบราว์เซอร์
• ขนาดเล็ก - ขนาดไฟล์ jar ประมาณ 1.5MB

คุณสมบัติของฐานข้อมูล H2

คุณสมบัติหลักของ H2 Database มีดังนี้ -

• เป็นเครื่องมือฐานข้อมูลที่รวดเร็วมาก

• H2 เป็นโอเพ่นซอร์สและเขียนด้วย Java

• รองรับ SQL มาตรฐานและ JDBC API สามารถใช้ไดรเวอร์ PostgreSQL ODBC ได้เช่นกัน

• มีโหมดฝังตัวและเซิร์ฟเวอร์

• H2 รองรับ clustering และ multi-version concurrency.

• มีคุณสมบัติด้านความปลอดภัยที่แข็งแกร่ง

คุณลักษณะเพิ่มเติม

ต่อไปนี้เป็นคุณสมบัติเพิ่มเติมของ H2 Database -

• H2 เป็นฐานข้อมูลและตารางที่ใช้ดิสก์หรือในหน่วยความจำสนับสนุนฐานข้อมูลแบบอ่านอย่างเดียวตารางชั่วคราว

• H2 ให้การสนับสนุนธุรกรรม (อ่านคอมมิต) การเชื่อมต่อหลายเฟสคอมมิต 2 เฟสการล็อกระดับตาราง

• H2 เป็นเครื่องมือเพิ่มประสิทธิภาพตามต้นทุนโดยใช้อัลกอริธึมทางพันธุกรรมสำหรับการสืบค้นที่ซับซ้อนการดูแลระบบเป็นศูนย์

• H2 ประกอบด้วยการสนับสนุนชุดผลลัพธ์ที่เลื่อนได้และอัปเดตได้ชุดผลลัพธ์ขนาดใหญ่การเรียงลำดับผลลัพธ์ภายนอกฟังก์ชันสามารถส่งคืนชุดผลลัพธ์

• H2 รองรับฐานข้อมูลที่เข้ารหัส (AES), การเข้ารหัสรหัสผ่าน SHA-256, ฟังก์ชันการเข้ารหัสและ SSL

ส่วนประกอบในฐานข้อมูล H2

ในการใช้ฐานข้อมูล H2 คุณต้องมีส่วนประกอบดังต่อไปนี้ -

• เว็บเบราว์เซอร์
• เซิร์ฟเวอร์คอนโซล H2

นี่คือแอปพลิเคชันไคลเอนต์ / เซิร์ฟเวอร์ดังนั้นทั้งเซิร์ฟเวอร์และไคลเอนต์ (เบราว์เซอร์) จึงจำเป็นต้องเรียกใช้

H2 เป็นฐานข้อมูลที่เขียนด้วยภาษาจาวา เราสามารถฝังฐานข้อมูลนี้ลงในแอปพลิเคชันของเราได้อย่างง่ายดายโดยใช้ JDBC เราสามารถเรียกใช้สิ่งนี้บนแพลตฟอร์มต่างๆหรือ Java Runtime Environment เวอร์ชันใดก็ได้ อย่างไรก็ตามก่อนการติดตั้งฐานข้อมูลควรมี Java ติดตั้งอยู่ในระบบ

ตรวจสอบการติดตั้ง Java

หากติดตั้ง JDK ในระบบให้ลองใช้คำสั่งต่อไปนี้เพื่อตรวจสอบเวอร์ชัน Java

java –version

หากติดตั้ง JDk ในระบบสำเร็จเราจะได้ผลลัพธ์ดังต่อไปนี้

java version "1.8.0_91" 
Java(TM) SE Runtime Environment (build 1.8.0_91-b14) 
Java HotSpot(TM) 64-Bit Server VM (build 25.91-b14, mixed mode)

หาก JDK ไม่ได้ติดตั้งในระบบแล้วไปที่ลิงก์ต่อไปนี้เพื่อติดตั้ง JDK

ติดตั้งฐานข้อมูล H2

เราสามารถเรียกใช้ฐานข้อมูลนี้บนแพลตฟอร์มต่างๆมากมาย ในบทนี้เราจะเรียนรู้เกี่ยวกับการติดตั้งฐานข้อมูล H2 บน Windows

ต่อไปนี้เป็นขั้นตอนในการติดตั้ง H2 Database บนระบบปฏิบัติการ Windows

ขั้นตอนที่ 1: ดาวน์โหลด H2 Setup File

ดาวน์โหลดH2 Databaseเวอร์ชันล่าสุดจากลิงค์ที่ระบุ ในลิงค์นี้คุณจะได้รับฐานข้อมูล H2 เวอร์ชันล่าสุดในสองประเภท หนึ่งคือประเภท Windows Installer (นั่นคือไฟล์. exe) และที่สองคือไฟล์ zip ที่ไม่ขึ้นกับแพลตฟอร์มสำหรับระบบปฏิบัติการอื่น

คลิกตัวติดตั้ง Windows เพื่อดาวน์โหลดฐานข้อมูล H2 ที่รองรับ Windows หลังจากดาวน์โหลดไฟล์. exe ในกรณีนี้เรากำลังใช้ H2 Database กับเวอร์ชัน 1.4.192

ขั้นตอนที่ 2: ติดตั้งฐานข้อมูล H2

หลังจากดาวน์โหลดเราจะได้ไฟล์ตัวติดตั้ง H2 Windows (เช่น h2-setup-yyyy-mm-dd.exe) ในไดเร็กทอรีดาวน์โหลด ในการเริ่มกระบวนการติดตั้งฐานข้อมูล H2 ให้ดับเบิลคลิกที่ไฟล์ตัวติดตั้ง

หน้าจอต่อไปนี้เป็นขั้นตอนแรกในกระบวนการติดตั้ง ระบุเส้นทางที่เราต้องการติดตั้งเซิร์ฟเวอร์ฐานข้อมูล H2 ดังที่แสดงในภาพหน้าจอต่อไปนี้

ตามที่เห็นในภาพหน้าจอด้านบนโดยค่าเริ่มต้นจะใช้เวลา C:\ProgramFiles (x86)\H2เป็นโฟลเดอร์ปลายทาง คลิกถัดไปเพื่อดำเนินการขั้นต่อไป หน้าจอต่อไปนี้จะปรากฏขึ้น

ในภาพหน้าจอด้านบนคลิกปุ่มติดตั้งเพื่อเริ่มกระบวนการติดตั้ง หลังจากการติดตั้งเราจะได้ภาพหน้าจอต่อไปนี้

คลิกเสร็จสิ้นเพื่อเสร็จสิ้นกระบวนการติดตั้ง

ขั้นตอนที่ 3: ตรวจสอบการติดตั้งฐานข้อมูล H2

หลังจากการติดตั้งให้เราตรวจสอบการติดตั้งฐานข้อมูลในระบบ คลิก Windows →พิมพ์ H2 Console →คลิกไอคอน H2 console เชื่อมต่อกับ URLhttp://localhost:8082. ในขณะเชื่อมต่อฐานข้อมูล H2 จะขอการลงทะเบียนฐานข้อมูลดังที่แสดงในภาพหน้าจอต่อไปนี้

กรอกรายละเอียดทั้งหมดในกล่องโต้ตอบด้านบนเช่นการตั้งค่าที่บันทึกชื่อการตั้งค่าคลาสไดรเวอร์ URL JDBC ชื่อผู้ใช้และรหัสผ่าน ใน JDBC URL ระบุฐานข้อมูลที่อยู่และชื่อฐานข้อมูล ชื่อผู้ใช้และรหัสผ่านเป็นฟิลด์สำหรับชื่อผู้ใช้และรหัสผ่านของฐานข้อมูล คลิกเชื่อมต่อ

หน้ายินดีต้อนรับฐานข้อมูลจะปรากฏขึ้นตามที่แสดงในภาพหน้าจอต่อไปนี้

คำสั่ง Select ใช้เพื่อดึงข้อมูลบันทึกจากตารางหรือหลายตาราง หากเราออกแบบคิวรีแบบเลือกระบบจะส่งคืนข้อมูลในรูปแบบของตารางผลลัพธ์ที่เรียกว่าresult sets.

ไวยากรณ์

ไวยากรณ์พื้นฐานของคำสั่ง SELECT มีดังนี้ -

SELECT [ TOP term ] [ DISTINCT | ALL ] selectExpression [,...] 
FROM tableExpression [,...] [ WHERE expression ] 
[ GROUP BY expression [,...] ] [ HAVING expression ] 
[ { UNION [ ALL ] | MINUS | EXCEPT | INTERSECT } select ] [ ORDER BY order [,...] ] 
[ [ LIMIT expression ] [ OFFSET expression ] [ SAMPLE_SIZE rowCountInt ] ] 
[ FOR UPDATE ]

ในการดึงข้อมูลฟิลด์ที่มีทั้งหมดให้ใช้ไวยากรณ์ต่อไปนี้

SELECT * FROM table_name;

ตัวอย่าง

พิจารณาตารางลูกค้าที่มีบันทึกต่อไปนี้ -

+----+----------+-----+-----------+----------+ 
| ID | NAME     | AGE | ADDRESS   | SALARY   | 
+----+----------+-----+-----------+----------+ 
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 | 
|  2 | Khilan   |  25 | Delhi     |  1500.00 | 
|  3 | kaushik  |  23 | Kota      |  2000.00 | 
|  4 | Chaitali |  25 | Mumbai    |  6500.00 | 
|  5 | Hardik   |  27 | Bhopal    |  8500.00 | 
|  6 | Komal    |  22 | MP        |  4500.00 | 
|  7 | Muffy    |  24 | Indore    | 10000.00 | 
+----+----------+-----+-----------+----------+

ในการรับตารางลูกค้าพร้อมกับข้อมูลที่กำหนดให้ดำเนินการค้นหาต่อไปนี้

CREATE TABLE CUSTOMER (id number, name varchar(20), age number, address varchar(20), 
salary number);  

INSERT into CUSTOMER values (1, 'Ramesh', 32, 'Ahmedabad', 2000); 
INSERT into CUSTOMER values (2, 'Khilan', 25, 'Delhi', 1500); 
INSERT into CUSTOMER values (3, 'kaushik', 23, 'Kota', 2000); 
INSERT into CUSTOMER values (4, 'Chaitali', 25, 'Mumbai', 6500); 
INSERT into CUSTOMER values (5, 'Hardik', 27, 'Bhopal', 8500); 
INSERT into CUSTOMER values (6, 'Komal', 22, 'MP', 4500); 
INSERT into CUSTOMER values (7, 'Muffy', 24, 'Indore', 10000);

คำสั่งต่อไปนี้เป็นตัวอย่างซึ่งจะดึงฟิลด์ ID ชื่อและเงินเดือนของลูกค้าที่มีอยู่ในตาราง CUSTOMER

SELECT ID, NAME, SALARY FROM CUSTOMERS;

คำสั่งดังกล่าวก่อให้เกิดผลลัพธ์ต่อไปนี้

+----+----------+----------+ 
| ID | NAME     | SALARY   | 
+----+----------+----------+ 
|  1 | Ramesh   |  2000.00 | 
|  2 | Khilan   |  1500.00 | 
|  3 | kaushik  |  2000.00 | 
|  4 | Chaitali |  6500.00 | 
|  5 | Hardik   |  8500.00 | 
|  6 | Komal    |  4500.00 | 
|  7 | Muffy    | 10000.00 | 
+----+----------+----------+

ใช้แบบสอบถามต่อไปนี้เพื่อดึงฟิลด์ทั้งหมดของตาราง CUSTOMERS

SQL> SELECT * FROM CUSTOMERS;

แบบสอบถามข้างต้นให้ผลลัพธ์ดังต่อไปนี้ -

+----+----------+-----+-----------+----------+ 
| ID | NAME     | AGE | ADDRESS   | SALARY   | 
+----+----------+-----+-----------+----------+ 
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 | 
|  2 | Khilan   |  25 | Delhi     |  1500.00 | 
|  3 | kaushik  |  23 | Kota      |  2000.00 | 
|  4 | Chaitali |  25 | Mumbai    |  6500.00 | 
|  5 | Hardik   |  27 | Bhopal    |  8500.00 | 
|  6 | Komal    |  22 | MP        |  4500.00 | 
|  7 | Muffy    |  24 | Indore    | 10000.00 | 
+----+----------+-----+-----------+----------+

คำสั่ง SQL INSERT ใช้เพื่อเพิ่มแถวข้อมูลใหม่ลงในตารางในฐานข้อมูล

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง INSERT INTO

INSERT INTO tableName 
{ [ ( columnName [,...] ) ] 
{ VALUES 
{ ( { DEFAULT | expression } [,...] ) } [,...] | [ DIRECT ] [ SORTED ] select } } | 
{ SET { columnName = { DEFAULT | expression } } [,...] }

การใช้คำสั่ง INSERT นี้เราสามารถแทรกระเบียนใหม่หรือแถวใหม่ลงในตาราง เมื่อใช้คำสั่ง DIRECT ผลลัพธ์จะได้รับผลโดยตรงกับตารางเป้าหมายโดยไม่มีขั้นตอนกลาง อย่างไรก็ตามในขณะที่เพิ่มค่าสำหรับคอลัมน์ทั้งหมดของตารางตรวจสอบให้แน่ใจว่าลำดับของค่าอยู่ในลำดับเดียวกับคอลัมน์ในตาราง

ตัวอย่าง

ให้เรายกตัวอย่างและลองใส่บันทึกที่กำหนดต่อไปนี้ลงในตารางลูกค้า

ID	ชื่อ	อายุ	ที่อยู่	เงินเดือน
1	ราเมช	32	อาเมดาบัด	พ.ศ. 2543
2	คิลัน	25	เดลี	1,500
3	Kaushik	23	โคตะ	พ.ศ. 2543
4	Chaitail	25	มุมไบ	6500
5	ฮาร์ดิค	27	โภปาล	8500
6	Komal	22	ส.ส.	4500
7	Muffy	24	อินดอร์	10,000

เราสามารถรับบันทึกที่กำหนดทั้งหมดลงในตารางลูกค้าได้โดยดำเนินการคำสั่งต่อไปนี้

INSERT INTO CUSTOMER VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000); 
INSERT INTO CUSTOMER VALUES (2, 'Khilan', 25, 'Delhi', 1500); 
INSERT INTO CUSTOMER VALUES (3, 'kaushik', 23, 'Kota', 2000); 
INSERT INTO CUSTOMER VALUES (4, 'Chaitali', 25, 'Mumbai', 6500); 
INSERT INTO CUSTOMER VALUES (5, 'Hardik', 27, 'Bhopal', 8500); 
INSERT INTO CUSTOMER VALUES (6, 'Komal', 22, 'MP', 4500); 
INSERT INTO CUSTOMER VALUES (7, 'Muffy', 24, 'Indore', 10000);

แบบสอบถาม UPDATE ใช้เพื่ออัปเดตหรือแก้ไขระเบียนที่มีอยู่ในตาราง เราสามารถใช้ WHERE clause กับ UPDATE query เพื่ออัปเดตแถวที่เลือกมิฉะนั้นแถวทั้งหมดจะได้รับผลกระทบ

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของแบบสอบถาม UPDATE

UPDATE tableName [ [ AS ] newTableAlias ] SET 
{ { columnName = { DEFAULT | expression } } [,...] } | 
{ ( columnName [,...] ) = ( select ) } 
[ WHERE expression ] [ ORDER BY order [,...] ] [ LIMIT expression ]

ในไวยากรณ์ UPDATE นี้เราสามารถรวมเงื่อนไขได้มากกว่าหนึ่งเงื่อนไขโดยใช้ AND หรือ OR clauses

ตัวอย่าง

พิจารณาตารางลูกค้าที่มีบันทึกต่อไปนี้

+----+----------+-----+-----------+----------+ 
| ID | NAME     | AGE | ADDRESS   | SALARY   | 
+----+----------+-----+-----------+----------+ 
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 | 
|  2 | Khilan   |  25 | Delhi     |  1500.00 | 
|  3 | kaushik  |  23 | Kota      |  2000.00 | 
|  4 | Chaitali |  25 | Mumbai    |  6500.00 | 
|  5 | Hardik   |  27 | Bhopal    |  8500.00 | 
|  6 | Komal    |  22 | MP        |  4500.00 | 
|  7 | Muffy    |  24 | Indore    | 10000.00 | 
+----+----------+-----+-----------+----------+

หากคุณต้องการรับตารางลูกค้าพร้อมกับข้อมูลที่กำหนดให้ดำเนินการค้นหาต่อไปนี้

CREATE TABLE CUSTOMER (id number, name varchar(20), age number, address varchar(20), 
   salary number);  
INSERT into CUSTOMER values (1, 'Ramesh', 32, 'Ahmedabad', 2000); 
INSERT into CUSTOMER values (2, 'Khilan', 25, 'Delhi', 1500); 
INSERT into CUSTOMER values (3, 'kaushik', 23, 'Kota', 2000); 
INSERT into CUSTOMER values (4, 'Chaitali', 25, 'Mumbai', 6500); 
INSERT into CUSTOMER values (5, 'Hardik', 27, 'Bhopal', 8500); 
INSERT into CUSTOMER values (6, 'Komal', 22, 'MP', 4500); 
INSERT into CUSTOMER values (7, 'Muffy', 24, 'Indore', 10000);

คำสั่งต่อไปนี้เป็นตัวอย่างซึ่งจะอัปเดต ADDRESS สำหรับลูกค้าที่มี ID คือ 6 -

UPDATE CUSTOMERS SET ADDRESS = 'Pune' WHERE ID = 6;

ตอนนี้ตาราง CUSTOMERS จะมีบันทึกต่อไปนี้ เราสามารถตรวจสอบบันทึกตารางของลูกค้าได้โดยดำเนินการสอบถามต่อไปนี้

SELECT * FROM CUSTOMERS;

แบบสอบถามข้างต้นให้ผลลัพธ์ดังต่อไปนี้

+----+----------+-----+-----------+----------+ 
| ID | NAME     | AGE | ADDRESS   | SALARY   | 
+----+----------+-----+-----------+----------+ 
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 | 
|  2 | Khilan   |  25 | Delhi     |  1500.00 | 
|  3 | kaushik  |  23 | Kota      |  2000.00 | 
|  4 | Chaitali |  25 | Mumbai    |  6500.00 | 
|  5 | Hardik   |  27 | Bhopal    |  8500.00 | 
|  6 | Komal    |  22 | Pune      |  4500.00 | 
|  7 | Muffy    |  24 | Indore    | 10000.00 | 
+----+----------+-----+-----------+----------+

ในการแก้ไขค่าคอลัมน์ ADDRESS และ SALARY ทั้งหมดในตาราง CUSTOMERS เราไม่จำเป็นต้องใช้คำสั่ง WHERE แบบสอบถาม UPDATE จะเป็นดังนี้ -

UPDATE CUSTOMERS SET ADDRESS = 'Pune', SALARY = 1000.00;

ตอนนี้ตาราง CUSTOMERS จะมีบันทึกต่อไปนี้ เราสามารถตรวจสอบบันทึกตารางของลูกค้าได้โดยดำเนินการสอบถามต่อไปนี้

SELECT * FROM CUSTOMERS;

แบบสอบถามข้างต้นให้ผลลัพธ์ดังต่อไปนี้ -

+----+----------+-----+---------+---------+ 
| ID | NAME     | AGE | ADDRESS | SALARY  | 
+----+----------+-----+---------+---------+ 
|  1 | Ramesh   |  32 | Pune    | 1000.00 | 
|  2 | Khilan   |  25 | Pune    | 1000.00 | 
|  3 | kaushik  |  23 | Pune    | 1000.00 | 
|  4 | Chaitali |  25 | Pune    | 1000.00 | 
|  5 | Hardik   |  27 | Pune    | 1000.00 | 
|  6 | Komal    |  22 | Pune    | 1000.00 | 
|  7 | Muffy    |  24 | Pune    | 1000.00 | 
+----+----------+-----+---------+---------+

แบบสอบถาม SQL DELETE ใช้เพื่อลบระเบียนที่มีอยู่ออกจากตาราง เราสามารถใช้ WHERE clause กับ DELETE query เพื่อลบเร็กคอร์ดที่เลือกมิฉะนั้นบันทึกทั้งหมดจะถูกลบ

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์การสืบค้นทั่วไปของคำสั่งลบ

DELETE [ TOP term ] FROM tableName [ WHERE expression ] [ LIMIT term ]

ไวยากรณ์ด้านบนจะลบแถวออกจากตาราง หากระบุ TOP หรือ LIMIT แถวมากที่สุดตามจำนวนที่ระบุไว้จะถูกลบ (ไม่ จำกัด ว่าเป็นค่าว่างหรือน้อยกว่าศูนย์)

ตัวอย่าง

พิจารณาตารางลูกค้าที่มีบันทึกต่อไปนี้

+----+----------+-----+-----------+----------+ 
| ID | NAME     | AGE | ADDRESS   | SALARY   | 
+----+----------+-----+-----------+----------+ 
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 | 
|  2 | Khilan   |  25 | Delhi     |  1500.00 | 
|  3 | kaushik  |  23 | Kota      |  2000.00 | 
|  4 | Chaitali |  25 | Mumbai    |  6500.00 | 
|  5 | Hardik   |  27 | Bhopal    |  8500.00 | 
|  6 | Komal    |  22 | MP        |  4500.00 | 
|  7 | Muffy    |  24 | Indore    | 10000.00 | 
+----+----------+-----+-----------+----------+

คำสั่งต่อไปนี้จะลบรายละเอียดของลูกค้าซึ่งมี ID คือ 6

DELETE FROM CUSTOMERS WHERE ID = 6;

หลังจากดำเนินการคำสั่งดังกล่าวแล้วให้ตรวจสอบตารางลูกค้าโดยดำเนินการคำสั่งต่อไปนี้

SELECT * FROM CUSTOMERS;

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้ -

+----+----------+-----+-----------+----------+ 
| ID | NAME     | AGE | ADDRESS   | SALARY   | 
+----+----------+-----+-----------+----------+ 
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 | 
|  2 | Khilan   |  25 | Delhi     |  1500.00 | 
|  3 | kaushik  |  23 | Kota      |  2000.00 | 
|  4 | Chaitali |  25 | Mumbai    |  6500.00 | 
|  5 | Hardik   |  27 | Bhopal    |  8500.00 | 
|  7 | Muffy    |  24 | Indore    | 10000.00 | 
+----+----------+-----+-----------+----------+

ถ้าเราต้องการลบระเบียนทั้งหมดจากตาราง CUSTOMERS เราไม่ใช้ WHERE clause แบบสอบถาม DELETE จะเป็นดังนี้

DELETE FROM CUSTOMER;

หลังจากดำเนินการคำสั่งข้างต้นจะไม่มีบันทึกในตารางลูกค้า

BACKUP เป็นคำสั่งที่ใช้ในการสำรองฐานข้อมูลลงในไฟล์. zip แยกต่างหาก อ็อบเจ็กต์ไม่ได้ถูกล็อกและเมื่อทำการสำรองข้อมูลบันทึกธุรกรรมจะถูกคัดลอกไปด้วย ต้องมีสิทธิ์ผู้ดูแลระบบเพื่อดำเนินการคำสั่งนี้

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Backup

BACKUP TO fileNameString;

ตัวอย่าง

ในตัวอย่างนี้ให้เราสำรองฐานข้อมูลปัจจุบันลงใน backup.zipไฟล์. ใช้คำสั่งต่อไปนี้สำหรับสิ่งเดียวกัน

BACKUP TO 'backup.zip';

ในการดำเนินการคำสั่งข้างต้นคุณจะได้รับไฟล์ backup.zip ในระบบไฟล์ภายในของคุณ

CALL เป็นคำสั่ง SQL ซึ่งเป็นของเซิร์ฟเวอร์ฐานข้อมูล H2 คำสั่งนี้ใช้ในการคำนวณนิพจน์ทั่วไป ส่งคืนผลลัพธ์ของนิพจน์ที่กำหนดในฟิลด์คอลัมน์เดียว เมื่อส่งกลับอาร์เรย์ของผลลัพธ์แต่ละองค์ประกอบในอาร์เรย์จะแสดงเป็นค่าคอลัมน์

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง CALL

CALL expression;

เราสามารถใช้นิพจน์เลขคณิตในไวยากรณ์นี้

ตัวอย่าง

ให้เรายกตัวอย่างและดำเนินการนิพจน์เลขคณิต (15 * 25) โดยใช้คำสั่งโทร

CALL 15*25;

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

375
375

คำสั่ง EXPLAIN แสดงแผนการดำเนินการสำหรับคำสั่ง เมื่อเราดำเนินการคำสั่งโดยใช้คำสั่ง EXPLAIN ANALYZE แผนการสืบค้นจะรวมจำนวนการสแกนแถวจริงสำหรับแต่ละตาราง

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง EXPLAIN

EXPLAIN { [ PLAN FOR ] | ANALYZE } { select | insert | update | delete | merge}

นอกจากไวยากรณ์นี้แล้วเรายังสามารถใช้เลือกแทรกลบและผสานได้

ตัวอย่าง

ตัวอย่างนี้อธิบายรายละเอียดแผนการสืบค้นของลูกค้าด้วย ID 1

EXPLAIN SELECT * FROM CUSTOMER WHERE ID = 1;

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้ -

คำสั่ง MERGE ใช้เพื่ออัปเดตแถวที่มีอยู่และแทรกแถวใหม่ลงในตาราง คอลัมน์คีย์หลักมีบทบาทสำคัญขณะใช้คำสั่งนี้ ใช้เพื่อค้นหาแถว

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง MERGE

MERGE INTO tableName [ ( columnName [,...] ) ] 
[ KEY ( columnName [,...] ) ] 
{ VALUES { ( { DEFAULT | expression } [,...] ) } [,...] | select }

ในไวยากรณ์ข้างต้นคำสั่ง KEY ใช้เพื่อระบุชื่อคอลัมน์คีย์หลัก นอกเหนือจากคำสั่ง VALUES แล้วเราสามารถใช้ค่าดั้งเดิมเพื่อแทรกหรือเราสามารถดึงและเก็บค่าตารางอื่นลงในตารางนี้โดยใช้คำสั่ง select

ตัวอย่าง

ในตัวอย่างนี้ให้เราลองเพิ่มระเบียนใหม่ในตารางลูกค้า ต่อไปนี้เป็นรายละเอียดของระเบียนใหม่ในตาราง

ชื่อคอลัมน์	มูลค่า
ID	8
ชื่อ	Lokesh
อายุ	32
ที่อยู่	ไฮเดอราบาด
เงินเดือน	2500

ใช้แบบสอบถามต่อไปนี้ให้เราแทรกบันทึกที่กำหนดลงในแบบสอบถามฐานข้อมูล H2

MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Lokesh', 32, 'Hyderabad', 2500);

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

Update count: 1

ให้เราตรวจสอบบันทึกของตารางลูกค้าโดยดำเนินการค้นหาต่อไปนี้

SELECT * FROM CUSTOMER;

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

ID	ชื่อ	อายุ	ที่อยู่	เงินเดือน
1	ราเมช	32	อาเมดาบัด	พ.ศ. 2543
2	คิลัน	25	เดลี	1,500
3	Kaushik	23	โคตะ	พ.ศ. 2543
4	Chaitali	25	มุมไบ	6500
5	ฮาร์ดิค	27	โภปาล	8500
6	Komal	22	ส.ส.	4500
7	Muffy	24	อินดอร์	10,000
8	Lokesh	32	ไฮเดอราบาด	2500

ตอนนี้ให้เราพยายามอัปเดตบันทึกโดยใช้ไฟล์ Mergeคำสั่ง ต่อไปนี้เป็นรายละเอียดของบันทึกที่จะอัปเดต

ชื่อคอลัมน์	มูลค่า
ID	8
ชื่อ	โลกิ
อายุ	32
ที่อยู่	ไฮเดอราบาด
เงินเดือน	3000

ใช้แบบสอบถามต่อไปนี้เพื่อแทรกระเบียนที่กำหนดลงในแบบสอบถามฐานข้อมูล H2

MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Loki', 32, 'Hyderabad', 3000);

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

Update count: 1

ให้เราตรวจสอบบันทึกของตารางลูกค้าโดยดำเนินการค้นหาต่อไปนี้

SELECT * FROM CUSTOMER;

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้ -

ID	ชื่อ	อายุ	ที่อยู่	เงินเดือน
1	ราเมช	32	อาเมดาบัด	พ.ศ. 2543
2	คิลัน	25	เดลี	1,500
3	Kaushik	23	โคตะ	พ.ศ. 2543
4	Chaitali	25	มุมไบ	6500
5	ฮาร์ดิค	27	โภปาล	8500
6	Komal	22	ส.ส.	4500
7	Muffy	24	อินดอร์	10,000
8	โลกิ	32	ไฮเดอราบาด	3000

SHOW คือคำสั่งที่ใช้เพื่อแสดงรายการของ Schemas ตารางหรือคอลัมน์ของตาราง

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง SHOW

SHOW { SCHEMAS | TABLES [ FROM schemaName ] | 
COLUMNS FROM tableName [ FROM schemaName ] }

ตัวอย่าง

คำสั่งต่อไปนี้สามารถใช้เพื่อรับรายการตารางในฐานข้อมูลปัจจุบัน

SHOW TABLES;

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

TABLE_NAME	TABLE_SCHEMA
ลูกค้า	สาธารณะ
EMP	สาธารณะ

CREATE เป็นคำสั่ง SQL ทั่วไปที่ใช้ในการสร้างตารางสคีมาลำดับมุมมองและผู้ใช้ในเซิร์ฟเวอร์ฐานข้อมูล H2

สร้างตาราง

Create Table เป็นคำสั่งที่ใช้ในการสร้างตารางที่ผู้ใช้กำหนดเองในฐานข้อมูลปัจจุบัน

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปสำหรับคำสั่ง Create Table

CREATE [ CACHED | MEMORY ] [ TEMP | [ GLOBAL | LOCAL ] TEMPORARY ] 
TABLE [ IF NOT EXISTS ] name 
[ ( { columnDefinition | constraint } [,...] ) ] 
[ ENGINE tableEngineName [ WITH tableEngineParamName [,...] ] ] 
[ NOT PERSISTENT ] [ TRANSACTIONAL ] 
[ AS select ]

ด้วยการใช้ไวยากรณ์ทั่วไปของคำสั่งสร้างตารางเราสามารถสร้างตารางประเภทต่างๆเช่นตารางแคชตารางหน่วยความจำและตารางชั่วคราว ต่อไปนี้เป็นรายการเพื่ออธิบายประโยคต่างๆจากไวยากรณ์ที่กำหนด

• CACHED- ตารางแคชเป็นประเภทเริ่มต้นสำหรับตารางปกติ ซึ่งหมายความว่าจำนวนแถวไม่ได้ถูก จำกัด โดยหน่วยความจำหลัก

• MEMORY- ตารางหน่วยความจำเป็นประเภทเริ่มต้นสำหรับตารางชั่วคราว ซึ่งหมายความว่าตารางหน่วยความจำไม่ควรมีขนาดใหญ่เกินไปและข้อมูลดัชนีจะถูกเก็บไว้ในหน่วยความจำหลัก

• TEMPORARY- ตารางชั่วคราวจะถูกลบขณะปิดหรือเปิดฐานข้อมูล โดยทั่วไปตารางชั่วคราวมีสองประเภท -

  • ประเภท GLOBAL - เข้าถึงได้โดยการเชื่อมต่อทั้งหมด

  • ประเภทท้องถิ่น - เข้าถึงได้โดยการเชื่อมต่อปัจจุบัน

  ประเภทเริ่มต้นสำหรับตารางชั่วคราวคือประเภทส่วนกลาง ดัชนีของตารางชั่วคราวจะถูกเก็บไว้ในหน่วยความจำหลักเว้นแต่จะสร้างตารางชั่วคราวโดยใช้ CREATE CACHED TABLE

• ENGINE - จำเป็นต้องใช้ตัวเลือก ENGINE เมื่อใช้งานตารางแบบกำหนดเองเท่านั้น

• NOT PERSISTENT - เป็นตัวปรับแต่งเพื่อเก็บข้อมูลตารางที่สมบูรณ์ไว้ในหน่วยความจำและแถวทั้งหมดจะหายไปเมื่อปิดฐานข้อมูล

• TRANSACTIONAL - เป็นคีย์เวิร์ดที่ทำธุรกรรมแบบเปิดและคำสั่งนี้รองรับเฉพาะตารางชั่วคราว

ตัวอย่าง

ในตัวอย่างนี้ให้เราสร้างตารางชื่อ tutorials_tbl โดยใช้ข้อมูลที่กำหนดต่อไปนี้

ซีเนียร์ No	ชื่อคอลัมน์	ประเภทข้อมูล
1	ID	Int
2	หัวข้อ	วาร์ชาร์ (50)
3	ผู้เขียน	วาร์ชาร์ (20)
4	วันที่ยื่น	วันที่

แบบสอบถามต่อไปนี้ใช้เพื่อสร้างตาราง tutorials_tbl พร้อมกับข้อมูลคอลัมน์ที่กำหนด

CREATE TABLE tutorials_tbl ( 
   id INT NOT NULL, 
   title VARCHAR(50) NOT NULL, 
   author VARCHAR(20) NOT NULL, 
   submission_date DATE 
);

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

(0) rows effected

สร้างสคีมา

Create Schema คือคำสั่งที่ใช้ในการสร้าง schema ที่ขึ้นอยู่กับผู้ใช้ภายใต้การอนุญาตเฉพาะ (ภายใต้ผู้ใช้ที่ลงทะเบียนในปัจจุบัน)

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Create Schema

CREATE SCHEMA [ IF NOT EXISTS ] name [ AUTHORIZATION ownerUserName ]

ในไวยากรณ์ทั่วไปข้างต้น AUTHORIZATION เป็นคำหลักที่ใช้เพื่อระบุชื่อผู้ใช้ที่เกี่ยวข้อง คำสั่งนี้เป็นทางเลือกซึ่งหมายความว่าหากเราไม่ได้ระบุชื่อผู้ใช้คำสั่งนี้จะพิจารณาผู้ใช้ปัจจุบัน ผู้ใช้ที่ดำเนินการคำสั่งต้องมีสิทธิ์ของผู้ดูแลระบบเช่นเดียวกับเจ้าของ

คำสั่งนี้คอมมิตธุรกรรมเปิดในการเชื่อมต่อนี้

ตัวอย่าง

ในตัวอย่างนี้ให้เราสร้างสคีมาชื่อ test_schema ภายใต้ผู้ใช้ SA โดยใช้คำสั่งต่อไปนี้

CREATE SCHEMA test_schema AUTHORIZATION sa;

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

(0) rows effected

สร้างลำดับ

ลำดับคือแนวคิดที่ใช้ในการสร้างตัวเลขโดยทำตามลำดับสำหรับ id หรือค่าคอลัมน์แบบสุ่ม

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่งสร้างลำดับ

CREATE SEQUENCE [ IF NOT EXISTS ] newSequenceName [ START WITH long ] 
[ INCREMENT BY long ] 
[ MINVALUE long | NOMINVALUE | NO MINVALUE ] 
[ MAXVALUE long | NOMAXVALUE | NO MAXVALUE ] 
[ CYCLE long | NOCYCLE | NO CYCLE ] 
[ CACHE long | NOCACHE | NO CACHE ]

ไวยากรณ์ทั่วไปนี้ใช้เพื่อสร้างลำดับ ประเภทข้อมูลของลำดับคือBIGINT. ในลำดับนี้จะไม่มีการใช้ค่าซ้ำแม้ว่าธุรกรรมจะถูกย้อนกลับก็ตาม

ตัวอย่าง

ในตัวอย่างนี้ให้เราสร้างลำดับชื่อ SEQ_IDโดยใช้แบบสอบถามต่อไปนี้

CREATE SEQUENCE SEQ_ID;

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

(0) rows effected

ALTER เป็นคำสั่งที่ใช้ในการเปลี่ยนโครงสร้างตารางโดยการเพิ่มส่วนคำสั่งต่างๆลงในไฟล์ alterคำสั่ง ตามสถานการณ์เราจำเป็นต้องเพิ่มส่วนคำสั่งที่เกี่ยวข้องให้กับคำสั่ง alter ในบทนี้เราจะพูดถึงสถานการณ์ต่างๆของคำสั่งแก้ไข

แก้ไขตารางเพิ่ม

Alter Table Add เป็นคำสั่งที่ใช้ในการเพิ่มคอลัมน์ใหม่ในตารางพร้อมกับชนิดข้อมูลที่เกี่ยวข้อง คำสั่งนี้ทำธุรกรรมในการเชื่อมต่อนี้

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Alter Table Add

ALTER TABLE [ IF EXISTS ] tableName ADD [ COLUMN ] 
{ [ IF NOT EXISTS ] columnDefinition [ { BEFORE | AFTER } columnName ] 
   | ( { columnDefinition } [,...] ) }

ตัวอย่าง

ในตัวอย่างนี้เราจะเพิ่มคอลัมน์ใหม่ start_date ไปที่โต๊ะ tutorials_tbl. ประเภทข้อมูลสำหรับ start_date คือ Date ต่อไปนี้คือแบบสอบถามเพื่อเพิ่มคอลัมน์ใหม่

ALTER TABLE tutorials_tbl ADD start_date DATE;

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

(6) rows effected

แก้ไขข้อ จำกัด เพิ่มตาราง

Alter table add constraint เป็นคำสั่งที่ใช้ในการเพิ่มข้อ จำกัด ต่าง ๆ ให้กับตารางเช่นคีย์หลักคีย์นอกไม่ใช่ null เป็นต้น

ดัชนีที่จำเป็นจะถูกสร้างขึ้นโดยอัตโนมัติหากยังไม่มีอยู่ ไม่สามารถปิดการตรวจสอบข้อ จำกัด เฉพาะได้ คำสั่งนี้คอมมิตธุรกรรมเปิดในการเชื่อมต่อนี้

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Alter table add constraint

ALTER TABLE [ IF EXISTS ] tableName ADD constraint [ CHECK | NOCHECK ]

ตัวอย่าง

ในตัวอย่างนี้ให้เราเพิ่มข้อ จำกัด ของคีย์หลัก (tutorials_tbl_pk) ไปยังรหัสคอลัมน์ของตาราง tutorials_tblโดยใช้แบบสอบถามต่อไปนี้

ALTER TABLE tutorials_tbl ADD CONSTRAINT tutorials_tbl_pk PRIMARYKEY(id);

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

(6) row (s) effected

แก้ไขข้อ จำกัด การเปลี่ยนชื่อตาราง

คำสั่งนี้ใช้เพื่อเปลี่ยนชื่อข้อ จำกัด ของตารางความสัมพันธ์เฉพาะ คำสั่งนี้คอมมิตธุรกรรมเปิดในการเชื่อมต่อนี้

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Alter Table Rename Constraint

ALTER TABLE [ IF EXISTS ] tableName RENAME oldConstraintName TO newConstraintName

ในขณะที่ใช้ไวยากรณ์นี้ตรวจสอบให้แน่ใจว่าชื่อข้อ จำกัด เก่าควรมีอยู่ในคอลัมน์ที่เกี่ยวข้อง

ตัวอย่าง

ในตัวอย่างนี้เราจะเปลี่ยนชื่อข้อ จำกัด คีย์หลักของตาราง tutorials_tbl จาก tutorials_tbl_pk ถึง tutorials_tbl_pk_constraint. ต่อไปนี้เป็นแบบสอบถามที่จะทำ

ALTER TABLE tutorials_tbl RENAME CONSTRAINT 
tutorials_tbl_pk TO tutorials_tbl_pk_constraint;

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

(1) row (s) effected

แก้ไขคอลัมน์แก้ไขตาราง

คำสั่งนี้ใช้เพื่อเปลี่ยนโครงสร้างและคุณสมบัติของคอลัมน์ของตารางเฉพาะ การเปลี่ยนคุณสมบัติหมายถึงการเปลี่ยนประเภทข้อมูลของคอลัมน์เปลี่ยนชื่อคอลัมน์เปลี่ยนค่าข้อมูลประจำตัวหรือเปลี่ยนการเลือก

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Alter Table Alter Column

ALTER TABLE [ IF EXISTS ] tableName ALTER COLUMN columnName 
{ { dataType [ DEFAULT expression ] [ [ NOT ] NULL ] [ AUTO_INCREMENT | IDENTITY ] } 
| { RENAME TO name } 
| { RESTART WITH long } 
| { SELECTIVITY int } 
| { SET DEFAULT expression } 
| { SET NULL } 
| { SET NOT NULL } }

ในไวยากรณ์ข้างต้น -

• RESTART - คำสั่งเปลี่ยนค่าถัดไปของคอลัมน์การเพิ่มอัตโนมัติ

• SELECTIVITY- คำสั่งตั้งค่าการเลือก (1-100) สำหรับคอลัมน์ ขึ้นอยู่กับค่าการเลือกเราสามารถแสดงภาพค่าของคอลัมน์ได้

• SET DEFAULT - เปลี่ยนค่าเริ่มต้นของคอลัมน์

• SET NULL - ตั้งค่าคอลัมน์เพื่อให้เป็น NULL

• SET NOT NULL - ตั้งค่าคอลัมน์เพื่อให้ไม่เป็นโมฆะ

ตัวอย่าง

ในตัวอย่างนี้เราจะเปลี่ยนชื่อคอลัมน์ของตาราง tutorials_tbl จาก Title ถึง Tutorial_Title โดยใช้แบบสอบถามต่อไปนี้

ALTER TABLE tutorials_tbl ALTER COLUMN title RENAME TO tutorial_title;

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

(0) row(s) effected

ในทำนองเดียวกันเราสามารถดำเนินการสถานการณ์ต่างๆได้ด้วยคำสั่ง ALTER

DROP เป็นคำสั่งที่นำมาจากไวยากรณ์ SQL ทั่วไป คำสั่งนี้ใช้เพื่อลบส่วนประกอบฐานข้อมูลและโครงสร้างออกจากหน่วยความจำ มีสถานการณ์ที่แตกต่างกันด้วยคำสั่ง Drop ที่เราจะพูดถึงในบทนี้

วางตาราง

Drop Table เป็นคำสั่งที่ลบตารางตามลำดับและโครงสร้าง

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Drop Table

DROP TABLE [ IF EXISTS ] tableName [,...] [ RESTRICT | CASCADE ]

คำสั่งจะล้มเหลวหากเราใช้ RESTRICT และตารางที่มีมุมมองที่ขึ้นต่อกันอยู่ มุมมองที่อ้างอิงทั้งหมดจะถูกทิ้งเมื่อเราใช้คำหลัก CASCADE

ตัวอย่าง

ในตัวอย่างนี้เราจะวางตารางชื่อการทดสอบโดยใช้แบบสอบถามต่อไปนี้

DROP TABLE test;

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

(6) row (s) effected

วางสคีมา

Drop Schema คือคำสั่งที่ดร็อปสกีมาตามลำดับจากเซิร์ฟเวอร์ฐานข้อมูล มันจะไม่ทำงานจากสคีมาปัจจุบัน

ไวยากรณ์

DROP SCHEMA [ IF EXISTS ] schemaName

ตัวอย่าง

ในตัวอย่างนี้เราจะทิ้งสคีมาที่ชื่อ test_schema โดยใช้แบบสอบถามต่อไปนี้

DROP SCHEMA TEST_SCHEMA;

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

(0) row(s) effected

วางลำดับ

Drop Sequence เป็นคำสั่งที่ใช้ในการวางลำดับจากโครงสร้างตาราง

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Drop Sequence

DROP SEQUENCE [ IF EXISTS ] sequenceName

คำสั่งนี้คอมมิตธุรกรรมเปิดในการเชื่อมต่อนี้

ตัวอย่าง

ในตัวอย่างนี้เราจะวางลำดับที่ชื่อ sequence_id. ต่อไปนี้เป็นคำสั่ง

DROP SEQUENCE sequence_id;

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

(0) row (s) effected

Drop View

Drop View เป็นคำสั่งที่ใช้เพื่อวางมุมมองที่มีอยู่ มุมมองที่อ้างอิงทั้งหมดจะหายไปเช่นกันหากใช้ประโยค CASCADE

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Drop View

DROP VIEW [ IF EXISTS ] viewName [ RESTRICT | CASCADE ]

ตัวอย่าง

ในตัวอย่างนี้เราจะทิ้งมุมมองที่ชื่อ sample_view โดยใช้แบบสอบถามต่อไปนี้

DROP VIEW sample_view;

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

(0) row (s) effected

TRUNCATE เป็นคำสั่งที่ใช้ในการลบข้อมูลออกจากตาราง ไม่เหมือนกับ DELETE FROM ที่ไม่มีคำสั่ง WHERE คำสั่งนี้ไม่สามารถย้อนกลับได้ คำสั่งนี้คอมมิตธุรกรรมเปิดในการเชื่อมต่อนี้

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง truncate

TRUNCATE TABLE tableName

ตัวอย่าง

ในตัวอย่างนี้เราจะตัดตารางที่ชื่อ test โดยใช้แบบสอบถามต่อไปนี้

TRUNCATE TABLE test;

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

(6) row (s) effected

COMMIT เป็นคำสั่งจากไวยากรณ์ SQL ที่ใช้ในการคอมมิตธุรกรรม เราสามารถกระทำธุรกรรมเฉพาะหรือเราสามารถกระทำธุรกรรมที่ดำเนินการอยู่ในปัจจุบัน

ไวยากรณ์

มีไวยากรณ์สองแบบที่แตกต่างกันสำหรับคำสั่ง COMMIT

ต่อไปนี้เป็นไวยากรณ์ทั่วไปสำหรับคำสั่งคอมมิตเพื่อคอมมิตธุรกรรมปัจจุบัน

COMMIT [ WORK ]

ต่อไปนี้เป็นไวยากรณ์ทั่วไปสำหรับคำสั่งคอมมิตเพื่อคอมมิตธุรกรรมเฉพาะ

COMMIT TRANSACTION transactionName

ตัวอย่าง 1

ในตัวอย่างนี้ให้เราคอมมิตธุรกรรมปัจจุบันโดยใช้คำสั่งต่อไปนี้

COMMIT

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

Committed successfully

ตัวอย่าง 2

ในตัวอย่างนี้เราจะทำธุรกรรมที่ชื่อ tx_test โดยใช้คำสั่งต่อไปนี้

COMMIT TRANSACTION tx_test;

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

Committed successfully

Grant เป็นคำสั่งที่มาจากไวยากรณ์ SQL ที่ใช้เพื่อให้สิทธิ์แก่ตารางแก่ผู้ใช้หรือบทบาท ต้องมีสิทธิ์ผู้ดูแลระบบเพื่อดำเนินการคำสั่งนี้ คำสั่งนี้คอมมิตธุรกรรมเปิดในการเชื่อมต่อนี้

ในบทนี้เราจะพูดถึงสถานการณ์ต่างๆของคำสั่ง Grant

ให้สิทธิ์

Grant Right คือคำสั่งเพื่อให้สิทธิ์ผู้ดูแลระบบแก่ตารางแก่ผู้ใช้หรือบทบาท

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Grant

GRANT { SELECT | INSERT | UPDATE | DELETE | ALL } [,...] ON 
{ { SCHEMA schemaName } | { tableName [,...] } } 
TO { PUBLIC | userName | roleName }

ตัวอย่าง

ในตัวอย่างนี้เราจะให้ตารางทดสอบเป็นแบบอ่านอย่างเดียวโดยใช้คำสั่งต่อไปนี้

GRANT SELECT ON TEST TO READONLY

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

Grant successfully

ให้สิทธิ์แก้ไขสคีมาใด ๆ

Grant Alter Any Schema เป็นคำสั่งเพื่อให้สิทธิ์ในการแก้ไข schema แก่ผู้ใช้ที่เกี่ยวข้อง

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Grant Alter Any Schema

GRANT ALTER ANY SCHEMA TO userName

ตัวอย่าง

ในตัวอย่างนี้เราจะให้สิทธิ์ในการแก้ไขสคีมาแก่ผู้ใช้ที่ชื่อ test_user. ตรวจสอบให้แน่ใจว่ามี test_user อยู่ ต่อไปนี้เป็นแบบสอบถามเพื่อให้สิทธิ์ในการเปลี่ยนแปลง

GRANT ALTER ANY SCHEMA TO test_user;

แบบสอบถามข้างต้นสร้างผลลัพธ์ต่อไปนี้

Granted successfully to test_user

SAVEPOINT เป็นคำสั่งที่ใช้บันทึกธุรกรรมชั่วคราว เป็นการดีกว่าที่จะรักษาจุดประหยัดในการทำธุรกรรมของคุณเนื่องจากการย้อนกลับธุรกรรมไปยัง Savepoint ตามลำดับจะเป็นประโยชน์เมื่อจำเป็น

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Savepoint

SAVEPOINT savepointName

ตัวอย่าง

ในตัวอย่างนี้เราจะสร้าง Savepoint ชื่อ Half_Done โดยใช้คำสั่งต่อไปนี้

SAVEPOINT Half_Done;

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

Savepoint created

ROLLBACK เป็นคำสั่งจากไวยากรณ์ SQL ที่ใช้เพื่อย้อนกลับธุรกรรมไปยัง Savepoint หรือธุรกรรมก่อนหน้า ด้วยการใช้คำสั่งนี้เราสามารถย้อนกลับไปที่ Savepoint เฉพาะหรือเราสามารถย้อนกลับไปที่ธุรกรรมที่ดำเนินการก่อนหน้านี้

ไวยากรณ์

มีไวยากรณ์สองแบบที่แตกต่างกันสำหรับคำสั่ง ROLLABCK

ต่อไปนี้เป็นไวยากรณ์ทั่วไปสำหรับคำสั่งย้อนกลับ

ROLLBACK [ TO SAVEPOINT savepointName ]

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Rollback สำหรับธุรกรรมเฉพาะ

ROLLBACK TRANSACTION transactionName

ตัวอย่าง 1

ในตัวอย่างนี้เราจะย้อนกลับธุรกรรมปัจจุบันเป็น Savepoint ที่มีชื่อว่า sp1_test โดยใช้คำสั่งต่อไปนี้

ROLLBACK sp1_test;

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

Rollback successfully

ตัวอย่าง 2

ในตัวอย่างต่อไปนี้เราจะย้อนกลับธุรกรรมที่มีชื่อว่า tx_test โดยใช้คำสั่งที่กำหนด

ROLLBACK TRANSACTION tx_test;

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

Rollback successfully

H2 เป็นฐานข้อมูล JAVA เราสามารถโต้ตอบกับฐานข้อมูลนี้โดยใช้ JDBC ในบทนี้เราจะดูวิธีสร้างการเชื่อมต่อ JDBC กับฐานข้อมูล H2 และการดำเนินการ CRUD กับฐานข้อมูล H2

โดยทั่วไปมีห้าขั้นตอนในการสร้างการเชื่อมต่อ JDBC

Step 1 - การลงทะเบียนไดรเวอร์ฐานข้อมูล JDBC

Class.forName ("org.h2.Driver");

Step 2 - การเปิดการเชื่อมต่อ

Connection conn = DriverManager.getConnection ("jdbc:h2:~/test", "sa","");

Step 3 - การสร้างคำสั่ง

Statement st = conn.createStatement();

Step 4 - ดำเนินการคำสั่งและรับ Resultset

Stmt.executeUpdate("sql statement");

Step 5 - การปิดการเชื่อมต่อ

conn.close();

ก่อนที่จะดำเนินการสร้างโปรแกรมเต็มเราจำเป็นต้องเพิ่ม h2-1.4.192.jar fileเป็น CLASSPATH เราจะได้รับสิ่งนี้jar จากโฟลเดอร์ C:\Program Files (x86)\H2\bin.

สร้างตาราง

ในตัวอย่างนี้เราจะเขียนโปรแกรมสำหรับสร้างตาราง พิจารณาตารางที่มีชื่อว่าRegistration มีฟิลด์ต่อไปนี้

ส. เลขที่	ชื่อคอลัมน์	ประเภทข้อมูล	ไม่เป็นโมฆะ	คีย์หลัก
1	ID	จำนวน	ใช่	ใช่
2	อันดับแรก	วาร์ชาร์ (255)	ไม่	ไม่
3	ล่าสุด	วาร์ชาร์ (255)	ไม่	ไม่
4	อายุ	จำนวน	ไม่	ไม่

ต่อไปนี้เป็นโปรแกรมตัวอย่างชื่อ H2jdbcCreateDemo.

import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.SQLException; 
import java.sql.Statement;  

public class H2jdbcCreateDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   //  Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
  
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER); 
             
         //STEP 2: Open a connection 
         System.out.println("Connecting to database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         //STEP 3: Execute a query 
         System.out.println("Creating table in given database..."); 
         stmt = conn.createStatement(); 
         String sql =  "CREATE TABLE   REGISTRATION " + 
            "(id INTEGER not NULL, " + 
            " first VARCHAR(255), " +  
            " last VARCHAR(255), " +  
            " age INTEGER, " +  
            " PRIMARY KEY ( id ))";  
         stmt.executeUpdate(sql);
         System.out.println("Created table in given database..."); 
         
         // STEP 4: Clean-up environment 
         stmt.close(); 
         conn.close(); 
      } catch(SQLException se) { 
         //Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         //Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         //finally block used to close resources 
         try{ 
            if(stmt!=null) stmt.close(); 
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se){ 
            se.printStackTrace(); 
         } //end finally try 
      } //end try 
      System.out.println("Goodbye!");
   } 
}

บันทึกโปรแกรมข้างต้นลงใน H2jdbcCreateDemo.java คอมไพล์และรันโปรแกรมข้างต้นโดยดำเนินการคำสั่งต่อไปนี้ในพรอมต์คำสั่ง

\>javac H2jdbcCreateDemo.java 
\>java H2jdbcCreateDemo

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

Connecting to database... 
Creating table in given database... 
Created table in given database... 
Goodbye!

หลังจากการดำเนินการนี้เราสามารถตรวจสอบตารางที่สร้างโดยใช้อินเทอร์เฟซ H2 SQL

แทรกบันทึก

ในตัวอย่างนี้เราจะเขียนโปรแกรมสำหรับแทรกระเบียน ให้เราใส่บันทึกต่อไปนี้ลงในตารางการลงทะเบียน

ID	อันดับแรก	ล่าสุด	อายุ
100	ซาร่า	อาลี	18
101	มาห์นาซ	แฟตมา	25
102	Zaid	ข่าน	30
103	สุมิตร	Mital	28

ต่อไปนี้เป็นโปรแกรมตัวอย่างชื่อ H2jdbcInsertDemo.

import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.SQLException; 
import java.sql.Statement;  

public class H2jdbcInsertDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   //  Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
  
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try{
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER);  
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to a selected database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS); 
         System.out.println("Connected database successfully..."); 
         
         // STEP 3: Execute a query 
         stmt = conn.createStatement();  
         String sql = "INSERT INTO Registration " + "VALUES (100, 'Zara', 'Ali', 18)"; 
         
         stmt.executeUpdate(sql); 
         sql = "INSERT INTO Registration " + "VALUES (101, 'Mahnaz', 'Fatma', 25)";  
         
         stmt.executeUpdate(sql); 
         sql = "INSERT INTO Registration " + "VALUES (102, 'Zaid', 'Khan', 30)"; 
         
         stmt.executeUpdate(sql); 
         sql = "INSERT INTO Registration " + "VALUES(103, 'Sumit', 'Mittal', 28)"; 
         
         stmt.executeUpdate(sql); 
         System.out.println("Inserted records into the table..."); 
         
         // STEP 4: Clean-up environment 
         stmt.close(); 
         conn.close(); 
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources 
         try {
            if(stmt!=null) stmt.close();  
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try 
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

บันทึกโปรแกรมข้างต้นลงใน H2jdbcInsertDemo.java คอมไพล์และรันโปรแกรมข้างต้นโดยดำเนินการคำสั่งต่อไปนี้ในพรอมต์คำสั่ง

\>javac H2jdbcInsertDemo.java 
\>java H2jdbcInsertDemo

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

Connecting to a selected database... 
Connected database successfully... 
Inserted records into the table... 
Goodbye!

อ่านบันทึก

ในตัวอย่างนี้เราจะเขียนโปรแกรมสำหรับการอ่านบันทึก ให้เราพยายามอ่านบันทึกทั้งหมดจากตารางRegistration.

ต่อไปนี้เป็นโปรแกรมตัวอย่างชื่อ H2jdbcRecordDemo.

import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.sql.Statement;  

public class H2jdbcReadDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   //  Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
   
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER); 
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         // STEP 3: Execute a query 
         System.out.println("Connected database successfully..."); 
         stmt = conn.createStatement(); 
         String sql = "SELECT id, first, last, age FROM Registration"; 
         ResultSet rs = stmt.executeQuery(sql); 
         
         // STEP 4: Extract data from result set 
         while(rs.next()) { 
            // Retrieve by column name 
            int id  = rs.getInt("id"); 
            int age = rs.getInt("age"); 
            String first = rs.getString("first"); 
            String last = rs.getString("last");  
            
            // Display values 
            System.out.print("ID: " + id); 
            System.out.print(", Age: " + age); 
            System.out.print(", First: " + first); 
            System.out.println(", Last: " + last); 
         } 
         // STEP 5: Clean-up environment 
         rs.close(); 
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources 
         try { 
            if(stmt!=null) stmt.close();  
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try 
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

บันทึกโปรแกรมข้างต้นลงใน H2jdbcReadDemo.java คอมไพล์และรันโปรแกรมข้างต้นโดยดำเนินการคำสั่งต่อไปนี้ในพรอมต์คำสั่ง

\>javac H2jdbcReadDemo.java 
\>java H2jdbcReadDemo

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

Connecting to a selected database... 
Connected database successfully... 
ID: 100, Age: 18, First: Zara, Last: Ali 
ID: 101, Age: 25, First: Mahnaz, Last: Fatma 
ID: 102, Age: 30, First: Zaid, Last: Khan 
ID: 103, Age: 28, First: Sumit, Last: Mittal 
Goodbye!

อัปเดตบันทึก

ในตัวอย่างนี้เราจะเขียนโปรแกรมเพื่อปรับปรุงระเบียน ให้เราพยายามอ่านบันทึกทั้งหมดจากตารางRegistration.

ต่อไปนี้เป็นโปรแกรมตัวอย่างชื่อ H2jdbcUpdateDemo.

import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.sql.Statement;  

public class H2jdbcUpdateDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   // Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
   
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER); 
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to a database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         // STEP 3: Execute a query 
         System.out.println("Connected database successfully..."); 
         stmt = conn.createStatement(); 
         String sql = "UPDATE Registration " + "SET age = 30 WHERE id in (100, 101)"; 
         stmt.executeUpdate(sql);  
         
         // Now you can extract all the records 
         // to see the updated records 
         sql = "SELECT id, first, last, age FROM Registration"; 
         ResultSet rs = stmt.executeQuery(sql);  
         
         while(rs.next()){ 
            // Retrieve by column name 
            int id  = rs.getInt("id"); 
            int age = rs.getInt("age"); 
            String first = rs.getString("first"); 
            String last = rs.getString("last");  
            
            // Display values 
            System.out.print("ID: " + id); 
            System.out.print(", Age: " + age); 
            System.out.print(", First: " + first); 
            System.out.println(", Last: " + last); 
         } 
         rs.close();    
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources  
         try { 
            if(stmt!=null) stmt.close(); 
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try 
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

บันทึกโปรแกรมข้างต้นลงใน H2jdbcUpdateDemo.java คอมไพล์และรันโปรแกรมข้างต้นโดยดำเนินการคำสั่งต่อไปนี้ในพรอมต์คำสั่ง

\>javac H2jdbcUpdateDemo.java 
\>java H2jdbcUpdateDemo

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

Connecting to a selected database... 
Connected database successfully... 
ID: 100, Age: 30, First: Zara, Last: Ali 
ID: 101, Age: 30, First: Mahnaz, Last: Fatma 
ID: 102, Age: 30, First: Zaid, Last: Khan 
ID: 103, Age: 28, First: Sumit, Last: Mittal 
Goodbye!

ลบบันทึก

ในตัวอย่างนี้เราจะเขียนโปรแกรมเพื่อลบบันทึก ให้เราพยายามอ่านบันทึกทั้งหมดจากตารางRegistration.

ต่อไปนี้เป็นโปรแกรมตัวอย่างชื่อ H2jdbcDeleteDemo.

import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.sql.Statement;  

public class H2jdbcDeleteDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   // Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
  
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER);  
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         // STEP 3: Execute a query
         System.out.println("Creating table in given database..."); 
         stmt = conn.createStatement();  
         String sql = "DELETE FROM Registration " + "WHERE id = 101"; 
         stmt.executeUpdate(sql);  
         
         // Now you can extract all the records 
         // to see the remaining records 
         sql = "SELECT id, first, last, age FROM Registration"; 
         ResultSet rs = stmt.executeQuery(sql);  
         
         while(rs.next()){ 
            // Retrieve by column name 
            int id  = rs.getInt("id"); 
            int age = rs.getInt("age"); 
            String first = rs.getString("first"); 
            String last = rs.getString("last");  
            
            // Display values 
            System.out.print("ID: " + id); 
            System.out.print(", Age: " + age); 
            System.out.print(", First: " + first); 
            System.out.println(", Last: " + last); 
         } 
         rs.close(); 
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace();  
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources 
         try { 
            if(stmt!=null) stmt.close(); 
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

บันทึกโปรแกรมข้างต้นลงใน H2jdbcDeleteDemo.java คอมไพล์และรันโปรแกรมข้างต้นโดยดำเนินการคำสั่งต่อไปนี้ในพรอมต์คำสั่ง

\>javac H2jdbcDeleteDemo.java 
\>java H2jdbcDeleteDemo

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้

Connecting to a selected database... 
Connected database successfully... 
ID: 100, Age: 30, First: Zara, Last: Ali 
ID: 102, Age: 30, First: Zaid, Last: Khan 
ID: 103, Age: 28, First: Sumit, Last: Mittal 
Goodbye!