SQLite - คู่มือฉบับย่อ

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

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

SQLite คืออะไร?

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

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

ทำไมต้อง SQLite

• SQLite ไม่ต้องการกระบวนการหรือระบบเซิร์ฟเวอร์แยกต่างหากในการดำเนินการ (แบบไร้เซิร์ฟเวอร์)

• SQLite มาพร้อมกับการกำหนดค่าเป็นศูนย์ซึ่งหมายความว่าไม่จำเป็นต้องมีการตั้งค่าหรือการดูแลระบบ

• ฐานข้อมูล SQLite ที่สมบูรณ์จะถูกเก็บไว้ในไฟล์ดิสก์ข้ามแพลตฟอร์มเดียว

• SQLite มีขนาดเล็กมากและน้ำหนักเบาน้อยกว่า 400KiB ที่กำหนดค่าไว้อย่างสมบูรณ์หรือน้อยกว่า 250KiB โดยไม่ใส่คุณสมบัติเสริม

• SQLite มีอยู่ในตัวซึ่งหมายความว่าไม่มีการอ้างอิงภายนอก

• ธุรกรรม SQLite เป็นไปตาม ACID โดยสมบูรณ์ทำให้สามารถเข้าถึงได้อย่างปลอดภัยจากหลายกระบวนการหรือเธรด

• SQLite สนับสนุนคุณลักษณะภาษาแบบสอบถามส่วนใหญ่ที่พบในมาตรฐาน SQL92 (SQL2)

• SQLite เขียนด้วย ANSI-C และมี API ที่เรียบง่ายและใช้งานง่าย

• SQLite พร้อมใช้งานบน UNIX (Linux, Mac OS-X, Android, iOS) และ Windows (Win32, WinCE, WinRT)

SQLite ประวัติโดยย่อ

• 2000 - D. Richard Hipp ออกแบบ SQLite เพื่อวัตถุประสงค์ในการดูแลระบบที่ไม่จำเป็นสำหรับการใช้งานโปรแกรม

• 2000 - ในเดือนสิงหาคม SQLite 1.0 เปิดตัวพร้อม GNU Database Manager

• 2554 - Hipp ประกาศเพิ่มอินเทอร์เฟซ UNQl ให้กับ SQLite DB และพัฒนา UNQLite (ฐานข้อมูลเชิงเอกสาร)

ข้อ จำกัด SQLite

มีคุณลักษณะที่ไม่สนับสนุนบางประการของ SQL92 ใน SQLite ซึ่งแสดงอยู่ในตารางต่อไปนี้

ซีเนียร์	คุณสมบัติและคำอธิบาย
1	RIGHT OUTER JOIN ใช้เฉพาะ LEFT OUTER JOIN เท่านั้น
2	FULL OUTER JOIN ใช้เฉพาะ LEFT OUTER JOIN เท่านั้น
3	ALTER TABLE รองรับตัวแปร RENAME TABLE และ ADD COLUMN ของคำสั่ง ALTER TABLE ไม่รองรับ DROP COLUMN, ALTER COLUMN, ADD CONSTRAINT
4	Trigger support สำหรับทริกเกอร์แต่ละแถวได้รับการสนับสนุน แต่ไม่ใช่สำหรับทริกเกอร์แต่ละรายการ
5	VIEWs VIEW ใน SQLite เป็นแบบอ่านอย่างเดียว คุณไม่สามารถดำเนินการคำสั่ง DELETE, INSERT หรือ UPDATE ในมุมมองได้
6	GRANT and REVOKE สิทธิ์การเข้าถึงเดียวที่สามารถใช้ได้คือสิทธิ์การเข้าถึงไฟล์ปกติของระบบปฏิบัติการที่ใช้อยู่

คำสั่ง SQLite

คำสั่ง SQLite มาตรฐานเพื่อโต้ตอบกับฐานข้อมูลเชิงสัมพันธ์คล้ายกับ SQL พวกเขาสร้างเลือกแทรกอัปเดตลบและปล่อย คำสั่งเหล่านี้สามารถแบ่งออกเป็นกลุ่มตามลักษณะการทำงาน -

DDL - ภาษานิยามข้อมูล

ซีเนียร์	คำสั่งและคำอธิบาย
1	CREATE สร้างตารางใหม่มุมมองของตารางหรือวัตถุอื่น ๆ ในฐานข้อมูล
2	ALTER แก้ไขอ็อบเจ็กต์ฐานข้อมูลที่มีอยู่เช่นตาราง
3	DROP ลบทั้งตารางมุมมองของตารางหรือวัตถุอื่น ๆ ในฐานข้อมูล

DML - ภาษาการจัดการข้อมูล

ซีเนียร์	คำสั่งและคำอธิบาย
1	INSERT สร้างบันทึก
2	UPDATE แก้ไขบันทึก
3	DELETE ลบบันทึก

DQL - ภาษาแบบสอบถามข้อมูล

ซีเนียร์	คำสั่งและคำอธิบาย
1	SELECT ดึงข้อมูลบางรายการจากตารางอย่างน้อยหนึ่งตาราง

SQLite มีชื่อเสียงในด้านการกำหนดค่าเป็นศูนย์ซึ่งหมายความว่าไม่จำเป็นต้องมีการตั้งค่าหรือการดูแลระบบที่ซับซ้อน บทนี้จะนำคุณเข้าสู่ขั้นตอนการตั้งค่า SQLite บน Windows, Linux และ Mac OS X

ติดตั้ง SQLite บน Windows

• Step 1- ไปที่หน้าดาวน์โหลด SQLiteและดาวน์โหลดไบนารีที่คอมไพล์ไว้ล่วงหน้าจากส่วน Windows

• Step 2 - ดาวน์โหลดไฟล์ sqlite-shell-win32 - *. zip และ sqlite-dll-win32 - *. zip

• Step 3 - สร้างโฟลเดอร์ C: \> sqlite และคลายซิปเหนือไฟล์ซิปสองไฟล์ในโฟลเดอร์นี้ซึ่งจะให้ไฟล์ sqlite3.def, sqlite3.dll และ sqlite3.exe

• Step 4 - เพิ่ม C: \> sqlite ในตัวแปรสภาพแวดล้อม PATH ของคุณและสุดท้ายไปที่พรอมต์คำสั่งและออกคำสั่ง sqlite3 ซึ่งจะแสดงผลลัพธ์ต่อไปนี้

C:\>sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

ติดตั้ง SQLite บน Linux

ทุกวันนี้ Linux OS เกือบทุกรสชาติถูกส่งมาพร้อมกับ SQLite ดังนั้นคุณเพียงแค่ใช้คำสั่งต่อไปนี้เพื่อตรวจสอบว่าคุณได้ติดตั้ง SQLite ในเครื่องของคุณแล้วหรือไม่

$sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

หากคุณไม่เห็นผลลัพธ์ข้างต้นแสดงว่าคุณไม่ได้ติดตั้ง SQLite บนเครื่อง Linux ของคุณ ต่อไปนี้เป็นขั้นตอนต่อไปนี้เพื่อติดตั้ง SQLite -

• Step 1- ไปที่หน้าดาวน์โหลด SQLiteและดาวน์โหลด sqlite-autoconf - *. tar.gz จากส่วนซอร์สโค้ด

• Step 2 - เรียกใช้คำสั่งต่อไปนี้ -

$tar xvfz sqlite-autoconf-3071502.tar.gz
$cd sqlite-autoconf-3071502 $./configure --prefix=/usr/local
$make $make install

คำสั่งดังกล่าวจะจบลงด้วยการติดตั้ง SQLite บนเครื่อง Linux ของคุณ ซึ่งคุณสามารถตรวจสอบได้ตามที่อธิบายไว้ข้างต้น

ติดตั้ง SQLite บน Mac OS X

แม้ว่า Mac OS X เวอร์ชันล่าสุดจะมาพร้อมกับ SQLite แต่หากคุณไม่มีการติดตั้งให้ทำตามขั้นตอนต่อไปนี้ -

• Step 1- ไปที่หน้าดาวน์โหลด SQLiteและดาวน์โหลด sqlite-autoconf - *. tar.gz จากส่วนซอร์สโค้ด

• Step 2 - เรียกใช้คำสั่งต่อไปนี้ -

$tar xvfz sqlite-autoconf-3071502.tar.gz $cd sqlite-autoconf-3071502
$./configure --prefix=/usr/local $make
$make install

ขั้นตอนข้างต้นจะจบลงด้วยการติดตั้ง SQLite บนเครื่อง Mac OS X ของคุณ ซึ่งคุณสามารถตรวจสอบได้โดยใช้คำสั่งต่อไปนี้ -

$sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

สุดท้ายคุณมีพรอมต์คำสั่ง SQLite ซึ่งคุณสามารถออกคำสั่ง SQLite สำหรับแบบฝึกหัดของคุณได้

บทนี้จะนำคุณไปสู่คำสั่งง่ายๆและมีประโยชน์ที่โปรแกรมเมอร์ SQLite ใช้ คำสั่งเหล่านี้เรียกว่าคำสั่ง SQLite dot และข้อยกเว้นสำหรับคำสั่งเหล่านี้คือไม่ควรสิ้นสุดด้วยเครื่องหมายอัฒภาค (;)

เริ่มต้นด้วยการพิมพ์ง่ายๆ sqlite3 คำสั่งที่พร้อมรับคำสั่งซึ่งจะให้พรอมต์คำสั่ง SQLite ซึ่งคุณจะออกคำสั่ง SQLite ต่างๆ

$sqlite3
SQLite version 3.3.6
Enter ".help" for instructions
sqlite>

สำหรับรายการคำสั่ง dot ที่ใช้ได้คุณสามารถป้อน ".help" ได้ทุกเมื่อ ตัวอย่างเช่น -

sqlite>.help

คำสั่งดังกล่าวจะแสดงรายการคำสั่ง SQLite dot ที่สำคัญต่างๆซึ่งแสดงอยู่ในตารางต่อไปนี้

ซีเนียร์	คำสั่งและคำอธิบาย
1	.backup ?DB? FILE ฐานข้อมูลสำรอง (ค่าเริ่มต้น "หลัก") ไปยัง FILE
2	.bail ON|OFF หยุดหลังจากกดปุ่มข้อผิดพลาด ค่าเริ่มต้นปิด
3	.databases แสดงรายชื่อและไฟล์ของฐานข้อมูลที่แนบมา
4	.dump ?TABLE? ถ่ายโอนฐานข้อมูลในรูปแบบข้อความ SQL หากระบุ TABLE เฉพาะตารางการถ่ายโอนข้อมูลที่ตรงกับรูปแบบ LIKE TABLE
5	.echo ON|OFF เปิดหรือปิดเสียงสะท้อนคำสั่ง
6	.exit ออกจากพรอมต์ SQLite
7	.explain ON|OFF เปิดหรือปิดโหมดเอาต์พุตที่เหมาะสำหรับ EXPLAIN เมื่อไม่มี args มันจะเปิด EXPLAIN
8	.header(s) ON|OFF เปิดหรือปิดการแสดงส่วนหัว
9	.help แสดงข้อความนี้
10	.import FILE TABLE นำเข้าข้อมูลจาก FILE ไปยัง TABLE
11	.indices ?TABLE? แสดงชื่อของดัชนีทั้งหมด หากระบุ TABLE แสดงเฉพาะดัชนีสำหรับตารางที่ตรงกับรูปแบบ LIKE TABLE
12	.load FILE ?ENTRY? โหลดไลบรารีส่วนขยาย
13	.log FILE|off เปิดหรือปิดการบันทึก FILE สามารถเป็น stderr / stdout
14	.mode MODE ตั้งค่าโหมดเอาต์พุตโดยที่ MODE เป็นหนึ่งใน - csv - ค่าที่คั่นด้วยจุลภาค column - คอลัมน์ชิดซ้าย html - โค้ด HTML <table> insert - คำสั่งแทรก SQL สำหรับ TABLE line - หนึ่งค่าต่อบรรทัด list - ค่าที่คั่นด้วยสตริง. ตัวแยก tabs - ค่าที่คั่นด้วยแท็บ tcl - องค์ประกอบรายการ TCL
15	.nullvalue STRING พิมพ์ STRING แทนค่า NULL
16	.output FILENAME ส่งเอาต์พุตไปที่ FILENAME
17	.output stdout ส่งเอาต์พุตไปที่หน้าจอ
18	.print STRING... พิมพ์ตามตัวอักษร STRING
19	.prompt MAIN CONTINUE แทนที่ข้อความแจ้งมาตรฐาน
20	.quit ออกจากพรอมต์ SQLite
21	.read FILENAME ดำเนินการ SQL ใน FILENAME
22	.schema ?TABLE? แสดงคำสั่ง CREATE หากระบุ TABLE แสดงเฉพาะตารางที่ตรงกับรูปแบบ LIKE TABLE
23	.separator STRING เปลี่ยนตัวคั่นที่ใช้โดยโหมดเอาต์พุตและ. นำเข้า
24	.show แสดงค่าปัจจุบันสำหรับการตั้งค่าต่างๆ
25	.stats ON|OFF เปิดหรือปิดสถิติ
26	.tables ?PATTERN? รายชื่อตารางที่ตรงกับรูปแบบ LIKE
27	.timeout MS ลองเปิดตารางที่ล็อกไว้สำหรับ MS มิลลิวินาที
28	.width NUM NUM ตั้งค่าความกว้างของคอลัมน์สำหรับโหมด "คอลัมน์"
29	.timer ON|OFF เปิดหรือปิดการวัดตัวจับเวลา CPU

มาลองกัน .show คำสั่งเพื่อดูการตั้งค่าเริ่มต้นสำหรับพรอมต์คำสั่ง SQLite ของคุณ

sqlite>.show
     echo: off
  explain: off
  headers: off
     mode: column
nullvalue: ""
   output: stdout
separator: "|"
    width:
sqlite>

ตรวจสอบให้แน่ใจว่าไม่มีช่องว่างระหว่างคำสั่ง sqlite> prompt และ dot มิฉะนั้นจะไม่ทำงาน

การจัดรูปแบบเอาต์พุต

คุณสามารถใช้ลำดับคำสั่ง dot ต่อไปนี้เพื่อจัดรูปแบบผลลัพธ์ของคุณ

sqlite>.header on
sqlite>.mode column
sqlite>.timer on
sqlite>

การตั้งค่าข้างต้นจะให้ผลลัพธ์ในรูปแบบต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
CPU Time: user 0.000000 sys 0.000000

ตาราง sqlite_master

ตารางหลักเก็บข้อมูลสำคัญเกี่ยวกับตารางฐานข้อมูลของคุณและเรียกว่า sqlite_master. คุณสามารถดูสคีมาได้ดังนี้ -

sqlite>.schema sqlite_master

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

CREATE TABLE sqlite_master (
   type text,
   name text,
   tbl_name text,
   rootpage integer,
   sql text
);

SQLite ตามด้วยชุดกฎและแนวทางเฉพาะที่เรียกว่า Syntax บทนี้แสดงรายการไวยากรณ์ SQLite พื้นฐานทั้งหมด

ความไวกรณี

จุดสำคัญที่ต้องสังเกตคือ SQLite คือ case insensitiveกล่าวคือประโยค GLOB และ glob มีความหมายเหมือนกันในคำสั่ง SQLite

ความคิดเห็น

ความคิดเห็น SQLite เป็นบันทึกพิเศษซึ่งคุณสามารถเพิ่มในรหัส SQLite ของคุณเพื่อเพิ่มความสามารถในการอ่านและสามารถปรากฏได้ทุกที่ ช่องว่างสามารถเกิดขึ้นได้รวมถึงนิพจน์ภายในและอยู่ตรงกลางของคำสั่ง SQL อื่น ๆ แต่ไม่สามารถซ้อนกันได้

ความคิดเห็น SQL เริ่มต้นด้วยอักขระ "-" สองตัวต่อเนื่องกัน (ASCII 0x2d) และขยายไปจนถึงและรวมถึงอักขระขึ้นบรรทัดใหม่ถัดไป (ASCII 0x0a) หรือจนกว่าจะสิ้นสุดการป้อนข้อมูลแล้วแต่ว่ากรณีใดจะเกิดขึ้นก่อน

คุณยังสามารถใช้ความคิดเห็นรูปแบบ C ซึ่งขึ้นต้นด้วย "/ *" และขยายได้ถึงและรวมคู่อักขระ "* /" ถัดไปหรือจนกว่าจะสิ้นสุดการป้อนข้อมูลแล้วแต่ว่ากรณีใดจะเกิดขึ้นก่อน ความคิดเห็นรูปแบบ C สามารถขยายได้หลายบรรทัด

sqlite> .help -- This is a single line comment

คำสั่ง SQLite

คำสั่ง SQLite ทั้งหมดเริ่มต้นด้วยคำสำคัญใด ๆ เช่น SELECT, INSERT, UPDATE, DELETE, ALTER, DROP เป็นต้นและคำสั่งทั้งหมดจะลงท้ายด้วยอัฒภาค (;)

คำสั่ง SQLite ANALYZE

ANALYZE;
or
ANALYZE database_name;
or
ANALYZE database_name.table_name;

SQLite AND / OR Clause

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION-1 {AND|OR} CONDITION-2;

คำสั่ง SQLite ALTER TABLE

ALTER TABLE table_name ADD COLUMN column_def...;

คำสั่ง SQLite ALTER TABLE (เปลี่ยนชื่อ)

ALTER TABLE table_name RENAME TO new_table_name;

คำสั่ง SQLite ATTACH DATABASE

ATTACH DATABASE 'DatabaseName' As 'Alias-Name';

คำสั่ง SQLite BEGIN TRANSACTION

BEGIN;
or
BEGIN EXCLUSIVE TRANSACTION;

SQLite ระหว่างข้อ

SELECT column1, column2....columnN
FROM table_name
WHERE column_name BETWEEN val-1 AND val-2;

คำสั่ง SQLite COMMIT

COMMIT;

SQLite สร้างคำสั่ง INDEX

CREATE INDEX index_name
ON table_name ( column_name COLLATE NOCASE );

SQLite สร้างคำสั่งดัชนีที่ไม่ซ้ำกัน

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);

คำสั่งสร้างตาราง SQLite

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
   PRIMARY KEY( one or more columns )
);

SQLite สร้างคำสั่ง TRIGGER

CREATE TRIGGER database_name.trigger_name 
BEFORE INSERT ON table_name FOR EACH ROW
BEGIN 
   stmt1; 
   stmt2;
   ....
END;

SQLite สร้างคำสั่ง VIEW

CREATE VIEW database_name.view_name AS
SELECT statement....;

SQLite สร้างคำสั่ง VIRTUAL TABLE

CREATE VIRTUAL TABLE database_name.table_name USING weblog( access.log );
or
CREATE VIRTUAL TABLE database_name.table_name USING fts3( );

คำสั่ง SQLite COMMIT TRANSACTION

COMMIT;

SQLite COUNT Clause

SELECT COUNT(column_name)
FROM table_name
WHERE CONDITION;

คำสั่ง SQLite DELETE

DELETE FROM table_name
WHERE {CONDITION};

คำสั่ง SQLite DETACH DATABASE

DETACH DATABASE 'Alias-Name';

SQLite DISTINCT Clause

SELECT DISTINCT column1, column2....columnN
FROM table_name;

คำสั่ง SQLite DROP INDEX

DROP INDEX database_name.index_name;

คำสั่ง SQLite DROP TABLE

DROP TABLE database_name.table_name;

คำสั่ง SQLite DROP VIEW

DROP INDEX database_name.view_name;

คำสั่ง SQLite DROP TRIGGER

DROP INDEX database_name.trigger_name;

SQLite EXISTS Clause

SELECT column1, column2....columnN
FROM table_name
WHERE column_name EXISTS (SELECT * FROM   table_name );

คำสั่ง SQLite EXPLAIN

EXPLAIN INSERT statement...;
or 
EXPLAIN QUERY PLAN SELECT statement...;

SQLite GLOB Clause

SELECT column1, column2....columnN
FROM table_name
WHERE column_name GLOB { PATTERN };

SQLite GROUP ตามข้อ

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name;

SQLite HAVING Clause

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name
HAVING (arithematic function condition);

คำสั่ง SQLite INSERT INTO

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);

SQLite ในข้อ

SELECT column1, column2....columnN
FROM table_name
WHERE column_name IN (val-1, val-2,...val-N);

SQLite Like Clause

SELECT column1, column2....columnN
FROM table_name
WHERE column_name LIKE { PATTERN };

SQLite ไม่อยู่ในข้อ

SELECT column1, column2....columnN
FROM table_name
WHERE column_name NOT IN (val-1, val-2,...val-N);

SQLite ORDER ตามข้อ

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION
ORDER BY column_name {ASC|DESC};

คำสั่ง SQLite PRAGMA

PRAGMA pragma_name;

For example:

PRAGMA page_size;
PRAGMA cache_size = 1024;
PRAGMA table_info(table_name);

คำสั่ง SQLite RELEASE SAVEPOINT

RELEASE savepoint_name;

คำสั่ง SQLite REINDEX

REINDEX collation_name;
REINDEX database_name.index_name;
REINDEX database_name.table_name;

คำสั่ง SQLite ROLLBACK

ROLLBACK;
or
ROLLBACK TO SAVEPOINT savepoint_name;

คำสั่ง SQLite SAVEPOINT

SAVEPOINT savepoint_name;

คำสั่ง SQLite SELECT

SELECT column1, column2....columnN
FROM table_name;

คำสั่ง SQLite UPDATE

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE  CONDITION ];

คำสั่ง SQLite VACUUM

VACUUM;

SQLite WHERE Clause

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION;

ชนิดข้อมูล SQLite เป็นแอตทริบิวต์ที่ระบุประเภทข้อมูลของวัตถุใด ๆ แต่ละคอลัมน์ตัวแปรและนิพจน์มีชนิดข้อมูลที่เกี่ยวข้องใน SQLite

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

คลาสพื้นที่จัดเก็บ SQLite

แต่ละค่าที่จัดเก็บในฐานข้อมูล SQLite มีคลาสหน่วยเก็บข้อมูลต่อไปนี้ -

ซีเนียร์	ประเภทการจัดเก็บและคำอธิบาย
1	NULL ค่านี้เป็นค่า NULL
2	INTEGER ค่านี้เป็นจำนวนเต็มลงนามซึ่งเก็บไว้ใน 1, 2, 3, 4, 6 หรือ 8 ไบต์ขึ้นอยู่กับขนาดของค่า
3	REAL ค่านี้เป็นค่าทศนิยมที่จัดเก็บเป็นเลขทศนิยม 8 ไบต์ IEEE
4	TEXT ค่านี้เป็นสตริงข้อความที่จัดเก็บโดยใช้การเข้ารหัสฐานข้อมูล (UTF-8, UTF-16BE หรือ UTF-16LE)
5	BLOB ค่านี้เป็นหยดข้อมูลที่จัดเก็บไว้ตรงตามที่ป้อนข้อมูล

คลาสพื้นที่จัดเก็บ SQLite นั้นกว้างกว่าประเภทข้อมูลเล็กน้อย ตัวอย่างเช่นคลาสหน่วยเก็บข้อมูล INTEGER มีประเภทข้อมูลจำนวนเต็ม 6 ชนิดที่มีความยาวต่างกัน

SQLite Affinity Type

SQLite สนับสนุนแนวคิดของ type affinityบนคอลัมน์ คอลัมน์ใด ๆ ยังคงสามารถจัดเก็บข้อมูลประเภทใดก็ได้ แต่คลาสพื้นที่เก็บข้อมูลที่ต้องการสำหรับคอลัมน์นั้นเรียกว่าaffinity. แต่ละคอลัมน์ของตารางในฐานข้อมูล SQLite3 ได้รับการกำหนดความสัมพันธ์ประเภทใดประเภทหนึ่งต่อไปนี้ -

ซีเนียร์	ผู้สนใจและคำอธิบาย
1	TEXT คอลัมน์นี้เก็บข้อมูลทั้งหมดโดยใช้คลาสการจัดเก็บ NULL, TEXT หรือ BLOB
2	NUMERIC คอลัมน์นี้อาจมีค่าโดยใช้คลาสพื้นที่เก็บข้อมูลทั้งห้าคลาส
3	INTEGER ทำงานเหมือนกับคอลัมน์ที่มีความสัมพันธ์แบบ NUMERIC โดยมีข้อยกเว้นในนิพจน์ CAST
4	REAL ทำตัวเหมือนคอลัมน์ที่มีความสัมพันธ์แบบ NUMERIC ยกเว้นว่าจะบังคับให้ค่าจำนวนเต็มเป็นการแสดงจุดลอยตัว
5	NONE คอลัมน์ที่มีความสัมพันธ์ NONE ไม่ชอบคลาสหน่วยเก็บหนึ่งมากกว่าอีกคลาสหนึ่งและไม่มีความพยายามที่จะบังคับข้อมูลจากคลาสหน่วยเก็บหนึ่งไปยังอีกคลาส

SQLite Affinity และ Type Names

ตารางต่อไปนี้แสดงชื่อชนิดข้อมูลต่างๆที่สามารถใช้ในขณะสร้างตาราง SQLite3 ด้วยความสัมพันธ์ที่ใช้ที่สอดคล้องกัน

ประเภทข้อมูล	ความสัมพันธ์กัน
INT INTEGER TINYINT SMALLINT MEDIUMINT BIGINT INT ขนาดใหญ่ที่ไม่ได้ลงนาม INT2 INT8	จำนวนเต็ม
CHARACTER(20) VARCHAR(255) ตัวละครที่แตกต่างกัน (255) NCHAR(55) ตัวละครธรรมชาติ (70) NVARCHAR(100) TEXT CLOB	TEXT
BLOB ไม่ได้ระบุประเภทข้อมูล	ไม่มี
REAL DOUBLE ความแม่นยำสองเท่า FLOAT	จริง
NUMERIC DECIMAL(10,5) BOOLEAN DATE DATETIME	NUMERIC

ประเภทข้อมูลบูลีน

SQLite ไม่มีคลาสหน่วยเก็บข้อมูลบูลีนแยกต่างหาก แทนค่าบูลีนจะถูกเก็บเป็นจำนวนเต็ม 0 (เท็จ) และ 1 (จริง)

ประเภทข้อมูลวันที่และเวลา

SQLite ไม่มีคลาสพื้นที่จัดเก็บแยกต่างหากสำหรับจัดเก็บวันที่และ / หรือเวลา แต่ SQLite สามารถจัดเก็บวันที่และเวลาเป็นค่า TEXT, REAL หรือ INTEGER

ซีเนียร์	คลาสการจัดเก็บและรูปแบบวันที่
1	TEXT วันที่ในรูปแบบเช่น "YYYY-MM-DD HH: MM: SS.SSS"
2	REAL จำนวนวันนับตั้งแต่เที่ยงในกรีนิชวันที่ 24 พฤศจิกายน 4714 ปีก่อนคริสตกาล
3	INTEGER จำนวนวินาทีตั้งแต่ 1970-01-01 00:00:00 UTC

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

ใน SQLite sqlite3คำสั่งใช้เพื่อสร้างฐานข้อมูล SQLite ใหม่ คุณไม่จำเป็นต้องมีสิทธิพิเศษใด ๆ ในการสร้างฐานข้อมูล

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง sqlite3 เพื่อสร้างฐานข้อมูล: -

$sqlite3 DatabaseName.db

ชื่อฐานข้อมูลควรไม่ซ้ำกันภายใน RDBMS เสมอ

ตัวอย่าง

หากคุณต้องการสร้างฐานข้อมูลใหม่ <testDB.db> คำสั่ง SQLITE3 จะเป็นดังนี้ -

$sqlite3 testDB.db
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

คำสั่งดังกล่าวจะสร้างไฟล์ testDB.dbในไดเร็กทอรีปัจจุบัน ไฟล์นี้จะถูกใช้เป็นฐานข้อมูลโดยเอ็นจิ้น SQLite หากคุณสังเกตเห็นขณะสร้างฐานข้อมูลคำสั่ง sqlite3 จะให้ไฟล์sqlite> แจ้งหลังจากสร้างไฟล์ฐานข้อมูลสำเร็จ

เมื่อสร้างฐานข้อมูลแล้วคุณสามารถตรวจสอบได้ในรายการฐานข้อมูลโดยใช้ SQLite ต่อไปนี้ .databases คำสั่ง

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db

คุณจะใช้ SQLite .quit คำสั่งที่จะออกมาจากพรอมต์ sqlite ดังนี้ -

sqlite>.quit
$

คำสั่ง. dump

คุณสามารถใช้ได้ .dump คำสั่ง dot เพื่อส่งออกฐานข้อมูลทั้งหมดในไฟล์ข้อความโดยใช้คำสั่ง SQLite ต่อไปนี้ที่พร้อมท์คำสั่ง

$sqlite3 testDB.db .dump > testDB.sql

คำสั่งดังกล่าวจะแปลงเนื้อหาทั้งหมดของ testDB.db ฐานข้อมูลลงในคำสั่ง SQLite และถ่ายโอนข้อมูลลงในไฟล์ข้อความ ASCII testDB.sql. คุณสามารถทำการกู้คืนจาก testDB.sql ที่สร้างขึ้นด้วยวิธีง่ายๆดังนี้ -

$sqlite3 testDB.db < testDB.sql

ในขณะนี้ฐานข้อมูลของคุณว่างเปล่าดังนั้นคุณสามารถลองสองขั้นตอนข้างต้นเมื่อคุณมีตารางและข้อมูลไม่กี่ตารางในฐานข้อมูลของคุณ สำหรับตอนนี้เรามาดูบทต่อไป

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

ไวยากรณ์

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

ATTACH DATABASE 'DatabaseName' As 'Alias-Name';

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

ตัวอย่าง

หากคุณต้องการแนบฐานข้อมูลที่มีอยู่ testDB.dbจากนั้นคำสั่ง ATTACH DATABASE จะเป็นดังนี้ -

sqlite> ATTACH DATABASE 'testDB.db' as 'TEST';

ใช้ SQLite .database คำสั่งเพื่อแสดงฐานข้อมูลที่แนบมา

sqlite> .database
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db

ชื่อฐานข้อมูล main และ tempถูกสงวนไว้สำหรับฐานข้อมูลหลักและฐานข้อมูลเพื่อเก็บตารางชั่วคราวและวัตถุข้อมูลชั่วคราวอื่น ๆ ชื่อฐานข้อมูลทั้งสองนี้มีอยู่สำหรับทุกการเชื่อมต่อฐานข้อมูลและไม่ควรใช้ในการแนบมิฉะนั้นคุณจะได้รับข้อความเตือนต่อไปนี้

sqlite> ATTACH DATABASE 'testDB.db' as 'TEMP';
Error: database TEMP is already in use
sqlite> ATTACH DATABASE 'testDB.db' as 'main';
Error: database TEMP is already in use

SQLite DETACH DATABASEคำสั่งใช้เพื่อแยกและแยกฐานข้อมูลที่มีชื่อออกจากการเชื่อมต่อฐานข้อมูลที่แนบมาก่อนหน้านี้โดยใช้คำสั่ง ATTACH หากมีการแนบไฟล์ฐานข้อมูลเดียวกันโดยมีหลายนามแฝงคำสั่ง DETACH จะตัดการเชื่อมต่อเฉพาะชื่อที่กำหนดและไฟล์แนบที่เหลือจะยังคงดำเนินต่อไป คุณไม่สามารถถอดไฟล์main หรือ temp ฐานข้อมูล

หากฐานข้อมูลเป็นฐานข้อมูลในหน่วยความจำหรือฐานข้อมูลชั่วคราวฐานข้อมูลจะถูกทำลายและเนื้อหาจะสูญหาย

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง 'นามแฝง - ชื่อ' ฐานข้อมูล SQLite DETACH

DETACH DATABASE 'Alias-Name';

ที่นี่ 'นามแฝง - ชื่อ' เป็นนามแฝงเดียวกับที่คุณใช้ในขณะที่แนบฐานข้อมูลโดยใช้คำสั่ง ATTACH

ตัวอย่าง

พิจารณาว่าคุณมีฐานข้อมูลซึ่งคุณสร้างไว้ในบทก่อนหน้าและแนบมาพร้อมกับ 'test' และ 'currentDB' ตามที่เราเห็นโดยใช้ .database คำสั่ง

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db
3    currentDB        /home/sqlite/testDB.db

ลองแยก 'currentDB' ออกจาก testDB.db โดยใช้คำสั่งต่อไปนี้

sqlite> DETACH DATABASE 'currentDB';

ตอนนี้ถ้าคุณจะตรวจสอบไฟล์แนบปัจจุบันคุณจะพบว่า testDB.db ยังคงเชื่อมต่อกับ 'test' และ 'main'

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db

SQLite CREATE TABLEคำสั่งใช้เพื่อสร้างตารางใหม่ในฐานข้อมูลที่กำหนด การสร้างตารางพื้นฐานเกี่ยวข้องกับการตั้งชื่อตารางและการกำหนดคอลัมน์และประเภทข้อมูลของแต่ละคอลัมน์

ไวยากรณ์

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

CREATE TABLE database_name.table_name(
   column1 datatype PRIMARY KEY(one or more columns),
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype
);

CREATE TABLE คือคีย์เวิร์ดที่บอกให้ระบบฐานข้อมูลสร้างตารางใหม่ ชื่อเฉพาะหรือตัวระบุสำหรับตารางเป็นไปตามคำสั่ง CREATE TABLE คุณสามารถระบุdatabase_nameพร้อมกับtable_nameได้

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างที่สร้างตาราง COMPANY โดยมี ID เป็นคีย์หลักและ NOT NULL เป็นข้อ จำกัด ที่แสดงว่าฟิลด์เหล่านี้ไม่สามารถเป็น NULL ได้ในขณะที่สร้างเรกคอร์ดในตารางนี้

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

ให้เราสร้างตารางขึ้นมาอีกหนึ่งตารางซึ่งเราจะใช้ในแบบฝึกหัดของเราในบทต่อ ๆ ไป

sqlite> CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

คุณสามารถตรวจสอบได้ว่าสร้างตารางของคุณสำเร็จหรือไม่โดยใช้คำสั่ง SQLite .tables คำสั่งซึ่งจะใช้เพื่อแสดงรายการตารางทั้งหมดในฐานข้อมูลที่แนบมา

sqlite>.tables
COMPANY     DEPARTMENT

ที่นี่คุณสามารถดูตาราง COMPANY ได้สองครั้งเนื่องจากตาราง COMPANY แสดงสำหรับฐานข้อมูลหลักและตาราง test.COMPANY สำหรับนามแฝง 'test' ที่สร้างขึ้นสำหรับ testDB.db ของคุณ คุณสามารถรับข้อมูลทั้งหมดเกี่ยวกับตารางโดยใช้ SQLite ต่อไปนี้.schema คำสั่ง

sqlite>.schema COMPANY
CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

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

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

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง DROP TABLE คุณสามารถเลือกระบุชื่อฐานข้อมูลพร้อมกับชื่อตารางได้ดังนี้ -

DROP TABLE database_name.table_name;

ตัวอย่าง

ให้เราตรวจสอบตาราง COMPANY ก่อนจากนั้นเราจะลบออกจากฐานข้อมูล

sqlite>.tables
COMPANY       test.COMPANY

ซึ่งหมายความว่าตาราง COMPANY มีอยู่ในฐานข้อมูลดังนั้นให้เราวางลงดังนี้ -

sqlite>DROP TABLE COMPANY;
sqlite>

ตอนนี้ถ้าคุณลองใช้คำสั่ง. TABLES คุณจะไม่พบตาราง COMPANY อีกต่อไป

sqlite>.tables
sqlite>

ไม่แสดงอะไรเลยซึ่งหมายความว่าตารางจากฐานข้อมูลของคุณถูกทิ้งสำเร็จ

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

ไวยากรณ์

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

INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)]  
VALUES (value1, value2, value3,...valueN);

ที่นี่ column1, column2, ... columnN คือชื่อของคอลัมน์ในตารางที่คุณต้องการแทรกข้อมูล

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

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

ตัวอย่าง

พิจารณาว่าคุณได้สร้างตาราง COMPANY ใน testDB.db ของคุณแล้วดังนี้ -

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

ตอนนี้คำสั่งต่อไปนี้จะสร้างระเบียนหกรายการในตาราง COMPANY

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Allen', 25, 'Texas', 15000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'David', 27, 'Texas', 85000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Kim', 22, 'South-Hall', 45000.00 );

คุณสามารถสร้างเรกคอร์ดในตาราง COMPANY โดยใช้ไวยากรณ์ที่สองดังนี้ -

INSERT INTO COMPANY VALUES (7, 'James', 24, 'Houston', 10000.00 );

ข้อความข้างต้นทั้งหมดจะสร้างบันทึกต่อไปนี้ในตาราง COMPANY ในบทถัดไปคุณจะได้เรียนรู้วิธีแสดงระเบียนเหล่านี้ทั้งหมดจากตาราง

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

เติมข้อมูลหนึ่งตารางโดยใช้ตารางอื่น

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

INSERT INTO first_table_name [(column1, column2, ... columnN)] 
   SELECT column1, column2, ...columnN 
   FROM second_table_name
   [WHERE condition];

ในตอนนี้คุณสามารถข้ามข้อความข้างต้นได้ ก่อนอื่นเรามาเรียนรู้คำสั่ง SELECT และ WHERE ซึ่งจะกล่าวถึงในบทต่อ ๆ ไป

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

ไวยากรณ์

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

SELECT column1, column2, columnN FROM table_name;

ที่นี่ column1, column2 ... คือฟิลด์ของตารางซึ่งมีค่าที่คุณต้องการดึงข้อมูล หากคุณต้องการดึงฟิลด์ทั้งหมดที่มีอยู่ในฟิลด์คุณสามารถใช้ไวยากรณ์ต่อไปนี้ -

SELECT * FROM table_name;

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

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

sqlite>.header on
sqlite>.mode column
sqlite> SELECT * FROM COMPANY;

สุดท้ายคุณจะได้รับผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

หากคุณต้องการดึงเฉพาะฟิลด์ที่เลือกของตาราง COMPANY ให้ใช้แบบสอบถามต่อไปนี้ -

sqlite> SELECT ID, NAME, SALARY FROM COMPANY;

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

ID          NAME        SALARY
----------  ----------  ----------
1           Paul        20000.0
2           Allen       15000.0
3           Teddy       20000.0
4           Mark        65000.0
5           David       85000.0
6           Kim         45000.0
7           James       10000.0

การตั้งค่าความกว้างของคอลัมน์เอาต์พุต

บางครั้งคุณจะประสบปัญหาที่เกี่ยวข้องกับผลลัพธ์ที่ถูกตัดทอนในกรณีของ .mode columnซึ่งเกิดขึ้นเนื่องจากความกว้างเริ่มต้นของคอลัมน์ที่จะแสดง สิ่งที่คุณสามารถทำได้คือคุณสามารถตั้งค่าความกว้างของคอลัมน์ที่แสดงได้โดยใช้.width num, num.... คำสั่งดังนี้ -

sqlite>.width 10, 20, 10
sqlite>SELECT * FROM COMPANY;

ข้างบน .width คำสั่งตั้งค่าความกว้างของคอลัมน์แรกเป็น 10 ความกว้างของคอลัมน์ที่สองเป็น 20 และความกว้างของคอลัมน์ที่สามเป็น 10 สุดท้ายคำสั่ง SELECT ด้านบนจะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME                  AGE         ADDRESS     SALARY
----------  --------------------  ----------  ----------  ----------
1           Paul                  32          California  20000.0
2           Allen                 25          Texas       15000.0
3           Teddy                 23          Norway      20000.0
4           Mark                  25          Rich-Mond   65000.0
5           David                 27          Texas       85000.0
6           Kim                   22          South-Hall  45000.0
7           James                 24          Houston     10000.0

ข้อมูลสคีมา

เช่นเดียวกับ dot commands มีอยู่ที่พรอมต์ SQLite ดังนั้นในขณะที่เขียนโปรแกรมด้วย SQLite คุณจะใช้คำสั่ง SELECT ต่อไปนี้กับ sqlite_master ตารางเพื่อแสดงรายการตารางทั้งหมดที่สร้างในฐานข้อมูลของคุณ

sqlite> SELECT tbl_name FROM sqlite_master WHERE type = 'table';

สมมติว่าคุณมีตาราง COMPANY เพียงตารางเดียวใน testDB.db ของคุณสิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

tbl_name
----------
COMPANY

คุณสามารถลงรายการข้อมูลทั้งหมดเกี่ยวกับตาราง COMPANY ได้ดังนี้ -

sqlite> SELECT sql FROM sqlite_master WHERE type = 'table' AND tbl_name = 'COMPANY';

สมมติว่าคุณมีตาราง COMPANY เพียงตารางเดียวใน testDB.db ของคุณสิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
)

Operator ใน SQLite คืออะไร?

ตัวดำเนินการคือคำสงวนหรืออักขระที่ใช้เป็นหลักในส่วนคำสั่ง WHERE ของคำสั่ง SQLite เพื่อดำเนินการเช่นการเปรียบเทียบและการคำนวณทางคณิตศาสตร์

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

• ตัวดำเนินการเลขคณิต
• ตัวดำเนินการเปรียบเทียบ
• ตัวดำเนินการทางตรรกะ
• ตัวดำเนินการ Bitwise

ตัวดำเนินการทางคณิตศาสตร์ SQLite

สมมติตัวแปร a ถือ 10 และตัวแปร b ถือ 20 จากนั้นตัวดำเนินการทางคณิตศาสตร์ SQLite จะถูกใช้ดังนี้ -

แสดงตัวอย่าง

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
+ (เพิ่มเติม)	เพิ่มค่าที่ด้านใดด้านหนึ่งของตัวดำเนินการ	a + b จะให้ 30
- (การลบ)	ลบตัวถูกดำเนินการด้านขวาออกจากตัวถูกดำเนินการด้านซ้าย	a - b จะให้ -10
* (การคูณ)	คูณค่าที่ด้านใดด้านหนึ่งของตัวดำเนินการ	a * b จะให้ 200
/ (แผนก)	แบ่งตัวถูกดำเนินการด้านซ้ายด้วยตัวถูกดำเนินการด้านขวา	b / a จะให้ 2
% (โมดูลัส)	หารตัวถูกดำเนินการด้านซ้ายด้วยตัวถูกดำเนินการด้านขวาและส่งกลับส่วนที่เหลือ	b% a จะให้ 0

ตัวดำเนินการเปรียบเทียบ SQLite

สมมติตัวแปร a ถือ 10 และตัวแปร b ถือ 20 จากนั้นตัวดำเนินการเปรียบเทียบ SQLite จะถูกใช้ดังต่อไปนี้

แสดงตัวอย่าง

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
==	ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(a == b) ไม่เป็นความจริง
=	ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(a = b) ไม่เป็นความจริง
! =	ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่หากค่าไม่เท่ากันเงื่อนไขจะกลายเป็นจริง	(a! = b) เป็นจริง
<>	ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่หากค่าไม่เท่ากันเงื่อนไขจะกลายเป็นจริง	(a <> b) เป็นจริง
>	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(a> b) ไม่เป็นความจริง
<	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(a <b) เป็นจริง
> =	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(a> = b) ไม่เป็นความจริง
<=	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(a <= b) เป็นจริง
! <	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายไม่น้อยกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(a! <b) เป็นเท็จ
!>	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายไม่มากกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(a!> b) เป็นจริง

ตัวดำเนินการตรรกะ SQLite

นี่คือรายการของตัวดำเนินการทางตรรกะทั้งหมดที่มีอยู่ใน SQLite

แสดงตัวอย่าง

ซีเนียร์	ตัวดำเนินการและคำอธิบาย
1	AND ตัวดำเนินการ AND อนุญาตให้มีหลายเงื่อนไขในส่วนคำสั่ง WHERE ของคำสั่ง SQL
2	BETWEEN ตัวดำเนินการ BETWEEN ใช้เพื่อค้นหาค่าที่อยู่ในชุดของค่ากำหนดค่าต่ำสุดและค่าสูงสุด
3	EXISTS ตัวดำเนินการ EXISTS ใช้เพื่อค้นหาการมีอยู่ของแถวในตารางที่ระบุซึ่งตรงตามเกณฑ์ที่กำหนด
4	IN ตัวดำเนินการ IN ใช้เพื่อเปรียบเทียบค่ากับรายการค่าตามตัวอักษรที่ระบุไว้
5	NOT IN การปฏิเสธของตัวดำเนินการ IN ซึ่งใช้เพื่อเปรียบเทียบค่ากับรายการของค่าตามตัวอักษรที่ระบุไว้
6	LIKE ตัวดำเนินการ LIKE ใช้เพื่อเปรียบเทียบค่ากับค่าที่คล้ายกันโดยใช้ตัวดำเนินการสัญลักษณ์แทน
7	GLOB ตัวดำเนินการ GLOB ใช้เพื่อเปรียบเทียบค่ากับค่าที่คล้ายกันโดยใช้ตัวดำเนินการตัวแทน นอกจากนี้ GLOB ยังพิจารณาตัวพิมพ์เล็กและใหญ่ซึ่งแตกต่างจาก LIKE
8	NOT ตัวดำเนินการ NOT จะกลับความหมายของตัวดำเนินการทางตรรกะที่ใช้ เช่น. ไม่ออกไม่อยู่ระหว่างไม่ได้อยู่ใน ฯลฯThis is negate operator.
9	OR ตัวดำเนินการ OR ใช้เพื่อรวมหลายเงื่อนไขในคำสั่ง WHERE ของคำสั่ง SQL
10	IS NULL ตัวดำเนินการ NULL ใช้เพื่อเปรียบเทียบค่ากับค่า NULL
11	IS ตัวดำเนินการ IS ทำงานเหมือน =
12	IS NOT ตัวดำเนินการ IS ทำงานเหมือน! =
13	|| เพิ่มสองสตริงที่แตกต่างกันและสร้างใหม่
14	UNIQUE ตัวดำเนินการ UNIQUE จะค้นหาทุกแถวของตารางที่ระบุเพื่อความไม่ซ้ำกัน (ไม่ซ้ำกัน)

ตัวดำเนินการ SQLite Bitwise

ตัวดำเนินการ Bitwise ทำงานบนบิตและดำเนินการแบบบิตต่อบิต ต่อไปนี้เป็นตารางความจริงสำหรับ& และ |.

น	q	p & q	p | q
0	0	0	0
0	1	0	1
1	1	1	1
1	0	0	1

สมมติว่า A= 60; และB = 13 จากนั้นในรูปแบบไบนารีจะเป็นดังนี้ -

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

ก | B = 0011 1101

~ A = 1100 0011

ตัวดำเนินการ Bitwise ที่รองรับโดยภาษา SQLite แสดงอยู่ในตารางต่อไปนี้ สมมติตัวแปรA ถือ 60 และตัวแปร B ถือ 13 แล้ว -

แสดงตัวอย่าง

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
&	ไบนารี AND Operator จะคัดลอกบิตไปยังผลลัพธ์หากมีอยู่ในตัวถูกดำเนินการทั้งสอง	(A & B) จะให้ 12 ซึ่งเท่ากับ 0000 1100
|	ไบนารีหรือตัวดำเนินการคัดลอกบิตหากมีอยู่ในตัวถูกดำเนินการอย่างใดอย่างหนึ่ง	(A | B) จะให้ 61 ซึ่งก็คือ 0011 1101
~	Binary Ones Complement Operator เป็นเอกภาพและมีผลของบิต 'พลิก'	(~ A) จะให้ -61 ซึ่งก็คือ 1100 0011 ในรูปแบบส่วนเติมเต็มของ 2 เนื่องจากเลขฐานสองที่ลงนาม
<<	ตัวดำเนินการกะซ้ายแบบไบนารี ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางซ้ายตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา	A << 2 จะให้ 240 ซึ่งก็คือ 1111 0000
>>	ตัวดำเนินการกะไบนารีขวา ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางขวาตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา	A >> 2 จะให้ 15 ซึ่งก็คือ 0000 1111

นิพจน์คือการรวมกันของค่าตัวดำเนินการและฟังก์ชัน SQL อย่างน้อยหนึ่งค่าที่ประเมินเป็นค่า

นิพจน์ SQL เป็นเหมือนสูตรและเขียนด้วยภาษาแบบสอบถาม คุณยังสามารถใช้เพื่อสอบถามฐานข้อมูลสำหรับชุดข้อมูลเฉพาะได้

ไวยากรณ์

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

SELECT column1, column2, columnN 
FROM table_name 
WHERE [CONDITION | EXPRESSION];

ต่อไปนี้เป็นนิพจน์ SQLite ประเภทต่างๆ

SQLite - นิพจน์บูลีน

SQLite Boolean Expressions ดึงข้อมูลบนพื้นฐานของค่าเดียวที่ตรงกัน ต่อไปนี้เป็นไวยากรณ์ -

SELECT column1, column2, columnN 
FROM table_name 
WHERE SINGLE VALUE MATCHTING EXPRESSION;

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ต่อไปนี้เป็นตัวอย่างง่ายๆที่แสดงการใช้ SQLite Boolean Expressions -

sqlite> SELECT * FROM COMPANY WHERE SALARY = 10000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           James        24          Houston   10000.0

SQLite - นิพจน์ตัวเลข

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

SELECT numerical_expression as OPERATION_NAME
[FROM table_name WHERE CONDITION] ;

ที่นี่ numerical_expression ใช้สำหรับนิพจน์ทางคณิตศาสตร์หรือสูตรใด ๆ ต่อไปนี้เป็นตัวอย่างง่ายๆที่แสดงการใช้ SQLite Numeric Expressions

sqlite> SELECT (15 + 6) AS ADDITION
ADDITION = 21

มีฟังก์ชันในตัวหลายอย่างเช่น avg(), sum(), count(), ฯลฯ เพื่อดำเนินการในสิ่งที่เรียกว่า aggregate data calculations เทียบกับตารางหรือคอลัมน์ตารางเฉพาะ

sqlite> SELECT COUNT(*) AS "RECORDS" FROM COMPANY; 
RECORDS = 7

SQLite - นิพจน์วันที่

Date Expressions ส่งกลับค่าวันที่และเวลาปัจจุบันของระบบ นิพจน์เหล่านี้ใช้ในการจัดการข้อมูลต่างๆ

sqlite> SELECT CURRENT_TIMESTAMP;
CURRENT_TIMESTAMP = 2013-03-17 10:43:35

SQLite WHERE อนุประโยคใช้เพื่อระบุเงื่อนไขในขณะดึงข้อมูลจากตารางเดียวหรือหลายตาราง

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

คำสั่ง WHERE ไม่เพียง แต่ใช้ในคำสั่ง SELECT เท่านั้น แต่ยังใช้ในคำสั่ง UPDATE, DELETE และอื่น ๆ ซึ่งจะกล่าวถึงในบทต่อ ๆ ไป

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง SQLite SELECT พร้อมด้วยคำสั่ง WHERE

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition]

ตัวอย่าง

คุณสามารถระบุเงื่อนไขโดยใช้Comparision หรือ Logical Operatorsเช่น>, <, =, LIKE, NOT เป็นต้นพิจารณาตาราง COMPANY ที่มีเรกคอร์ดต่อไปนี้ -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ต่อไปนี้เป็นตัวอย่างง่ายๆที่แสดงการใช้งานตัวดำเนินการลอจิก SQLite คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่ AGE มากกว่าหรือเท่ากับ 25AND เงินเดือนมากกว่าหรือเท่ากับ 65000.00

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่ AGE มากกว่าหรือเท่ากับ 25 OR เงินเดือนมากกว่าหรือเท่ากับ 65000.00

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดโดยที่ AGE ไม่ใช่ NULL ซึ่งหมายถึงระเบียนทั้งหมดเนื่องจากไม่มีระเบียนใดที่มี AGE เท่ากับ NULL

sqlite>  SELECT * FROM COMPANY WHERE AGE IS NOT NULL;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่ NAME ขึ้นต้นด้วย 'Ki' ไม่สำคัญว่าจะเกิดอะไรขึ้นหลังจาก 'Ki'

sqlite> SELECT * FROM COMPANY WHERE NAME LIKE 'Ki%';

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
6           Kim         22          South-Hall  45000.0

คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่ NAME ขึ้นต้นด้วย 'Ki' ไม่สำคัญว่าจะเกิดอะไรขึ้นหลังจาก 'Ki'

sqlite> SELECT * FROM COMPANY WHERE NAME GLOB 'Ki*';

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
6           Kim         22          South-Hall  45000.0

คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดโดยที่ค่า AGE คือ 25 หรือ 27

sqlite> SELECT * FROM COMPANY WHERE AGE IN ( 25, 27 );

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดโดยที่ค่า AGE ไม่ใช่ 25 หรือ 27

sqlite> SELECT * FROM COMPANY WHERE AGE NOT IN ( 25, 27 );

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่มีค่า AGE อยู่ระหว่าง 25 และ 27

sqlite> SELECT * FROM COMPANY WHERE AGE BETWEEN 25 AND 27;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

คำสั่ง SELECT ต่อไปนี้ใช้ประโยชน์จากแบบสอบถามย่อย SQL โดยที่แบบสอบถามย่อยจะค้นหาระเบียนทั้งหมดที่มีเขตข้อมูล AGE ที่มี SALARY> 65000 ขึ้นไป WHERE clause จะถูกใช้ร่วมกับตัวดำเนินการ EXISTS เพื่อแสดงรายการระเบียนทั้งหมดที่มี AGE จากแบบสอบถามภายนอกอยู่ ในผลลัพธ์ที่ส่งคืนโดยแบบสอบถามย่อย -

sqlite> SELECT AGE FROM COMPANY 
   WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);

AGE
----------
32
25
23
25
27
22
24

คำสั่ง SELECT ต่อไปนี้ใช้ประโยชน์จากแบบสอบถามย่อย SQL ที่แบบสอบถามย่อยค้นหาระเบียนทั้งหมดที่มีเขตข้อมูล AGE ที่มี SALARY> 65000 ขึ้นไป WHERE clause จะถูกใช้ร่วมกับตัวดำเนินการ> เพื่อแสดงรายการระเบียนทั้งหมดโดยที่ AGE จากแบบสอบถามภายนอกมีค่ามากกว่า กว่าอายุในผลลัพธ์ที่ส่งคืนโดยแบบสอบถามย่อย

sqlite> SELECT * FROM COMPANY 
   WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0

SQLite AND & ORตัวดำเนินการใช้เพื่อรวบรวมเงื่อนไขต่างๆเพื่อ จำกัด ข้อมูลที่เลือกให้แคบลงในคำสั่ง SQLite ตัวดำเนินการทั้งสองนี้เรียกว่าconjunctive operators.

ตัวดำเนินการเหล่านี้ให้วิธีการเปรียบเทียบหลายตัวกับตัวดำเนินการที่แตกต่างกันในคำสั่ง SQLite เดียวกัน

ตัวดำเนินการ AND

ANDตัวดำเนินการอนุญาตให้มีหลายเงื่อนไขในคำสั่ง WHERE ของคำสั่ง SQLite ในขณะที่ใช้ตัวดำเนินการ AND เงื่อนไขที่สมบูรณ์จะถือว่าเป็นจริงเมื่อเงื่อนไขทั้งหมดเป็นจริง ตัวอย่างเช่น [condition1] AND [condition2] จะเป็นจริงก็ต่อเมื่อทั้ง condition1 และ condition2 เป็นจริง

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของตัวดำเนินการ AND กับ WHERE clause

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

คุณสามารถรวม Nจำนวนเงื่อนไขที่ใช้ตัวดำเนินการ AND สำหรับการดำเนินการโดยคำสั่ง SQLite ไม่ว่าจะเป็นธุรกรรมหรือแบบสอบถามเงื่อนไขทั้งหมดที่คั่นด้วย AND ต้องเป็น TRUE

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่ AGE มากกว่าหรือเท่ากับ 25 AND เงินเดือนมากกว่าหรือเท่ากับ 65000.00

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

ตัวดำเนินการหรือ

นอกจากนี้ตัวดำเนินการ OR ยังใช้เพื่อรวมหลายเงื่อนไขในคำสั่ง WHERE ของคำสั่ง SQLite ในขณะที่ใช้ตัวดำเนินการ OR เงื่อนไขที่สมบูรณ์จะถือว่าเป็นจริงเมื่ออย่างน้อยเงื่อนไขใด ๆ เป็นจริง ตัวอย่างเช่น [condition1] หรือ [condition2] จะเป็นจริงถ้า condition1 หรือ condition2 เป็นจริง

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของตัวดำเนินการ OR ที่มีส่วนคำสั่ง WHERE

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

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

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่ AGE มากกว่าหรือเท่ากับ 25 OR เงินเดือนมากกว่าหรือเท่ากับ 65000.00

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

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

ไวยากรณ์

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

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

คุณสามารถรวม N จำนวนเงื่อนไขที่ใช้ตัวดำเนินการ AND หรือ OR

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

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

sqlite> UPDATE COMPANY SET ADDRESS = 'Texas' WHERE ID = 6;

ตอนนี้ตาราง COMPANY จะมีบันทึกต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          Texas       45000.0
7           James       24          Houston     10000.0

หากคุณต้องการแก้ไขค่าคอลัมน์ ADDRESS และ SALARY ทั้งหมดในตาราง COMPANY คุณไม่จำเป็นต้องใช้ WHERE clause และ UPDATE query จะเป็นดังนี้ -

sqlite> UPDATE COMPANY SET ADDRESS = 'Texas', SALARY = 20000.00;

ตอนนี้ตาราง COMPANY จะมีบันทึกต่อไปนี้ -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          Texas       20000.0
2           Allen       25          Texas       20000.0
3           Teddy       23          Texas       20000.0
4           Mark        25          Texas       20000.0
5           David       27          Texas       20000.0
6           Kim         22          Texas       20000.0
7           James       24          Texas       20000.0

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

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ DELETE query ด้วย WHERE clause

DELETE FROM table_name
WHERE [condition];

คุณสามารถรวม N จำนวนเงื่อนไขที่ใช้ตัวดำเนินการ AND หรือ OR

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ต่อไปนี้เป็นตัวอย่างซึ่งจะลบลูกค้าที่มีรหัส 7

sqlite> DELETE FROM COMPANY WHERE ID = 7;

ตอนนี้ตาราง COMPANY จะมีบันทึกดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0

ถ้าคุณต้องการลบระเบียนทั้งหมดจากตาราง COMPANY คุณไม่จำเป็นต้องใช้ WHERE clause กับ DELETE query ซึ่งจะเป็นดังนี้ -

sqlite> DELETE FROM COMPANY;

ตอนนี้ตาราง COMPANY ไม่มีบันทึกใด ๆ เนื่องจากระเบียนทั้งหมดถูกลบโดยคำสั่ง DELETE

SQLite LIKEตัวดำเนินการใช้เพื่อจับคู่ค่าข้อความกับรูปแบบโดยใช้สัญลักษณ์แทน หากนิพจน์การค้นหาสามารถจับคู่กับนิพจน์รูปแบบได้ตัวดำเนินการ LIKE จะคืนค่าจริงซึ่งก็คือ 1 มีสัญลักษณ์แทนสองตัวที่ใช้ร่วมกับตัวดำเนินการ LIKE -

• เครื่องหมายเปอร์เซ็นต์ (%)
• ขีดล่าง (_)

เครื่องหมายเปอร์เซ็นต์แสดงถึงตัวเลขหรืออักขระที่เป็นศูนย์หนึ่งหรือหลายตัว ขีดล่างแสดงถึงตัวเลขหรืออักขระตัวเดียว สัญลักษณ์เหล่านี้สามารถใช้ร่วมกันได้

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ% และ _

SELECT FROM table_name
WHERE column LIKE 'XXXX%'
or 
SELECT FROM table_name
WHERE column LIKE '%XXXX%'
or
SELECT FROM table_name
WHERE column LIKE 'XXXX_'
or
SELECT FROM table_name
WHERE column LIKE '_XXXX'
or
SELECT FROM table_name
WHERE column LIKE '_XXXX_'

คุณสามารถรวม Nจำนวนเงื่อนไขที่ใช้ตัวดำเนินการ AND หรือ OR ในที่นี้ XXXX อาจเป็นค่าตัวเลขหรือสตริงก็ได้

ตัวอย่าง

ตารางต่อไปนี้แสดงตัวอย่างจำนวนหนึ่งที่แสดงส่วน WHERE ที่มีคำสั่ง LIKE ต่างกันโดยมีตัวดำเนินการ '%' และ '_'

ซีเนียร์	คำชี้แจงและคำอธิบาย
1	WHERE SALARY LIKE '200%' ค้นหาค่าใด ๆ ที่เริ่มต้นด้วย 200
2	WHERE SALARY LIKE '%200%' ค้นหาค่าใด ๆ ที่มี 200 ในตำแหน่งใด ๆ
3	WHERE SALARY LIKE '_00%' ค้นหาค่าใด ๆ ที่มี 00 ในตำแหน่งที่สองและสาม
4	WHERE SALARY LIKE '2_%_%' ค้นหาค่าใด ๆ ที่ขึ้นต้นด้วย 2 และมีความยาวอย่างน้อย 3 อักขระ
5	WHERE SALARY LIKE '%2' ค้นหาค่าใด ๆ ที่ลงท้ายด้วย 2
6	WHERE SALARY LIKE '_2%3' ค้นหาค่าใด ๆ ที่มี 2 ในตำแหน่งที่สองและลงท้ายด้วย 3
7	WHERE SALARY LIKE '2___3' ค้นหาค่าใด ๆ ในตัวเลขห้าหลักที่ขึ้นต้นด้วย 2 และลงท้ายด้วย 3

ให้เรายกตัวอย่างจริงพิจารณาตาราง COMPANY ที่มีบันทึกต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ต่อไปนี้เป็นตัวอย่างซึ่งจะแสดงระเบียนทั้งหมดจากตาราง COMPANY โดยที่ AGE เริ่มต้นด้วย 2

sqlite> SELECT * FROM COMPANY WHERE AGE LIKE '2%';

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ต่อไปนี้เป็นตัวอย่างซึ่งจะแสดงระเบียนทั้งหมดจากตาราง COMPANY โดยที่ ADDRESS จะมีเครื่องหมายยัติภังค์ (-) อยู่ภายในข้อความ

sqlite> SELECT * FROM COMPANY WHERE ADDRESS  LIKE '%-%';

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0

SQLite GLOBตัวดำเนินการใช้เพื่อจับคู่เฉพาะค่าข้อความกับรูปแบบโดยใช้สัญลักษณ์แทน หากนิพจน์การค้นหาสามารถจับคู่กับนิพจน์รูปแบบได้ตัวดำเนินการ GLOB จะคืนค่าจริงซึ่งก็คือ 1 ซึ่งแตกต่างจากตัวดำเนินการ LIKE GLOB จะคำนึงถึงขนาดตัวพิมพ์และเป็นไปตามไวยากรณ์ของ UNIX สำหรับการระบุอักขระตัวแทนต่อไปนี้

• เครื่องหมายดอกจัน (*)
• เครื่องหมายคำถาม (?)

เครื่องหมายดอกจัน (*) หมายถึงตัวเลขหรืออักขระที่เป็นศูนย์หรือหลายตัว เครื่องหมายคำถาม (?) แสดงถึงตัวเลขหรืออักขระตัวเดียว

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ * และ ?.

SELECT FROM table_name
WHERE column GLOB 'XXXX*'
or 
SELECT FROM table_name
WHERE column GLOB '*XXXX*'
or
SELECT FROM table_name
WHERE column GLOB 'XXXX?'
or
SELECT FROM table_name
WHERE column GLOB '?XXXX'
or
SELECT FROM table_name
WHERE column GLOB '?XXXX?'
or
SELECT FROM table_name
WHERE column GLOB '????'

คุณสามารถรวม Nจำนวนเงื่อนไขที่ใช้ตัวดำเนินการ AND หรือ OR ในที่นี้ XXXX อาจเป็นค่าตัวเลขหรือสตริงก็ได้

ตัวอย่าง

ตารางต่อไปนี้แสดงตัวอย่างจำนวนหนึ่งที่แสดงว่าส่วนไหนที่มีคำสั่ง LIKE ต่างกันด้วย '*' และ '?' ตัวดำเนินการ

ซีเนียร์	คำชี้แจงและคำอธิบาย
1	WHERE SALARY GLOB '200*' ค้นหาค่าใด ๆ ที่เริ่มต้นด้วย 200
2	WHERE SALARY GLOB '*200*' ค้นหาค่าใด ๆ ที่มี 200 ในตำแหน่งใด ๆ
3	WHERE SALARY GLOB '?00*' ค้นหาค่าใด ๆ ที่มี 00 ในตำแหน่งที่สองและสาม
4	WHERE SALARY GLOB '2??' ค้นหาค่าใด ๆ ที่ขึ้นต้นด้วย 2 และมีความยาวอย่างน้อย 3 อักขระ
5	WHERE SALARY GLOB '*2' ค้นหาค่าใด ๆ ที่ลงท้ายด้วย 2
6	WHERE SALARY GLOB '?2*3' ค้นหาค่าใด ๆ ที่มี 2 ในตำแหน่งที่สองและลงท้ายด้วย 3
7	WHERE SALARY GLOB '2???3' ค้นหาค่าใด ๆ ในตัวเลขห้าหลักที่ขึ้นต้นด้วย 2 และลงท้ายด้วย 3

ให้เราเป็นตัวอย่างจริงพิจารณาตาราง COMPANY พร้อมบันทึกต่อไปนี้ -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ต่อไปนี้เป็นตัวอย่างซึ่งจะแสดงระเบียนทั้งหมดจากตาราง COMPANY โดยที่ AGE เริ่มต้นด้วย 2

sqlite> SELECT * FROM COMPANY WHERE AGE  GLOB '2*';

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ต่อไปนี้เป็นตัวอย่างซึ่งจะแสดงระเบียนทั้งหมดจากตาราง COMPANY โดยที่ ADDRESS จะมีเครื่องหมายยัติภังค์ (-) อยู่ภายในข้อความ -

sqlite> SELECT * FROM COMPANY WHERE ADDRESS  GLOB '*-*';

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0

SQLite LIMIT อนุประโยคถูกใช้เพื่อ จำกัด ปริมาณข้อมูลที่ส่งคืนโดยคำสั่ง SELECT

ไวยากรณ์

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

SELECT column1, column2, columnN 
FROM table_name
LIMIT [no of rows]

ต่อไปนี้เป็นไวยากรณ์ของ LIMIT clause เมื่อใช้ร่วมกับประโยค OFFSET

SELECT column1, column2, columnN 
FROM table_name
LIMIT [no of rows] OFFSET [row num]

SQLite engine จะส่งคืนแถวโดยเริ่มจากแถวถัดไปไปยัง OFFSET ที่กำหนดดังแสดงด้านล่างในตัวอย่างสุดท้าย

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ต่อไปนี้เป็นตัวอย่างซึ่ง จำกัด แถวในตารางตามจำนวนแถวที่คุณต้องการดึงข้อมูลจากตาราง

sqlite> SELECT * FROM COMPANY LIMIT 6;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0

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

sqlite> SELECT * FROM COMPANY LIMIT 3 OFFSET 2;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

SQLite ORDER BY อนุประโยคใช้เพื่อจัดเรียงข้อมูลตามลำดับจากน้อยไปมากหรือมากไปหาน้อยโดยยึดตามคอลัมน์อย่างน้อยหนึ่งคอลัมน์

ไวยากรณ์

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

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

คุณสามารถใช้คอลัมน์ได้มากกว่าหนึ่งคอลัมน์ในคำสั่ง ORDER BY ตรวจสอบให้แน่ใจว่าคุณใช้คอลัมน์ใดในการจัดเรียงคอลัมน์นั้นควรมีอยู่ในรายการคอลัมน์

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ต่อไปนี้เป็นตัวอย่างซึ่งจะเรียงลำดับผลลัพธ์จากมากไปหาน้อยตาม SALARY

sqlite> SELECT * FROM COMPANY ORDER BY SALARY ASC;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
7           James       24          Houston     10000.0
2           Allen       25          Texas       15000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

ต่อไปนี้เป็นตัวอย่างซึ่งจะเรียงลำดับผลลัพธ์จากมากไปหาน้อยตาม NAME และ SALARY

sqlite> SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
5           David       27          Texas       85000.0
7           James       24          Houston     10000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0

ต่อไปนี้เป็นตัวอย่างซึ่งจะเรียงลำดับผลลัพธ์จากมากไปหาน้อยตาม NAME

sqlite> SELECT * FROM COMPANY ORDER BY NAME DESC;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
3           Teddy       23          Norway      20000.0
1           Paul        32          California  20000.0
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
5           David       27          Texas       85000.0
2           Allen       25          Texas       15000.0

SQLite GROUP BY อนุประโยคถูกใช้ร่วมกับคำสั่ง SELECT เพื่อจัดเรียงข้อมูลที่เหมือนกันเป็นกลุ่ม

GROUP BY clause ตามหลัง WHERE clause ในคำสั่ง SELECT และนำหน้า ORDER BY clause

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ GROUP BY clause GROUP BY clause ต้องเป็นไปตามเงื่อนไขใน WHERE clause และต้องนำหน้า ORDER BY clause ถ้ามีการใช้

SELECT column-list
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnN

คุณสามารถใช้คอลัมน์มากกว่าหนึ่งคอลัมน์ใน GROUP BY clause ตรวจสอบให้แน่ใจว่าคอลัมน์ใดที่คุณใช้จัดกลุ่มคอลัมน์นั้นควรมีอยู่ในรายการคอลัมน์

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

หากคุณต้องการทราบจำนวนเงินเดือนทั้งหมดของลูกค้าแต่ละรายคำถาม GROUP BY จะเป็นดังนี้ -

sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

NAME        SUM(SALARY)
----------  -----------
Allen       15000.0
David       85000.0
James       10000.0
Kim         45000.0
Mark        65000.0
Paul        20000.0
Teddy       20000.0

ตอนนี้ให้เราสร้างระเบียนอีกสามรายการในตาราง COMPANY โดยใช้คำสั่ง INSERT ต่อไปนี้

INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00 );
INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00 );
INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00 );

ตอนนี้ตารางของเรามีระเบียนต่อไปนี้ที่มีชื่อซ้ำกัน

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

อีกครั้งให้เราใช้คำสั่งเดียวกันเพื่อจัดกลุ่มตามระเบียนทั้งหมดโดยใช้คอลัมน์ NAME ดังนี้ -

sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

NAME        SUM(SALARY)
----------  -----------
Allen       15000
David       85000
James       20000
Kim         45000
Mark        65000
Paul        40000
Teddy       20000

ให้เราใช้ ORDER BY clause พร้อมกับ GROUP BY clause ดังนี้ -

sqlite>  SELECT NAME, SUM(SALARY) 
   FROM COMPANY GROUP BY NAME ORDER BY NAME DESC;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

NAME        SUM(SALARY)
----------  -----------
Teddy       20000
Paul        40000
Mark        65000
Kim         45000
James       20000
David       85000
Allen       15000

HAVING clause ช่วยให้คุณสามารถระบุเงื่อนไขที่กรองผลลัพธ์ของกลุ่มที่จะปรากฏในผลลัพธ์สุดท้าย

WHERE clause วางเงื่อนไขบนคอลัมน์ที่เลือกในขณะที่ HAVING clause วางเงื่อนไขบนกลุ่มที่สร้างโดย GROUP BY clause

ไวยากรณ์

ต่อไปนี้เป็นตำแหน่งของ HAVING clause ในแบบสอบถาม SELECT

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

HAVING clause ต้องเป็นไปตาม GROUP BY clause ในเคียวรีและต้องนำหน้า ORDER BY clause ด้วยถ้าใช้ ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง SELECT รวมทั้ง HAVING clause

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

ต่อไปนี้เป็นตัวอย่างซึ่งจะแสดงบันทึกที่จำนวนชื่อน้อยกว่า 2

sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) < 2;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000
5           David       27          Texas       85000
6           Kim         22          South-Hall  45000
4           Mark        25          Rich-Mond   65000
3           Teddy       23          Norway      20000

ต่อไปนี้เป็นตัวอย่างซึ่งจะแสดงระเบียนที่จำนวนชื่อมากกว่า 2

sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) > 2;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
10          James       45          Texas       5000

SQLite DISTINCT คำหลักใช้ร่วมกับคำสั่ง SELECT เพื่อกำจัดระเบียนที่ซ้ำกันทั้งหมดและดึงเฉพาะระเบียนที่ไม่ซ้ำกัน

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

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคีย์เวิร์ด DISTINCT เพื่อกำจัดเร็กคอร์ดที่ซ้ำกัน

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

ขั้นแรกให้เราดูว่าแบบสอบถาม SELECT ต่อไปนี้ส่งคืนระเบียนเงินเดือนที่ซ้ำกันอย่างไร

sqlite> SELECT name FROM COMPANY;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
James
Paul
James
James

ตอนนี้ให้เราใช้ DISTINCT คำหลักที่มีคำค้นหา SELECT ด้านบนและดูผลลัพธ์

sqlite> SELECT DISTINCT name FROM COMPANY;

สิ่งนี้จะให้ผลลัพธ์ต่อไปนี้โดยที่ไม่มีรายการที่ซ้ำกัน

NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
James

SQLite PRAGMAคำสั่งเป็นคำสั่งพิเศษที่ใช้เพื่อควบคุมตัวแปรสภาพแวดล้อมและแฟล็กสถานะต่างๆภายในสภาพแวดล้อม SQLite สามารถอ่านค่า PRAGMA และยังสามารถตั้งค่าตามข้อกำหนดได้อีกด้วย

ไวยากรณ์

หากต้องการสอบถามค่า PRAGMA ปัจจุบันเพียงระบุชื่อของ pragma

PRAGMA pragma_name;

ในการตั้งค่าใหม่สำหรับ PRAGMA ให้ใช้ไวยากรณ์ต่อไปนี้

PRAGMA pragma_name = value;

โหมดการตั้งค่าสามารถเป็นได้ทั้งชื่อหรือจำนวนเต็ม แต่ค่าที่ส่งคืนจะเป็นจำนวนเต็มเสมอ

auto_vacuum Pragma

auto_vacuumpragma รับหรือตั้งค่าโหมดสูญญากาศอัตโนมัติ ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA [database.]auto_vacuum;
PRAGMA [database.]auto_vacuum = mode;

ที่ไหน mode สามารถเป็นอย่างใดอย่างหนึ่งต่อไปนี้ -

ซีเนียร์	ค่า Pragma & คำอธิบาย
1	0 or NONE ปิดใช้งานเครื่องดูดฝุ่นอัตโนมัติ นี่เป็นโหมดเริ่มต้นซึ่งหมายความว่าไฟล์ฐานข้อมูลจะไม่มีการย่อขนาดเว้นแต่จะถูกดูดด้วยตนเองโดยใช้คำสั่ง VACUUM
2	1 or FULL เปิดใช้งานสูญญากาศอัตโนมัติและอัตโนมัติเต็มรูปแบบซึ่งจะทำให้ไฟล์ฐานข้อมูลหดตัวเมื่อข้อมูลถูกลบออกจากฐานข้อมูล
3	2 or INCREMENTAL เปิดใช้งานเครื่องดูดฝุ่นอัตโนมัติ แต่ต้องเปิดใช้งานด้วยตนเอง ในโหมดนี้ข้อมูลอ้างอิงจะยังคงอยู่ แต่หน้าฟรีจะอยู่ในรายการฟรี หน้าเหล่านี้สามารถกู้คืนได้โดยใช้ไฟล์incremental_vacuum pragma ตลอดเวลา.

cache_size Pragma

cache_sizepragma สามารถรับหรือตั้งค่าขนาดสูงสุดของแคชเพจในหน่วยความจำชั่วคราว ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA [database.]cache_size;
PRAGMA [database.]cache_size = pages;

pagesค่าแทนจำนวนหน้าในแคช แคชของเพจในตัวมีขนาดเริ่มต้น 2,000 เพจและขนาดขั้นต่ำ 10 เพจ

case_sensitive_like Pragma

case_sensitive_likepragma ควบคุมความไวของตัวพิมพ์เล็กและใหญ่ของนิพจน์ LIKE ในตัว ตามค่าเริ่มต้น pragma นี้เป็นเท็จซึ่งหมายความว่าตัวดำเนินการ LIKE ในตัวจะละเว้นตัวอักษร ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA case_sensitive_like = [true|false];

ไม่มีวิธีการค้นหาสถานะปัจจุบันของ pragma นี้

count_changes Pragma

count_changespragma รับหรือกำหนดค่าส่งคืนของคำสั่งการจัดการข้อมูลเช่น INSERT, UPDATE และ DELETE ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA count_changes;
PRAGMA count_changes = [true|false];

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

database_list Pragma

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

PRAGMA database_list;

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

การเข้ารหัส Pragma

encodingpragma ควบคุมวิธีการเข้ารหัสและจัดเก็บสตริงในไฟล์ฐานข้อมูล ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA encoding;
PRAGMA encoding = format;

ค่ารูปแบบสามารถเป็นหนึ่งใน UTF-8, UTF-16le, หรือ UTF-16be.

freelist_count Pragma

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

PRAGMA [database.]freelist_count;

ค่ารูปแบบสามารถเป็นหนึ่งใน UTF-8, UTF-16le, หรือ UTF-16be.

index_info Pragma

index_infopragma ส่งคืนข้อมูลเกี่ยวกับดัชนีฐานข้อมูล ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA [database.]index_info( index_name );

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

index_list Pragma

index_listpragma แสดงดัชนีทั้งหมดที่เกี่ยวข้องกับตาราง ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA [database.]index_list( table_name );

ชุดผลลัพธ์จะมีหนึ่งแถวสำหรับแต่ละดัชนีที่ให้ลำดับดัชนีชื่อดัชนีและแฟล็กที่ระบุว่าดัชนีไม่ซ้ำกันหรือไม่

journal_mode Pragma

journal_modepragma รับหรือตั้งค่าโหมดเจอร์นัลซึ่งควบคุมวิธีการจัดเก็บและประมวลผลไฟล์เจอร์นัล ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA journal_mode;
PRAGMA journal_mode = mode;
PRAGMA database.journal_mode;
PRAGMA database.journal_mode = mode;

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

ซีเนียร์	ค่า Pragma & คำอธิบาย
1	DELETE นี่คือโหมดเริ่มต้น ในตอนท้ายของธุรกรรมไฟล์เจอร์นัลจะถูกลบ
2	TRUNCATE ไฟล์เจอร์นัลถูกตัดให้มีความยาวเป็นศูนย์ไบต์
3	PERSIST ไฟล์เจอร์นัลถูกทิ้งไว้ แต่ส่วนหัวถูกเขียนทับเพื่อระบุว่าเจอร์นัลไม่ถูกต้องอีกต่อไป
4	MEMORY เร็กคอร์ดเจอร์นัลถูกเก็บไว้ในหน่วยความจำแทนที่จะอยู่ในดิสก์
5	OFF ไม่มีการเก็บบันทึกรายวัน

max_page_count Pragma

max_page_countpragma รับหรือตั้งค่าจำนวนหน้าที่อนุญาตสูงสุดสำหรับฐานข้อมูล ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA [database.]max_page_count;
PRAGMA [database.]max_page_count = max_page;

ค่าดีฟอลต์คือ 1,073,741,823 ซึ่งเป็นหนึ่ง giga-page ซึ่งหมายความว่าหากขนาดเพจเริ่มต้น 1 KB สิ่งนี้จะช่วยให้ฐานข้อมูลเติบโตได้ถึงหนึ่งเทราไบต์

page_count Pragma

page_countpragma ส่งคืนในจำนวนเพจปัจจุบันในฐานข้อมูล ต่อไปนี้เป็นไวยากรณ์อย่างง่าย -

PRAGMA [database.]page_count;

ขนาดของไฟล์ฐานข้อมูลควรเป็น page_count * page_size

page_size Pragma

page_sizepragma รับหรือกำหนดขนาดของเพจฐานข้อมูล ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA [database.]page_size;
PRAGMA [database.]page_size = bytes;

โดยค่าเริ่มต้นขนาดที่อนุญาตคือ 512, 1024, 2048, 4096, 8192, 16384 และ 32768 ไบต์ วิธีเดียวที่จะเปลี่ยนขนาดเพจบนฐานข้อมูลที่มีอยู่คือการตั้งค่าขนาดเพจจากนั้นจึงลดขนาดฐานข้อมูลทันที

parser_trace Pragma

parser_tracepragma ควบคุมการพิมพ์สถานะการดีบักเมื่อแยกวิเคราะห์คำสั่ง SQL ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA parser_trace = [true|false];

โดยค่าเริ่มต้นจะถูกตั้งค่าเป็นเท็จ แต่เมื่อเปิดใช้งานโดยการตั้งค่าเป็นจริงตัวแยกวิเคราะห์ SQL จะพิมพ์สถานะเมื่อแยกวิเคราะห์คำสั่ง SQL

recursive_triggers Pragma

recursive_triggerspragma รับหรือตั้งค่าการทำงานของทริกเกอร์แบบเรียกซ้ำ หากไม่ได้เปิดใช้ทริกเกอร์แบบเรียกซ้ำการทำงานของทริกเกอร์จะไม่เริ่มทริกเกอร์อื่น ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA recursive_triggers;
PRAGMA recursive_triggers = [true|false];

schema_version Pragma

schema_versionpragma รับหรือตั้งค่าเวอร์ชันของสกีมาที่เก็บไว้ในส่วนหัวของฐานข้อมูล ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA [database.]schema_version;
PRAGMA [database.]schema_version = number;

นี่คือค่าจำนวนเต็มที่มีลายเซ็น 32 บิตที่ติดตามการเปลี่ยนแปลงสคีมา เมื่อใดก็ตามที่คำสั่งปรับเปลี่ยนสคีมาถูกเรียกใช้งาน (เช่น CREATE ... หรือ DROP ... ) ค่านี้จะเพิ่มขึ้น

secure_delete Pragma

secure_deletepragma ใช้เพื่อควบคุมวิธีการลบเนื้อหาออกจากฐานข้อมูล ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA secure_delete;
PRAGMA secure_delete = [true|false];
PRAGMA database.secure_delete;
PRAGMA database.secure_delete = [true|false];

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

sql_trace Pragma

sql_tracepragma ใช้เพื่อถ่ายโอนผลลัพธ์การติดตาม SQL ไปยังหน้าจอ ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA sql_trace;
PRAGMA sql_trace = [true|false];

ต้องรวบรวม SQLite ด้วยคำสั่ง SQLITE_DEBUG เพื่อรวม pragma นี้

Pragma แบบซิงโครนัส

synchronouspragma รับหรือตั้งค่าโหมดการซิงโครไนซ์ดิสก์ปัจจุบันซึ่งควบคุมว่า SQLite จะเขียนข้อมูลอย่างจริงจังไปยังที่จัดเก็บข้อมูลทางกายภาพอย่างไร ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA [database.]synchronous;
PRAGMA [database.]synchronous = mode;

SQLite รองรับโหมดการซิงโครไนซ์ต่อไปนี้ตามที่ระบุไว้ในตาราง

ซีเนียร์	ค่า Pragma & คำอธิบาย
1	0 or OFF ไม่มีการซิงค์เลย
2	1 or NORMAL ซิงค์หลังจากการทำงานของดิสก์ที่สำคัญแต่ละลำดับ
3	2 or FULL ซิงค์หลังจากการทำงานของดิสก์ที่สำคัญแต่ละครั้ง

temp_store Pragma

temp_storepragma รับหรือตั้งค่าโหมดการจัดเก็บที่ใช้โดยไฟล์ฐานข้อมูลชั่วคราว ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA temp_store;
PRAGMA temp_store = mode;

SQLite รองรับโหมดการจัดเก็บต่อไปนี้

ซีเนียร์	ค่า Pragma & คำอธิบาย
1	0 or DEFAULT ใช้ค่าเริ่มต้นเวลาคอมไพล์ โดยปกติ FILE.
2	1 or FILE ใช้ที่เก็บข้อมูลแบบไฟล์
3	2 or MEMORY ใช้ที่เก็บข้อมูลที่ใช้หน่วยความจำ

temp_store_directory Pragma

temp_store_directorypragma รับหรือตั้งค่าตำแหน่งที่ใช้สำหรับไฟล์ฐานข้อมูลชั่วคราว ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA temp_store_directory;
PRAGMA temp_store_directory = 'directory_path';

user_version Pragma

user_versionpragma รับหรือตั้งค่าเวอร์ชันที่ผู้ใช้กำหนดเองซึ่งเก็บไว้ในส่วนหัวของฐานข้อมูล ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA [database.]user_version;
PRAGMA [database.]user_version = number;

นี่คือค่าจำนวนเต็มที่มีลายเซ็น 32 บิตซึ่งนักพัฒนาสามารถกำหนดได้เพื่อวัตถุประสงค์ในการติดตามเวอร์ชัน

writable_schema Pragma

writable_schemapragma รับหรือตั้งค่าความสามารถในการแก้ไขตารางระบบ ต่อไปนี้เป็นไวยากรณ์ง่ายๆ

PRAGMA writable_schema;
PRAGMA writable_schema = [true|false];

หากตั้งค่า pragma นี้ตารางที่ขึ้นต้นด้วย sqlite_ สามารถสร้างและแก้ไขได้รวมทั้งตาราง sqlite_master โปรดใช้ความระมัดระวังในขณะที่ใช้ pragma เนื่องจากอาจทำให้ฐานข้อมูลเสียหายทั้งหมด

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

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

ต่อไปนี้เป็นข้อ จำกัด ที่ใช้กันทั่วไปใน SQLite

• NOT NULL Constraint - ตรวจสอบให้แน่ใจว่าคอลัมน์ต้องไม่มีค่า NULL

• DEFAULT Constraint - ระบุค่าเริ่มต้นสำหรับคอลัมน์เมื่อไม่มีการระบุ

• UNIQUE Constraint - ตรวจสอบให้แน่ใจว่าค่าทั้งหมดในคอลัมน์แตกต่างกัน

• PRIMARY Key - ระบุแต่ละแถว / ระเบียนในตารางฐานข้อมูลโดยไม่ซ้ำกัน

• CHECK Constraint - ตรวจสอบให้แน่ใจว่าค่าทั้งหมดในคอลัมน์เป็นไปตามเงื่อนไขบางประการ

ข้อ จำกัด ไม่ใช่โมฆะ

ตามค่าเริ่มต้นคอลัมน์สามารถเก็บค่า NULL ได้ หากคุณไม่ต้องการให้คอลัมน์มีค่า NULL คุณต้องกำหนดข้อ จำกัด ดังกล่าวในคอลัมน์นี้โดยระบุว่าตอนนี้ไม่อนุญาตให้มีค่า NULL สำหรับคอลัมน์นั้น

NULL ไม่เหมือนกับไม่มีข้อมูล แต่แสดงถึงข้อมูลที่ไม่รู้จัก

ตัวอย่าง

ตัวอย่างเช่นคำสั่ง SQLite ต่อไปนี้จะสร้างตารางใหม่ชื่อ COMPANY และเพิ่มคอลัมน์ห้าคอลัมน์โดยสามคอลัมน์คือ ID และ NAME และ AGE ระบุว่าไม่ยอมรับ NULL

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

ข้อ จำกัด เริ่มต้น

ข้อ จำกัด DEFAULT จัดเตรียมค่าเริ่มต้นให้กับคอลัมน์เมื่อคำสั่ง INSERT INTO ไม่ได้ระบุค่าเฉพาะ

ตัวอย่าง

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

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL    DEFAULT 50000.00
);

ข้อ จำกัด ที่ไม่ซ้ำใคร

UNIQUE Constraint ป้องกันไม่ให้สองระเบียนมีค่าเหมือนกันในคอลัมน์ใดคอลัมน์หนึ่ง ตัวอย่างเช่นในตาราง COMPANY คุณอาจต้องการป้องกันไม่ให้คนสองคนหรือมากกว่านั้นมีอายุเท่ากัน

ตัวอย่าง

ตัวอย่างเช่นคำสั่ง SQLite ต่อไปนี้จะสร้างตารางใหม่ชื่อ COMPANY และเพิ่มห้าคอลัมน์ ที่นี่คอลัมน์ AGE ถูกตั้งค่าเป็น UNIQUE ดังนั้นคุณจึงไม่สามารถมีสองระเบียนที่มีอายุเท่ากันได้ -

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL UNIQUE,
   ADDRESS        CHAR(50),
   SALARY         REAL    DEFAULT 50000.00
);

ข้อ จำกัด ที่สำคัญหลัก

ข้อ จำกัด ของ PRIMARY KEY จะระบุแต่ละระเบียนในตารางฐานข้อมูลโดยไม่ซ้ำกัน สามารถมีคอลัมน์ที่ไม่ซ้ำกันได้มากกว่า แต่จะมีคีย์หลักเพียงรายการเดียวในตาราง คีย์หลักมีความสำคัญเมื่อออกแบบตารางฐานข้อมูล คีย์หลักคือรหัสเฉพาะ

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

คีย์หลักคือเขตข้อมูลในตารางซึ่งระบุแต่ละแถว / ระเบียนในตารางฐานข้อมูลโดยไม่ซ้ำกัน คีย์หลักต้องมีค่าที่ไม่ซ้ำกัน คอลัมน์คีย์หลักต้องไม่มีค่า NULL

ตารางสามารถมีคีย์หลักได้เพียงคีย์เดียวซึ่งอาจประกอบด้วยฟิลด์เดียวหรือหลายฟิลด์ เมื่อใช้หลายช่องเป็นคีย์หลักจะเรียกว่า acomposite key.

หากตารางมีคีย์หลักที่กำหนดไว้ในฟิลด์ใด ๆ คุณจะไม่สามารถมีสองระเบียนที่มีค่าเดียวกันของฟิลด์นั้น

ตัวอย่าง

คุณได้เห็นตัวอย่างต่างๆด้านบนแล้วซึ่งเราได้สร้างตาราง COMPANY โดยมี ID เป็นคีย์หลัก

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

ตรวจสอบข้อ จำกัด

CHECK Constraint เปิดใช้งานเงื่อนไขเพื่อตรวจสอบค่าที่ป้อนลงในเรกคอร์ด หากเงื่อนไขประเมินว่าเป็นเท็จบันทึกจะละเมิดข้อ จำกัด และไม่ได้ป้อนลงในตาราง

ตัวอย่าง

ตัวอย่างเช่น SQLite ต่อไปนี้สร้างตารางใหม่ชื่อ COMPANY และเพิ่มห้าคอลัมน์ ที่นี่เราเพิ่มคอลัมน์ CHECK with SALARY เพื่อไม่ให้คุณมี SALARY Zero

CREATE TABLE COMPANY3(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL    CHECK(SALARY > 0)
);

การลดข้อ จำกัด

SQLite สนับสนุนชุดย่อยที่ จำกัด ของ ALTER TABLE คำสั่ง ALTER TABLE ใน SQLite อนุญาตให้ผู้ใช้เปลี่ยนชื่อตารางหรือเพิ่มคอลัมน์ใหม่ลงในตารางที่มีอยู่ ไม่สามารถเปลี่ยนชื่อคอลัมน์ลบคอลัมน์หรือเพิ่มหรือลบข้อ จำกัด ออกจากตารางได้

SQLite Joinsอนุประโยคใช้เพื่อรวมระเบียนจากตารางสองตารางขึ้นไปในฐานข้อมูล JOIN เป็นวิธีการรวมฟิลด์จากสองตารางโดยใช้ค่าร่วมกันของแต่ละตาราง

SQL กำหนดการรวมสามประเภทหลัก ๆ -

• CROSS เข้าร่วม
• การเข้าร่วมภายใน
• การเข้าร่วมภายนอก

ก่อนที่จะดำเนินการต่อลองพิจารณาสองตาราง COMPANY และ DEPARTMENT เราได้เห็นคำสั่ง INSERT เพื่อเติมข้อมูลตาราง COMPANY แล้ว สมมติว่ารายการบันทึกที่มีอยู่ในตาราง COMPANY -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ตารางอื่นคือ DEPARTMENT โดยมีคำจำกัดความดังต่อไปนี้ -

CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

นี่คือรายการของคำสั่ง INSERT เพื่อเติมข้อมูลตาราง DEPARTMENT -

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (1, 'IT Billing', 1 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (2, 'Engineering', 2 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (3, 'Finance', 7 );

ในที่สุดเรามีรายการบันทึกต่อไปนี้ในตาราง DEPARTMENT -

ID          DEPT        EMP_ID
----------  ----------  ----------
1           IT Billing  1
2           Engineering 2
3           Finance     7

CROSS เข้าร่วม

CROSS JOIN จับคู่ทุกแถวของตารางแรกกับทุกแถวของตารางที่สอง หากตารางอินพุตมีแถว x และ y ตามลำดับตารางผลลัพธ์จะมีแถว x * y เนื่องจาก CROSS JOIN มีศักยภาพในการสร้างตารางขนาดใหญ่มากจึงต้องใช้ความระมัดระวังในการใช้งานตามความเหมาะสมเท่านั้น

ต่อไปนี้เป็นไวยากรณ์ของ CROSS JOIN -

SELECT ... FROM table1 CROSS JOIN table2 ...

จากตารางด้านบนคุณสามารถเขียน CROSS JOIN ได้ดังนี้ -

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;

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

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Paul        Engineering
7           Paul        Finance
1           Allen       IT Billing
2           Allen       Engineering
7           Allen       Finance
1           Teddy       IT Billing
2           Teddy       Engineering
7           Teddy       Finance
1           Mark        IT Billing
2           Mark        Engineering
7           Mark        Finance
1           David       IT Billing
2           David       Engineering
7           David       Finance
1           Kim         IT Billing
2           Kim         Engineering
7           Kim         Finance
1           James       IT Billing
2           James       Engineering
7           James       Finance

การเข้าร่วมภายใน

INNER JOIN สร้างตารางผลลัพธ์ใหม่โดยการรวมค่าคอลัมน์ของสองตาราง (table1 และ table2) ตามการเข้าร่วมเพรดิเคต แบบสอบถามเปรียบเทียบแต่ละแถวของ table1 กับแต่ละแถวของ table2 เพื่อค้นหาคู่ของแถวทั้งหมดที่ตรงตามเงื่อนไขการรวม เมื่อเข้าร่วมเพรดิเคตเป็นที่พอใจแล้วค่าของคอลัมน์สำหรับแถว A และ B ที่ตรงกันแต่ละคู่จะรวมกันเป็นแถวผลลัพธ์

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

ต่อไปนี้เป็นไวยากรณ์ของ INNER JOIN -

SELECT ... FROM table1 [INNER] JOIN table2 ON conditional_expression ...

เพื่อหลีกเลี่ยงความซ้ำซ้อนและทำให้วลีสั้นลงสามารถประกาศเงื่อนไข INNER JOIN ด้วย a USINGนิพจน์. นิพจน์นี้ระบุรายการคอลัมน์อย่างน้อยหนึ่งคอลัมน์

SELECT ... FROM table1 JOIN table2 USING ( column1 ,... ) ...

NATURAL JOIN คล้ายกับไฟล์ JOIN...USINGเพียง แต่จะทดสอบความเท่าเทียมกันโดยอัตโนมัติระหว่างค่าของทุกคอลัมน์ที่มีอยู่ในทั้งสองตาราง -

SELECT ... FROM table1 NATURAL JOIN table2...

จากตารางด้านบนคุณสามารถเขียน INNER JOIN ได้ดังนี้ -

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

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

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Allen       Engineering
7           James       Finance

การเข้าร่วมภายนอก

OUTER JOIN เป็นส่วนเสริมของ INNER JOIN แม้ว่ามาตรฐาน SQL จะกำหนดประเภทของการเข้าร่วมภายนอกสามประเภท: LEFT, RIGHT และ FULL แต่ SQLite รองรับเฉพาะLEFT OUTER JOIN.

การเข้าร่วมภายนอกมีเงื่อนไขที่เหมือนกับการเข้าร่วมภายในซึ่งแสดงโดยใช้คีย์เวิร์ด ON, USING หรือ NATURAL ตารางผลลัพธ์เริ่มต้นคำนวณในลักษณะเดียวกัน เมื่อคำนวณ JOIN หลักแล้ว OUTER JOIN จะนำแถวที่ไม่ได้เข้าร่วมจากตารางหนึ่งหรือทั้งสองตารางใส่ค่า NULL และผนวกเข้ากับตารางผลลัพธ์

ต่อไปนี้เป็นไวยากรณ์ของ LEFT OUTER JOIN -

SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...

เพื่อหลีกเลี่ยงความซ้ำซ้อนและทำให้วลีสั้นลงสามารถประกาศเงื่อนไข OUTER JOIN ด้วยนิพจน์ USING นิพจน์นี้ระบุรายการคอลัมน์อย่างน้อยหนึ่งคอลัมน์

SELECT ... FROM table1 LEFT OUTER JOIN table2 USING ( column1 ,... ) ...

จากตารางด้านบนคุณสามารถเขียนการรวมภายในได้ดังนี้ -

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

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

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Allen       Engineering
            Teddy
            Mark
            David
            Kim
7           James       Finance

SQLite UNION อนุประโยค / ตัวดำเนินการใช้เพื่อรวมผลลัพธ์ของคำสั่ง SELECT สองคำขึ้นไปโดยไม่ส่งคืนแถวที่ซ้ำกัน

ในการใช้ UNION แต่ละ SELECT ต้องมีจำนวนคอลัมน์ที่เลือกเท่ากันจำนวนนิพจน์คอลัมน์เดียวกันชนิดข้อมูลเดียวกันและจัดเรียงไว้ในลำดับเดียวกัน แต่ไม่จำเป็นต้องมีความยาวเท่ากัน

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ UNION.

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

เงื่อนไขที่กำหนดอาจเป็นนิพจน์ใดก็ได้ตามความต้องการของคุณ

ตัวอย่าง

พิจารณาต่อไปนี้สองตาราง (ก) บริษัทตารางดังต่อไปนี้ -

sqlite> select * from COMPANY;
ID          NAME                  AGE         ADDRESS     SALARY
----------  --------------------  ----------  ----------  ----------
1           Paul                  32          California  20000.0
2           Allen                 25          Texas       15000.0
3           Teddy                 23          Norway      20000.0
4           Mark                  25          Rich-Mond   65000.0
5           David                 27          Texas       85000.0
6           Kim                   22          South-Hall  45000.0
7           James                 24          Houston     10000.0

(b) ตารางอื่นคือDEPARTMENTดังต่อไปนี้ -

ID          DEPT                  EMP_ID
----------  --------------------  ----------
1           IT Billing            1
2           Engineering           2
3           Finance               7
4           Engineering           3
5           Finance               4
6           Engineering           5
7           Finance               6

ตอนนี้ให้เราเข้าร่วมสองตารางนี้โดยใช้คำสั่ง SELECT พร้อมกับอนุประโยคดังนี้ -

sqlite>  SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID
         
         UNION
         
         SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

EMP_ID      NAME                  DEPT
----------  --------------------  ----------
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance

UNION ALL Clause

ตัวดำเนินการ UNION ALL ใช้เพื่อรวมผลลัพธ์ของคำสั่ง SELECT สองรายการรวมทั้งแถวที่ซ้ำกัน

กฎเดียวกันที่ใช้กับ UNION จะใช้กับตัวดำเนินการ UNION ALL ด้วยเช่นกัน

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ UNION ALL.

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION ALL

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

เงื่อนไขที่กำหนดอาจเป็นนิพจน์ใดก็ได้ตามความต้องการของคุณ

ตัวอย่าง

ตอนนี้ให้เราเข้าร่วมสองตารางที่กล่าวถึงข้างต้นในคำสั่ง SELECT ของเราดังนี้ -

sqlite>  SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID
         
         UNION ALL

         SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

EMP_ID      NAME                  DEPT
----------  --------------------  ----------
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance

SQLite NULLคือคำที่ใช้แทนค่าที่ขาดหายไป ค่า NULL ในตารางคือค่าในเขตข้อมูลที่ดูเหมือนจะว่างเปล่า

เขตข้อมูลที่มีค่า NULL คือเขตข้อมูลที่ไม่มีค่า เป็นสิ่งสำคัญมากที่ต้องเข้าใจว่าค่า NULL แตกต่างจากค่าศูนย์หรือเขตข้อมูลที่มีช่องว่าง

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของการใช้ NULL ขณะสร้างตาราง

SQLite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

ที่นี่ NOT NULLหมายความว่าคอลัมน์ควรยอมรับค่าที่ชัดเจนของชนิดข้อมูลที่กำหนดเสมอ มีสองคอลัมน์ที่เราไม่ได้ใช้ NOT NULL ซึ่งหมายความว่าคอลัมน์เหล่านี้อาจเป็น NULL

ฟิลด์ที่มีค่า NULL คือฟิลด์ที่เว้นว่างไว้ระหว่างการสร้างเรกคอร์ด

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ให้เราใช้คำสั่ง UPDATE เพื่อกำหนดค่าว่างไม่กี่ค่าเป็น NULL ดังนี้ -

sqlite> UPDATE COMPANY SET ADDRESS = NULL, SALARY = NULL where ID IN(6,7);

ตอนนี้ตาราง COMPANY จะมีบันทึกต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22
7           James       24

ต่อไปให้เราดูการใช้งานของ IS NOT NULL ตัวดำเนินการเพื่อแสดงรายการบันทึกทั้งหมดโดยที่ SALARY ไม่ใช่ NULL

sqlite> SELECT  ID, NAME, AGE, ADDRESS, SALARY
        FROM COMPANY
        WHERE SALARY IS NOT NULL;

คำสั่ง SQLite ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

ต่อไปนี้คือการใช้งานไฟล์ IS NULL ตัวดำเนินการซึ่งจะแสดงรายการบันทึกทั้งหมดโดยที่ SALARY เป็น NULL

sqlite> SELECT  ID, NAME, AGE, ADDRESS, SALARY
        FROM COMPANY
        WHERE SALARY IS NULL;

คำสั่ง SQLite ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
6           Kim         22
7           James       24

คุณสามารถเปลี่ยนชื่อตารางหรือคอลัมน์ชั่วคราวโดยตั้งชื่ออื่นซึ่งเรียกว่า ALIAS. การใช้นามแฝงของตารางหมายถึงการเปลี่ยนชื่อตารางในคำสั่ง SQLite เฉพาะ การเปลี่ยนชื่อเป็นการเปลี่ยนแปลงชั่วคราวและชื่อตารางจริงจะไม่เปลี่ยนแปลงในฐานข้อมูล

นามแฝงของคอลัมน์ใช้เพื่อเปลี่ยนชื่อคอลัมน์ของตารางเพื่อวัตถุประสงค์ในการสืบค้น SQLite โดยเฉพาะ

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ table นามแฝง.

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ column นามแฝง.

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

ตัวอย่าง

พิจารณาสองตารางต่อไปนี้ (a) ตารางCOMPANYมีดังนี้ -

sqlite> select * from COMPANY;
ID          NAME                  AGE         ADDRESS     SALARY
----------  --------------------  ----------  ----------  ----------
1           Paul                  32          California  20000.0
2           Allen                 25          Texas       15000.0
3           Teddy                 23          Norway      20000.0
4           Mark                  25          Rich-Mond   65000.0
5           David                 27          Texas       85000.0
6           Kim                   22          South-Hall  45000.0
7           James                 24          Houston     10000.0

(b) ตารางอื่นคือDEPARTMENTดังต่อไปนี้ -

ID          DEPT                  EMP_ID
----------  --------------------  ----------
1           IT Billing            1
2           Engineering           2
3           Finance               7
4           Engineering           3
5           Finance               4
6           Engineering           5
7           Finance               6

ต่อไปนี้คือการใช้งาน TABLE ALIAS โดยที่เราใช้ C และ D เป็นนามแฝงสำหรับตาราง COMPANY และ DEPARTMENT ตามลำดับ -

sqlite> SELECT C.ID, C.NAME, C.AGE, D.DEPT
        FROM COMPANY AS C, DEPARTMENT AS D
        WHERE  C.ID = D.EMP_ID;

คำสั่ง SQLite ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -

ID          NAME        AGE         DEPT
----------  ----------  ----------  ----------
1           Paul        32          IT Billing
2           Allen       25          Engineering
3           Teddy       23          Engineering
4           Mark        25          Finance
5           David       27          Engineering
6           Kim         22          Finance
7           James       24          Finance

ลองพิจารณาตัวอย่างการใช้งาน COLUMN ALIAS โดย COMPANY_ID เป็นชื่อแทนของคอลัมน์ ID และ COMPANY_NAME เป็นชื่อแทนของคอลัมน์

sqlite> SELECT C.ID AS COMPANY_ID, C.NAME AS COMPANY_NAME, C.AGE, D.DEPT
        FROM COMPANY AS C, DEPARTMENT AS D
        WHERE  C.ID = D.EMP_ID;

คำสั่ง SQLite ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -

COMPANY_ID  COMPANY_NAME  AGE         DEPT
----------  ------------  ----------  ----------
1           Paul          32          IT Billing
2           Allen         25          Engineering
3           Teddy         23          Engineering
4           Mark          25          Finance
5           David         27          Engineering
6           Kim           22          Finance
7           James         24          Finance

SQLite Triggersเป็นฟังก์ชันเรียกกลับฐานข้อมูลซึ่งจะดำเนินการ / เรียกใช้โดยอัตโนมัติเมื่อเกิดเหตุการณ์ฐานข้อมูลที่ระบุ ต่อไปนี้เป็นประเด็นสำคัญเกี่ยวกับทริกเกอร์ SQLite -

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

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

• ทั้งคำสั่ง WHEN และการดำเนินการทริกเกอร์อาจเข้าถึงองค์ประกอบของแถวที่ถูกแทรกลบหรืออัปเดตโดยใช้การอ้างอิงของแบบฟอร์ม NEW.column-name และ OLD.column-nameโดยที่ชื่อคอลัมน์คือชื่อของคอลัมน์จากตารางที่เกี่ยวข้องกับทริกเกอร์

• หากมีการระบุคำสั่ง WHEN คำสั่ง SQL ที่ระบุจะถูกดำเนินการสำหรับแถวที่มีคำสั่ง WHEN เป็นจริงเท่านั้น หากไม่มีระบุ WHEN clause คำสั่ง SQL จะถูกเรียกใช้งานสำหรับทุกแถว

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

• ทริกเกอร์จะหลุดโดยอัตโนมัติเมื่อตารางที่เกี่ยวข้องถูกทิ้ง

• ตารางที่จะแก้ไขต้องมีอยู่ในฐานข้อมูลเดียวกับตารางหรือมุมมองที่แนบทริกเกอร์และต้องใช้เพียง tablename ไม่ database.tablename.

• ฟังก์ชัน SQL พิเศษ RAISE () อาจถูกใช้ภายในโปรแกรมทริกเกอร์เพื่อเพิ่มข้อยกเว้น

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของการสร้างไฟล์ trigger.

CREATE TRIGGER trigger_name [BEFORE|AFTER] event_name 
ON table_name
BEGIN
 -- Trigger logic goes here....
END;

ที่นี่ event_nameอาจเป็นการดำเนินการฐานข้อมูลINSERT ลบและUPDATEบนตารางที่กล่าวถึงtable_name. คุณสามารถเลือกระบุสำหรับแต่ละแถวหลังชื่อตารางได้

ต่อไปนี้เป็นไวยากรณ์สำหรับการสร้างทริกเกอร์ในการดำเนินการ UPDATE บนคอลัมน์ที่ระบุอย่างน้อยหนึ่งคอลัมน์ของตาราง

CREATE TRIGGER trigger_name [BEFORE|AFTER] UPDATE OF column_name 
ON table_name
BEGIN
   -- Trigger logic goes here....
END;

ตัวอย่าง

ให้เราพิจารณากรณีที่เราต้องการทำการทดลองตรวจสอบสำหรับทุกระเบียนที่แทรกในตาราง COMPANY ซึ่งเราสร้างขึ้นใหม่ดังต่อไปนี้ (วางตาราง COMPANY หากคุณมีอยู่แล้ว)

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

เพื่อทำการทดลองตรวจสอบต่อไปเราจะสร้างตารางใหม่ชื่อ AUDIT ซึ่งจะแทรกข้อความบันทึกเมื่อใดก็ตามที่มีรายการในตาราง COMPANY สำหรับบันทึกใหม่

sqlite> CREATE TABLE AUDIT(
   EMP_ID INT NOT NULL,
   ENTRY_DATE TEXT NOT NULL
);

ในที่นี้ ID คือ ID เร็กคอร์ด AUDIT และ EMP_ID คือ ID ซึ่งจะมาจากตาราง COMPANY และ DATE จะเก็บการประทับเวลาเมื่อสร้างเรกคอร์ดในตาราง COMPANY ตอนนี้เรามาสร้างทริกเกอร์บนตาราง COMPANY ดังนี้ -

sqlite> CREATE TRIGGER audit_log AFTER INSERT 
ON COMPANY
BEGIN
   INSERT INTO AUDIT(EMP_ID, ENTRY_DATE) VALUES (new.ID, datetime('now'));
END;

ตอนนี้เราจะเริ่มงานจริงเริ่มแทรกบันทึกในตาราง COMPANY ซึ่งจะส่งผลให้สร้างบันทึกบันทึกการตรวจสอบในตาราง AUDIT สร้างหนึ่งระเบียนในตาราง COMPANY ดังนี้ -

sqlite> INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

สิ่งนี้จะสร้างหนึ่งระเบียนในตาราง COMPANY ซึ่งมีดังต่อไปนี้ -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0

ในเวลาเดียวกันจะมีการสร้างหนึ่งระเบียนในตาราง AUDIT บันทึกนี้เป็นผลมาจากทริกเกอร์ซึ่งเราได้สร้างขึ้นในการดำเนินการ INSERT ในตาราง COMPANY ในทำนองเดียวกันคุณสามารถสร้างทริกเกอร์ของคุณในการอัปเดตและลบการดำเนินการตามความต้องการของคุณ

EMP_ID      ENTRY_DATE
----------  -------------------
1           2013-04-05 06:26:00

รายการทริกเกอร์

คุณสามารถแสดงรายการทริกเกอร์ทั้งหมดได้จาก sqlite_master ตารางดังนี้ -

sqlite> SELECT name FROM sqlite_master
WHERE type = 'trigger';

คำสั่ง SQLite ด้านบนจะแสดงรายการเพียงรายการเดียวดังนี้ -

name
----------
audit_log

หากคุณต้องการแสดงรายการทริกเกอร์บนตารางใดตารางหนึ่งให้ใช้ AND clause กับชื่อตารางดังนี้ -

sqlite> SELECT name FROM sqlite_master
WHERE type = 'trigger' AND tbl_name = 'COMPANY';

คำสั่ง SQLite ข้างต้นจะแสดงรายการเพียงรายการเดียวดังนี้ -

name
----------
audit_log

ทริกเกอร์ลดลง

ต่อไปนี้คือคำสั่ง DROP ซึ่งสามารถใช้เพื่อวางทริกเกอร์ที่มีอยู่

sqlite> DROP TRIGGER trigger_name;

ดัชนีคือตารางการค้นหาพิเศษที่เครื่องมือค้นหาฐานข้อมูลสามารถใช้เพื่อเร่งความเร็วในการดึงข้อมูล ใส่เพียงแค่ไฟล์indexเป็นตัวชี้ไปยังข้อมูลในตาราง ดัชนีในฐานข้อมูลคล้ายกับดัชนีที่อยู่ด้านหลังของหนังสือ

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

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

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

ดัชนีสามารถไม่ซ้ำกันได้เช่นเดียวกับข้อ จำกัด UNIQUE เนื่องจากดัชนีป้องกันรายการที่ซ้ำกันในคอลัมน์หรือการรวมกันของคอลัมน์ที่มีดัชนี

คำสั่ง CREATE INDEX

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ CREATE INDEX.

CREATE INDEX index_name ON table_name;

ดัชนีคอลัมน์เดียว

ดัชนีคอลัมน์เดียวคือดัชนีที่สร้างขึ้นจากคอลัมน์ในตารางเดียวเท่านั้น ไวยากรณ์พื้นฐานมีดังนี้ -

CREATE INDEX index_name
ON table_name (column_name);

ดัชนีเฉพาะ

ดัชนีเฉพาะไม่เพียง แต่ใช้เพื่อประสิทธิภาพเท่านั้น แต่ยังใช้เพื่อความสมบูรณ์ของข้อมูลด้วย ดัชนีที่ไม่ซ้ำกันไม่อนุญาตให้แทรกค่าที่ซ้ำกันลงในตาราง ไวยากรณ์พื้นฐานมีดังนี้ -

CREATE UNIQUE INDEX index_name
on table_name (column_name);

ดัชนีคอมโพสิต

ดัชนีผสมคือดัชนีในคอลัมน์สองคอลัมน์ขึ้นไปของตาราง ไวยากรณ์พื้นฐานมีดังนี้ -

CREATE INDEX index_name
on table_name (column1, column2);

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

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

ดัชนีโดยนัย

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

Example

ต่อไปนี้เป็นตัวอย่างที่เราจะสร้างดัชนีในบริษัทตารางสำหรับคอลัมน์เงินเดือน -

sqlite> CREATE INDEX salary_index ON COMPANY (salary);

ตอนนี้ขอแสดงรายการดัชนีทั้งหมดที่มีอยู่ในตาราง COMPANY โดยใช้ .indices คำสั่งดังนี้ -

sqlite> .indices COMPANY

สิ่งนี้จะให้ผลลัพธ์ต่อไปนี้โดยที่sqlite_autoindex_COMPANY_1เป็นดัชนีโดยปริยายซึ่งถูกสร้างขึ้นเมื่อสร้างตารางขึ้นเอง

salary_index
sqlite_autoindex_COMPANY_1

คุณสามารถแสดงฐานข้อมูลดัชนีทั้งหมดได้ดังนี้ -

sqlite> SELECT * FROM sqlite_master WHERE type = 'index';

คำสั่ง DROP INDEX

ดัชนีสามารถทิ้งได้โดยใช้ SQLite DROPคำสั่ง ควรใช้ความระมัดระวังเมื่อวางดัชนีเนื่องจากประสิทธิภาพอาจช้าลงหรือดีขึ้น

ต่อไปนี้เป็นไวยากรณ์พื้นฐานมีดังนี้ -

DROP INDEX index_name;

คุณสามารถใช้คำสั่งต่อไปนี้เพื่อลบดัชนีที่สร้างไว้ก่อนหน้านี้

sqlite> DROP INDEX salary_index;

เมื่อใดควรหลีกเลี่ยงดัชนี

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

ไม่ควรใช้ดัชนีใน -

• โต๊ะเล็ก ๆ
• ตารางที่มีการอัปเดตแบตช์จำนวนมากบ่อยครั้งหรือการแทรกการดำเนินการ
• คอลัมน์ที่มีค่า NULL จำนวนมาก
• คอลัมน์ที่มีการจัดการบ่อยๆ

ส่วนคำสั่ง "INDEXED BY index-name" ระบุว่าต้องใช้ดัชนีที่ตั้งชื่อเพื่อค้นหาค่าในตารางก่อนหน้า

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

ส่วนคำสั่ง "NOT INDEXED" ระบุว่าจะไม่มีการใช้ดัชนีเมื่อเข้าถึงตารางก่อนหน้านี้รวมถึงดัชนีโดยนัยที่สร้างขึ้นโดยข้อ จำกัด UNIQUE และ PRIMARY KEY

อย่างไรก็ตามยังสามารถใช้ INTEGER PRIMARY KEY เพื่อค้นหารายการได้แม้ว่าจะระบุ "NOT INDEXED" ก็ตาม

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์สำหรับคำสั่ง INDEXED BY และสามารถใช้กับคำสั่ง DELETE, UPDATE หรือ SELECT

SELECT|DELETE|UPDATE column1, column2...
INDEXED BY (index_name)
table_name
WHERE (CONDITION);

ตัวอย่าง

พิจารณาตารางCOMPANYเราจะสร้างดัชนีและใช้สำหรับการดำเนินการ INDEXED BY

sqlite> CREATE INDEX salary_index ON COMPANY(salary);
sqlite>

ตอนนี้เลือกข้อมูลจากตาราง COMPANY คุณสามารถใช้ INDEXED BY clause ได้ดังนี้ -

sqlite> SELECT * FROM COMPANY INDEXED BY salary_index WHERE salary > 5000;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
7           James       24          Houston     10000.0
2           Allen       25          Texas       15000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

SQLite ALTER TABLEคำสั่งแก้ไขตารางที่มีอยู่โดยไม่ต้องดำเนินการดัมพ์ทั้งหมดและโหลดข้อมูลซ้ำ คุณสามารถเปลี่ยนชื่อตารางโดยใช้คำสั่ง ALTER TABLE และสามารถเพิ่มคอลัมน์เพิ่มเติมในตารางที่มีอยู่ได้โดยใช้คำสั่ง ALTER TABLE

ไม่มีการดำเนินการอื่นที่สนับสนุนโดยคำสั่ง ALTER TABLE ใน SQLite ยกเว้นการเปลี่ยนชื่อตารางและเพิ่มคอลัมน์ในตารางที่มีอยู่

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ ALTER TABLE เพื่อ RENAME ตารางที่มีอยู่

ALTER TABLE database_name.table_name RENAME TO new_table_name;

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ ALTER TABLE เพื่อเพิ่มคอลัมน์ใหม่ในตารางที่มีอยู่

ALTER TABLE database_name.table_name ADD COLUMN column_def...;

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ตอนนี้เรามาลองเปลี่ยนชื่อตารางนี้โดยใช้คำสั่ง ALTER TABLE ดังนี้ -

sqlite> ALTER TABLE COMPANY RENAME TO OLD_COMPANY;

คำสั่ง SQLite ข้างต้นจะเปลี่ยนชื่อตาราง COMPANY เป็น OLD_COMPANY ตอนนี้เรามาลองเพิ่มคอลัมน์ใหม่ในตาราง OLD_COMPANY ดังนี้ -

sqlite> ALTER TABLE OLD_COMPANY ADD COLUMN SEX char(1);

ตาราง COMPANY เปลี่ยนไปแล้วและต่อไปนี้จะเป็นผลลัพธ์จากคำสั่ง SELECT

ID          NAME        AGE         ADDRESS     SALARY      SEX
----------  ----------  ----------  ----------  ----------  ---
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ควรสังเกตว่าคอลัมน์ที่เพิ่มใหม่เต็มไปด้วยค่า NULL

ขออภัยเราไม่มีคำสั่ง TRUNCATE TABLE ใน SQLite แต่คุณสามารถใช้ SQLite ได้ DELETE คำสั่งเพื่อลบข้อมูลทั้งหมดออกจากตารางที่มีอยู่แม้ว่าจะแนะนำให้ใช้คำสั่ง DROP TABLE เพื่อวางตารางที่สมบูรณ์และสร้างใหม่อีกครั้ง

ไวยากรณ์

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

sqlite> DELETE FROM table_name;

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ DROP TABLE

sqlite> DROP TABLE table_name;

หากคุณใช้คำสั่ง DELETE TABLE เพื่อลบระเบียนทั้งหมดขอแนะนำให้ใช้ VACUUM คำสั่งเพื่อล้างพื้นที่ที่ไม่ได้ใช้งาน

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ต่อไปนี้เป็นตัวอย่างการตัดทอนตารางด้านบน -

SQLite> DELETE FROM COMPANY;
SQLite> VACUUM;

ตอนนี้ตาราง COMPANY ถูกตัดทอนอย่างสมบูรณ์และจะไม่มีผลลัพธ์จากคำสั่ง SELECT

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

มุมมองสามารถมีแถวทั้งหมดของตารางหรือแถวที่เลือกจากตารางอย่างน้อยหนึ่งตาราง สามารถสร้างมุมมองได้จากตารางเดียวหรือหลายตารางซึ่งขึ้นอยู่กับคิวรี SQLite ที่เขียนเพื่อสร้างมุมมอง

มุมมองซึ่งเป็นตารางเสมือนจริงอนุญาตให้ผู้ใช้ -

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

• จำกัด การเข้าถึงข้อมูลเพื่อให้ผู้ใช้เห็นเฉพาะข้อมูลที่ จำกัด แทนที่จะเป็นตารางทั้งหมด

• สรุปข้อมูลจากตารางต่างๆซึ่งสามารถใช้ในการสร้างรายงาน

มุมมอง SQLite เป็นแบบอ่านอย่างเดียวดังนั้นคุณอาจไม่สามารถดำเนินการคำสั่ง DELETE, INSERT หรือ UPDATE ในมุมมองได้ อย่างไรก็ตามคุณสามารถสร้างทริกเกอร์ในมุมมองที่เริ่มทำงานเมื่อพยายามลบแทรกหรืออัปเดตมุมมองและทำสิ่งที่คุณต้องการในเนื้อหาของทริกเกอร์

การสร้างมุมมอง

มุมมอง SQLite ถูกสร้างขึ้นโดยใช้ไฟล์ CREATE VIEWคำให้การ. มุมมอง SQLite สามารถสร้างจากตารางเดียวหลายตารางหรือมุมมองอื่น

ต่อไปนี้เป็นไวยากรณ์ CREATE VIEW พื้นฐาน

CREATE [TEMP | TEMPORARY] VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

คุณสามารถรวมหลายตารางในคำสั่ง SELECT ของคุณในลักษณะเดียวกันกับที่คุณใช้ในแบบสอบถาม SQL SELECT ปกติ หากมีคีย์เวิร์ด TEMP หรือ TEMPORARY ที่เป็นทางเลือกมุมมองจะถูกสร้างขึ้นในฐานข้อมูลชั่วคราว

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ต่อไปนี้เป็นตัวอย่างในการสร้างมุมมองจากตาราง COMPANY มุมมองนี้จะใช้เพื่อให้มีคอลัมน์เพียงไม่กี่คอลัมน์จากตาราง COMPANY

sqlite> CREATE VIEW COMPANY_VIEW AS
SELECT ID, NAME, AGE
FROM  COMPANY;

ตอนนี้คุณสามารถสืบค้น COMPANY_VIEW ในลักษณะเดียวกันกับที่คุณค้นหาตารางจริง ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT * FROM COMPANY_VIEW;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE
----------  ----------  ----------
1           Paul        32
2           Allen       25
3           Teddy       23
4           Mark        25
5           David       27
6           Kim         22
7           James       24

การลดมุมมอง

ในการวางมุมมองเพียงใช้คำสั่ง DROP VIEW กับ view_name. ไวยากรณ์ DROP VIEW พื้นฐานมีดังนี้ -

sqlite> DROP VIEW view_name;

คำสั่งต่อไปนี้จะลบมุมมอง COMPANY_VIEW ซึ่งเราสร้างไว้ในส่วนสุดท้าย

sqlite> DROP VIEW COMPANY_VIEW;

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

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

ในทางปฏิบัติคุณจะรวบรวมแบบสอบถาม SQLite จำนวนมากไว้ในกลุ่มและคุณจะดำเนินการทั้งหมดร่วมกันเป็นส่วนหนึ่งของธุรกรรม

คุณสมบัติของธุรกรรม

ธุรกรรมมีคุณสมบัติมาตรฐาน 4 ประการดังต่อไปนี้โดยปกติจะอ้างถึงโดยตัวย่อ ACID

• Atomicity- ตรวจสอบให้แน่ใจว่าการดำเนินการทั้งหมดภายในหน่วยงานเสร็จสมบูรณ์ มิฉะนั้นธุรกรรมจะถูกยกเลิกเมื่อถึงจุดที่ล้มเหลวและการดำเนินการก่อนหน้านี้จะย้อนกลับไปสู่สถานะเดิม

• Consistency - ตรวจสอบให้แน่ใจว่าฐานข้อมูลมีการเปลี่ยนแปลงสถานะอย่างเหมาะสมเมื่อทำธุรกรรมสำเร็จ

• Isolation - ช่วยให้การทำธุรกรรมดำเนินการอย่างอิสระและโปร่งใสซึ่งกันและกัน

• Durability - ตรวจสอบให้แน่ใจว่าผลลัพธ์หรือผลของธุรกรรมที่ตกลงกันยังคงมีอยู่ในกรณีที่ระบบล้มเหลว

การควบคุมธุรกรรม

คำสั่งต่อไปนี้ใช้เพื่อควบคุมธุรกรรม:

• BEGIN TRANSACTION - เพื่อเริ่มการทำธุรกรรม

• COMMIT - หากต้องการบันทึกการเปลี่ยนแปลงหรือคุณสามารถใช้ END TRANSACTION คำสั่ง

• ROLLBACK - เพื่อย้อนกลับการเปลี่ยนแปลง

คำสั่งควบคุมธุรกรรมใช้เฉพาะกับคำสั่ง DML INSERT, UPDATE และ DELETE ไม่สามารถใช้ในขณะที่สร้างตารางหรือวางตารางได้เนื่องจากการดำเนินการเหล่านี้ถูกส่งโดยอัตโนมัติในฐานข้อมูล

เริ่มต้นคำสั่งการทำธุรกรรม

ธุรกรรมสามารถเริ่มต้นได้โดยใช้ BEGIN TRANSACTION หรือคำสั่ง BEGIN ธุรกรรมดังกล่าวมักจะคงอยู่จนกว่าจะพบคำสั่ง COMMIT หรือ ROLLBACK ถัดไป อย่างไรก็ตามธุรกรรมจะ ROLLBACK หากฐานข้อมูลถูกปิดหรือหากเกิดข้อผิดพลาด ต่อไปนี้เป็นไวยากรณ์ง่ายๆในการเริ่มต้นธุรกรรม

BEGIN;
or 
BEGIN TRANSACTION;

คำสั่ง COMMIT

คำสั่ง COMMIT คือคำสั่งธุรกรรมที่ใช้เพื่อบันทึกการเปลี่ยนแปลงที่เรียกใช้โดยธุรกรรมไปยังฐานข้อมูล

คำสั่ง COMMIT บันทึกธุรกรรมทั้งหมดลงในฐานข้อมูลตั้งแต่คำสั่ง COMMIT หรือ ROLLBACK สุดท้าย

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

COMMIT;
or
END TRANSACTION;

คำสั่ง ROLLBACK

คำสั่ง ROLLBACK เป็นคำสั่งธุรกรรมที่ใช้ในการเลิกทำธุรกรรมที่ยังไม่ได้บันทึกลงในฐานข้อมูล

คำสั่ง ROLLBACK สามารถใช้เพื่อเลิกทำธุรกรรมได้ตั้งแต่คำสั่ง COMMIT หรือ ROLLBACK ล่าสุดถูกออก

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

ROLLBACK;

Example

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ตอนนี้เรามาเริ่มการทำธุรกรรมและลบบันทึกจากตารางที่มี age = 25 จากนั้นใช้คำสั่ง ROLLBACK เพื่อยกเลิกการเปลี่ยนแปลงทั้งหมด

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> ROLLBACK;

ตอนนี้ถ้าคุณตรวจสอบตาราง COMPANY ก็ยังมีบันทึกต่อไปนี้ -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

เริ่มต้นธุรกรรมใหม่และลบเร็กคอร์ดจากตารางที่มี age = 25 และในที่สุดเราก็ใช้คำสั่ง COMMIT เพื่อทำการเปลี่ยนแปลงทั้งหมด

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> COMMIT;

หากคุณตรวจสอบตาราง COMPANY ตอนนี้ยังมีบันทึกต่อไปนี้ -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

แบบสอบถามย่อยหรือแบบสอบถามภายในหรือแบบสอบถามที่ซ้อนกันคือแบบสอบถามภายในแบบสอบถาม SQLite อื่นและฝังอยู่ภายในส่วนคำสั่ง WHERE

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

สามารถใช้แบบสอบถามย่อยกับคำสั่ง SELECT, INSERT, UPDATE และ DELETE พร้อมกับตัวดำเนินการเช่น =, <,>,> =, <=, IN, BETWEEN เป็นต้น

มีกฎสองสามข้อที่ต้องปฏิบัติตามแบบสอบถามย่อย -

• แบบสอบถามย่อยต้องอยู่ในวงเล็บ

• แบบสอบถามย่อยสามารถมีได้เพียงคอลัมน์เดียวในส่วนคำสั่ง SELECT เว้นแต่ว่าจะมีหลายคอลัมน์ในแบบสอบถามหลักเพื่อให้แบบสอบถามย่อยเปรียบเทียบคอลัมน์ที่เลือก

• ไม่สามารถใช้ ORDER BY ในแบบสอบถามย่อยแม้ว่าแบบสอบถามหลักจะสามารถใช้ ORDER BY ได้ GROUP BY สามารถใช้เพื่อดำเนินการฟังก์ชันเดียวกับ ORDER BY ในแบบสอบถามย่อย

• แบบสอบถามย่อยที่ส่งคืนมากกว่าหนึ่งแถวสามารถใช้ได้กับตัวดำเนินการหลายค่าเท่านั้นเช่นตัวดำเนินการ IN

• BETWEEN ไม่สามารถใช้กับเคียวรีย่อยได้ อย่างไรก็ตามสามารถใช้ BETWEEN ภายในแบบสอบถามย่อยได้

แบบสอบถามย่อยที่มีคำสั่ง SELECT

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

SELECT column_name [, column_name ]
FROM table1 [, table2 ]
WHERE column_name OPERATOR
   (SELECT column_name [, column_name ]
      FROM table1 [, table2 ]
      [WHERE])

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ตอนนี้ให้เราตรวจสอบแบบสอบถามย่อยต่อไปนี้ด้วยคำสั่ง SELECT

sqlite> SELECT * 
   FROM COMPANY 
   WHERE ID IN (SELECT ID 
      FROM COMPANY 
      WHERE SALARY > 45000) ;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

แบบสอบถามย่อยที่มีคำสั่ง INSERT

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

ต่อไปนี้เป็นไวยากรณ์พื้นฐานมีดังนี้ -

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

ตัวอย่าง

พิจารณาตาราง COMPANY_BKP ที่มีโครงสร้างคล้ายกับตาราง COMPANY และสามารถสร้างได้โดยใช้ CREATE TABLE เดียวกันโดยใช้ COMPANY_BKP เป็นชื่อตาราง ในการคัดลอกตาราง COMPANY ที่สมบูรณ์ไปยัง COMPANY_BKP ไวยากรณ์ต่อไปนี้ -

sqlite> INSERT INTO COMPANY_BKP
   SELECT * FROM COMPANY 
   WHERE ID IN (SELECT ID 
      FROM COMPANY) ;

แบบสอบถามย่อยพร้อมคำชี้แจง UPDATE

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

ต่อไปนี้เป็นไวยากรณ์พื้นฐานมีดังนี้ -

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
      FROM TABLE_NAME)
   [ WHERE) ]

ตัวอย่าง

สมมติว่าเรามีตาราง COMPANY_BKP ซึ่งเป็นข้อมูลสำรองของตาราง COMPANY

ตัวอย่างต่อไปนี้จะอัปเดต SALARY 0.50 ครั้งในตาราง COMPANY สำหรับลูกค้าทั้งหมดที่ AGE มากกว่าหรือเท่ากับ 27

sqlite> UPDATE COMPANY
   SET SALARY = SALARY * 0.50
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
      WHERE AGE >= 27 );

สิ่งนี้จะส่งผลกระทบต่อสองแถวและสุดท้ายตาราง COMPANY จะมีบันทึกต่อไปนี้ -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  10000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       42500.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

แบบสอบถามย่อยที่มีคำสั่ง DELETE

แบบสอบถามย่อยสามารถใช้ร่วมกับคำสั่ง DELETE ได้เช่นเดียวกับข้อความอื่น ๆ ที่กล่าวถึงข้างต้น

ต่อไปนี้เป็นไวยากรณ์พื้นฐานมีดังนี้ -

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
      FROM TABLE_NAME)
   [ WHERE) ]

ตัวอย่าง

สมมติว่าเรามีตาราง COMPANY_BKP ซึ่งเป็นข้อมูลสำรองของตาราง COMPANY

ตัวอย่างต่อไปนี้จะลบระเบียนจากตาราง COMPANY สำหรับลูกค้าทั้งหมดที่มี AGE มากกว่าหรือเท่ากับ 27

sqlite> DELETE FROM COMPANY
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
   WHERE AGE > 27 );

สิ่งนี้จะส่งผลต่อสองแถวและสุดท้ายตาราง COMPANY จะมีบันทึกต่อไปนี้ -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       42500.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

SQLite AUTOINCREMENTเป็นคำหลักที่ใช้สำหรับการเพิ่มค่าของฟิลด์ในตารางโดยอัตโนมัติ เราสามารถเพิ่มค่าฟิลด์อัตโนมัติโดยใช้AUTOINCREMENT คำสำคัญเมื่อสร้างตารางที่มีชื่อคอลัมน์เฉพาะสำหรับการเพิ่มอัตโนมัติ

คำหลัก AUTOINCREMENT สามารถใช้ได้กับฟิลด์ INTEGER เท่านั้น

ไวยากรณ์

การใช้งานพื้นฐานของ AUTOINCREMENT คีย์เวิร์ดมีดังนี้ -

CREATE TABLE table_name(
   column1 INTEGER AUTOINCREMENT,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

ตัวอย่าง

พิจารณาตาราง COMPANY ที่จะสร้างดังนี้ -

sqlite> CREATE TABLE COMPANY(
   ID INTEGER PRIMARY KEY AUTOINCREMENT,
   NAME           TEXT      NOT NULL,
   AGE            INT       NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

ตอนนี้แทรกบันทึกต่อไปนี้ลงในตาราง COMPANY -

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Allen', 25, 'Texas', 15000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Teddy', 23, 'Norway', 20000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Mark', 25, 'Rich-Mond ', 65000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'David', 27, 'Texas', 85000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Kim', 22, 'South-Hall', 45000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'James', 24, 'Houston', 10000.00 );

สิ่งนี้จะแทรก 7 tuples ลงในตาราง COMPANY และ COMPANY จะมีบันทึกต่อไปนี้ -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

หากคุณรับข้อมูลผู้ใช้ผ่านหน้าเว็บและแทรกลงในฐานข้อมูล SQLite มีโอกาสที่คุณจะเปิดกว้างสำหรับปัญหาด้านความปลอดภัยที่เรียกว่า SQL Injection ในบทนี้คุณจะได้เรียนรู้วิธีช่วยป้องกันไม่ให้สิ่งนี้เกิดขึ้นและช่วยคุณรักษาความปลอดภัยสคริปต์และคำสั่ง SQLite ของคุณ

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

อย่าเชื่อถือข้อมูลที่ผู้ใช้ให้มาประมวลผลข้อมูลนี้หลังจากการตรวจสอบแล้วเท่านั้น ตามกฎแล้วสิ่งนี้ทำได้โดยการจับคู่รูปแบบ ในตัวอย่างต่อไปนี้ชื่อผู้ใช้ถูก จำกัด ไว้ที่ตัวอักษรและตัวเลขคละกันบวกขีดล่างและมีความยาวระหว่าง 8 ถึง 20 ตัวอักษร - แก้ไขกฎเหล่านี้ได้ตามต้องการ

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)){ $db = new SQLiteDatabase('filename');
   $result = @$db->query("SELECT * FROM users WHERE username = $matches[0]");
} else {
   echo "username not accepted";
}

เพื่อแสดงให้เห็นถึงปัญหาให้พิจารณาข้อความที่ตัดตอนมานี้ -

$name = "Qadir'; DELETE FROM users;";
@$db->query("SELECT * FROM users WHERE username = '{$name}'");

การเรียกใช้ฟังก์ชันควรจะดึงข้อมูลจากตารางผู้ใช้โดยที่คอลัมน์ชื่อตรงกับชื่อที่ผู้ใช้ระบุ ภายใต้สถานการณ์ปกติ$nameจะมีเพียงอักขระที่เป็นตัวเลขและตัวอักษรและอาจเว้นวรรคเช่นสตริง ilia อย่างไรก็ตามในกรณีนี้การต่อท้ายคำค้นหาใหม่ทั้งหมดกับ $ name การเรียกไปยังฐานข้อมูลจะกลายเป็นหายนะ: แบบสอบถาม DELETE ที่ถูกแทรกจะลบบันทึกทั้งหมดจากผู้ใช้

มีอินเทอร์เฟซฐานข้อมูลที่ไม่อนุญาตให้มีการซ้อนคิวรีหรือเรียกใช้การสืบค้นหลายรายการในการเรียกฟังก์ชันเดียว หากคุณพยายามซ้อนคิวรีการเรียกจะล้มเหลว แต่ SQLite และ PostgreSQL ดำเนินการแบบสอบถามแบบเรียงซ้อนกันอย่างมีความสุขดำเนินการค้นหาทั้งหมดที่มีให้ในสตริงเดียวและสร้างปัญหาด้านความปลอดภัยที่ร้ายแรง

การป้องกัน SQL Injection

คุณสามารถจัดการอักขระ Escape ทั้งหมดได้อย่างชาญฉลาดในภาษาสคริปต์เช่น PERL และ PHP ภาษาการเขียนโปรแกรม PHP ให้ฟังก์ชันstring sqlite_escape_string() เพื่อหลีกเลี่ยงอักขระอินพุตที่พิเศษสำหรับ SQLite

if (get_magic_quotes_gpc()) {
   $name = sqlite_escape_string($name);
}
$result = @$db->query("SELECT * FROM users WHERE username = '{$name}'");

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

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

คำสั่ง SQLite สามารถนำหน้าด้วยคีย์เวิร์ด "EXPLAIN" หรือวลี "EXPLAIN QUERY PLAN" ที่ใช้สำหรับอธิบายรายละเอียดของตาราง

การแก้ไขอย่างใดอย่างหนึ่งทำให้คำสั่ง SQLite ทำงานเป็นแบบสอบถามและส่งคืนข้อมูลเกี่ยวกับวิธีการทำงานของคำสั่ง SQLite หากคำหลักหรือวลี EXPLAIN ถูกละไว้

• ผลลัพธ์จาก EXPLAIN และ EXPLAIN QUERY PLAN มีไว้สำหรับการวิเคราะห์เชิงโต้ตอบและการแก้ไขปัญหาเท่านั้น

• รายละเอียดของรูปแบบผลลัพธ์อาจเปลี่ยนแปลงได้จาก SQLite รุ่นหนึ่งไปเป็นรุ่นถัดไป

• แอปพลิเคชันไม่ควรใช้ EXPLAIN หรือ EXPLAIN QUERY PLAN เนื่องจากพฤติกรรมที่แน่นอนมีความแปรปรวนและมีการจัดทำเป็นเอกสารเพียงบางส่วน

ไวยากรณ์

ไวยากรณ์สำหรับ EXPLAIN มีดังนี้ -

EXPLAIN [SQLite Query]

ไวยากรณ์สำหรับ EXPLAIN QUERY PLAN มีดังนี้ -

EXPLAIN  QUERY PLAN [SQLite Query]

ตัวอย่าง

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

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ตอนนี้ให้เราตรวจสอบแบบสอบถามย่อยต่อไปนี้ด้วยคำสั่ง SELECT -

sqlite> EXPLAIN SELECT * FROM COMPANY WHERE Salary >= 20000;

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

addr        opcode      p1          p2          p3
----------  ----------  ----------  ----------  ----------
0           Goto        0           19
1           Integer     0           0
2           OpenRead    0           8
3           SetNumColu  0           5
4           Rewind      0           17
5           Column      0           4
6           RealAffini  0           0
7           Integer     20000       0
8           Lt          357         16          collseq(BI
9           Rowid       0           0
10          Column      0           1
11          Column      0           2
12          Column      0           3
13          Column      0           4
14          RealAffini  0           0
15          Callback    5           0
16          Next        0           5
17          Close       0           0
18          Halt        0           0
19          Transactio  0           0
20          VerifyCook  0           38
21          Goto        0           1
22          Noop        0           0

ตอนนี้ให้เราตรวจสอบสิ่งต่อไปนี้ Explain Query Plan ด้วยคำสั่ง SELECT -

SQLite> EXPLAIN QUERY PLAN SELECT * FROM COMPANY WHERE Salary >= 20000;

order       from        detail
----------  ----------  -------------
0           0           TABLE COMPANY

คำสั่ง VACUUM ล้างฐานข้อมูลหลักโดยการคัดลอกเนื้อหาไปยังไฟล์ฐานข้อมูลชั่วคราวและโหลดไฟล์ฐานข้อมูลต้นฉบับจากสำเนา วิธีนี้จะกำจัดเพจว่างจัดแนวข้อมูลตารางให้ติดกันและล้างโครงสร้างไฟล์ฐานข้อมูล

คำสั่ง VACUUM อาจเปลี่ยน ROWID ของรายการในตารางที่ไม่มีคีย์หลัก INTEGER อย่างชัดเจน คำสั่ง VACUUM ใช้ได้กับฐานข้อมูลหลักเท่านั้น เป็นไปไม่ได้ที่จะ VACUUM ไฟล์ฐานข้อมูลที่แนบมา

คำสั่ง VACUUM จะล้มเหลวหากมีธุรกรรมที่ใช้งานอยู่ คำสั่ง VACUUM คือ no-op สำหรับฐานข้อมูลในหน่วยความจำ เนื่องจากคำสั่ง VACUUM สร้างไฟล์ฐานข้อมูลใหม่ตั้งแต่เริ่มต้น VACUUM ยังสามารถใช้เพื่อแก้ไขพารามิเตอร์คอนฟิกูเรชันเฉพาะฐานข้อมูลจำนวนมาก

คู่มือสุญญากาศ

ต่อไปนี้เป็นไวยากรณ์ง่ายๆในการออกคำสั่ง VACUUM สำหรับฐานข้อมูลทั้งหมดจากพรอมต์คำสั่ง -

$sqlite3 database_name "VACUUM;"

คุณสามารถเรียกใช้ VACUUM จาก SQLite prompt ได้ดังต่อไปนี้ -

sqlite> VACUUM;

คุณยังสามารถเรียกใช้ VACUUM บนตารางเฉพาะได้ดังนี้ -

sqlite> VACUUM table_name;

สูญญากาศอัตโนมัติ

SQLite Auto-VACUUM ไม่ทำเช่นเดียวกับ VACUUM แต่เพียงแค่ย้ายเพจว่างไปยังส่วนท้ายของฐานข้อมูลซึ่งจะช่วยลดขนาดฐานข้อมูล การทำเช่นนี้สามารถแยกส่วนฐานข้อมูลได้อย่างมีนัยสำคัญในขณะที่ VACUUM ช่วยให้มั่นใจได้ว่าการจัดเรียงข้อมูล ดังนั้น Auto-VACUUM จึงทำให้ฐานข้อมูลมีขนาดเล็ก

คุณสามารถเปิด / ปิดการใช้งานการดูดฝุ่นอัตโนมัติของ SQLite โดย pragmas ต่อไปนี้ที่รันที่พรอมต์ SQLite

sqlite> PRAGMA auto_vacuum = NONE; -- 0 means disable auto vacuum
sqlite> PRAGMA auto_vacuum = FULL; -- 1 means enable full auto vacuum
sqlite> PRAGMA auto_vacuum = INCREMENTAL; -- 2 means enable incremental vacuum

คุณสามารถรันคำสั่งต่อไปนี้จากพรอมต์คำสั่งเพื่อตรวจสอบการตั้งค่าสูญญากาศอัตโนมัติ -

$sqlite3 database_name "PRAGMA auto_vacuum;"

SQLite รองรับฟังก์ชันวันที่และเวลาห้าฟังก์ชันดังต่อไปนี้ -

ซีเนียร์	ฟังก์ชัน	ตัวอย่าง
1	วันที่ (timestring, modifiers ... )	ส่งคืนวันที่ในรูปแบบนี้: YYYY-MM-DD
2	เวลา (การกำหนดเวลาตัวปรับแต่ง ... )	ส่งคืนเวลาเป็น HH: MM: SS
3	วันที่และเวลา (timestring, modifiers ... )	สิ่งนี้จะคืนค่า YYYY-MM-DD HH: MM: SS
4	julianday (การจับเวลาตัวปรับแต่ง ... )	สิ่งนี้ส่งคืนจำนวนวันนับตั้งแต่เที่ยงในกรีนิชของวันที่ 24 พฤศจิกายน 4714 ปีก่อนคริสตกาล
5	strftime (การกำหนดเวลาการปรับเปลี่ยน ... )	สิ่งนี้ส่งคืนวันที่ที่จัดรูปแบบตามสตริงรูปแบบที่ระบุเป็นอาร์กิวเมนต์แรกที่จัดรูปแบบตามรูปแบบที่อธิบายด้านล่าง

ฟังก์ชันวันที่และเวลาทั้งห้าข้างต้นใช้สตริงเวลาเป็นอาร์กิวเมนต์ สตริงเวลาตามด้วยตัวปรับค่าศูนย์หรือมากกว่า ฟังก์ชัน strftime () ยังรับสตริงรูปแบบเป็นอาร์กิวเมนต์แรก ส่วนต่อไปนี้จะให้รายละเอียดเกี่ยวกับสตริงเวลาและตัวปรับเปลี่ยนประเภทต่างๆ

สตริงเวลา

สตริงเวลาสามารถอยู่ในรูปแบบใดก็ได้ดังต่อไปนี้ -

ซีเนียร์	สตริงเวลา	ตัวอย่าง
1	ปปปป - ดด - วว	2010-12-30
2	YYYY-MM-DD HH: MM	2553-12-30 12:10 น
3	YYYY-MM-DD HH: MM: SS.SSS	2553-12-30 12: 10: 04.100 น
4	ดด - ว - ปปปป HH: มม	30-12-2010 12:10 น
5	HH: มม	12:10
6	ปปปป - ดด - ววTHH: มม	2553-12-30 12:10 น
7	HH: MM: SS	12:10:01 น
8	YYYYMMDD HHMMSS	20101230 121001
9	ตอนนี้	2013-05-07

คุณสามารถใช้ "T" เป็นอักขระตามตัวอักษรคั่นวันที่และเวลา

ตัวปรับเปลี่ยน

สตริงเวลาสามารถตามด้วยตัวปรับค่าศูนย์หรือมากกว่าซึ่งจะเปลี่ยนวันที่และ / หรือเวลาที่ส่งกลับโดยฟังก์ชันใด ๆ จากห้าฟังก์ชันข้างต้น การปรับเปลี่ยนใช้จากซ้ายไปขวา

ตัวดัดแปลงต่อไปนี้มีอยู่ใน SQLite -

• NNN วัน
• NNN ชั่วโมง
• NNN นาที
• NNN.NNNN วินาที
• NNN เดือน
• NNN ปี
• ต้นเดือน
• ต้นปี
• เริ่มต้นวันใหม่
• วันธรรมดา N
• unixepoch
• localtime
• utc

ฟอร์แมต

SQLite มีฟังก์ชันที่มีประโยชน์มาก strftime()เพื่อจัดรูปแบบวันที่และเวลาใด ๆ คุณสามารถใช้การแทนที่ต่อไปนี้เพื่อจัดรูปแบบวันที่และเวลาของคุณ

การแทน	คำอธิบาย
% d	วันของเดือน 01-31
% ฉ	วินาทีเศษส่วน SS.SSS
% ซ	ชั่วโมง 00-23
% ญ	วันเดือนปี 001-366
ญ	หมายเลขวันจูเลียน DDDD.DDDD
% ม	เดือน, 00-12
% ม	นาที 00-59
% s	วินาทีตั้งแต่ 1970-01-01
% S	วินาที 00-59
% w	วันในสัปดาห์ 0-6 (0 คือวันอาทิตย์)
% W	สัปดาห์ของปี 01-53
% Y	ปีปปปปป
%%	% สัญลักษณ์

ตัวอย่าง

ลองดูตัวอย่างต่างๆตอนนี้โดยใช้พรอมต์ SQLite คำสั่งต่อไปนี้คำนวณวันที่ปัจจุบัน

sqlite> SELECT date('now');
2013-05-07

คำสั่งต่อไปนี้คำนวณวันสุดท้ายของเดือนปัจจุบัน

sqlite> SELECT date('now','start of month','+1 month','-1 day');
2013-05-31

คำสั่งต่อไปนี้คำนวณวันที่และเวลาสำหรับการประทับเวลา UNIX ที่กำหนด 1092941466

sqlite> SELECT datetime(1092941466, 'unixepoch');
2004-08-19 18:51:06

คำสั่งต่อไปนี้คำนวณวันที่และเวลาสำหรับการประทับเวลา UNIX 1092941466 ที่กำหนดและชดเชยเขตเวลาท้องถิ่นของคุณ

sqlite> SELECT datetime(1092941466, 'unixepoch', 'localtime');
2004-08-19 13:51:06

คำสั่งต่อไปนี้จะคำนวณการประทับเวลา UNIX ปัจจุบัน

sqlite> SELECT strftime('%s','now');
1393348134

คำสั่งต่อไปนี้คำนวณจำนวนวันนับตั้งแต่การลงนามในคำประกาศอิสรภาพของสหรัฐอเมริกา

sqlite> SELECT julianday('now') - julianday('1776-07-04');
86798.7094695023

คำสั่งต่อไปนี้คำนวณจำนวนวินาทีนับตั้งแต่ช่วงเวลาหนึ่งในปี 2004

sqlite> SELECT strftime('%s','now') - strftime('%s','2004-01-01 02:34:56');
295001572

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

sqlite> SELECT date('now','start of year','+9 months','weekday 2');
2013-10-01

คำสั่งต่อไปนี้คำนวณเวลาตั้งแต่ยุค UNIX เป็นวินาที (เช่น strftime ('% s', 'now') ยกเว้นรวมส่วนที่เป็นเศษส่วน)

sqlite> SELECT (julianday('now') - 2440587.5)*86400.0;
1367926077.12598

ในการแปลงระหว่างค่า UTC และเวลาท้องถิ่นเมื่อจัดรูปแบบวันที่ให้ใช้ตัวแก้ไข utc หรือ localtime ดังต่อไปนี้ -

sqlite> SELECT time('12:00', 'localtime');
05:00:00

sqlite> SELECT time('12:00', 'utc');
19:00:00

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

ซีเนียร์	ฟังก์ชั่นและคำอธิบาย
1	SQLite COUNT Function ฟังก์ชันการรวม SQLite COUNT ใช้เพื่อนับจำนวนแถวในตารางฐานข้อมูล
2	SQLite MAX Function ฟังก์ชันการรวม SQLite MAX ช่วยให้เราสามารถเลือกค่าสูงสุด (สูงสุด) สำหรับคอลัมน์หนึ่ง ๆ
3	SQLite MIN Function ฟังก์ชันการรวม SQLite MIN ช่วยให้เราสามารถเลือกค่าต่ำสุด (ต่ำสุด) สำหรับคอลัมน์หนึ่ง ๆ
4	SQLite AVG Function ฟังก์ชันการรวม SQLite AVG จะเลือกค่าเฉลี่ยสำหรับคอลัมน์ตารางบางคอลัมน์
5	SQLite SUM Function ฟังก์ชันการรวม SQLite SUM อนุญาตให้เลือกผลรวมสำหรับคอลัมน์ตัวเลข
6	SQLite RANDOM Function ฟังก์ชัน SQLite RANDOM ส่งคืนจำนวนเต็มสุ่มหลอกระหว่าง -9223372036854775808 และ +9223372036854775807
7	SQLite ABS Function ฟังก์ชัน SQLite ABS ส่งคืนค่าสัมบูรณ์ของอาร์กิวเมนต์ตัวเลข
8	SQLite UPPER Function ฟังก์ชัน SQLite UPPER แปลงสตริงเป็นตัวอักษรตัวพิมพ์ใหญ่
9	SQLite LOWER Function ฟังก์ชัน SQLite LOWER แปลงสตริงเป็นอักษรตัวพิมพ์เล็ก
10	SQLite LENGTH Function ฟังก์ชัน SQLite LENGTH ส่งกลับความยาวของสตริง
11	SQLite sqlite_version Function ฟังก์ชัน SQLite sqlite_version ส่งคืนเวอร์ชันของไลบรารี SQLite

ก่อนที่เราจะเริ่มยกตัวอย่างฟังก์ชันที่กล่าวถึงข้างต้นให้พิจารณาตาราง COMPANY ที่มีบันทึกต่อไปนี้

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

ฟังก์ชัน SQLite COUNT

ฟังก์ชันการรวม SQLite COUNT ใช้เพื่อนับจำนวนแถวในตารางฐานข้อมูล ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT count(*) FROM COMPANY;

คำสั่ง SQLite SQL ด้านบนจะสร้างสิ่งต่อไปนี้

count(*)
----------
7

ฟังก์ชัน SQLite MAX

ฟังก์ชันการรวม SQLite MAX ช่วยให้เราสามารถเลือกค่าสูงสุด (สูงสุด) สำหรับคอลัมน์หนึ่ง ๆ ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT max(salary) FROM COMPANY;

คำสั่ง SQLite SQL ด้านบนจะสร้างสิ่งต่อไปนี้

max(salary)
-----------
85000.0

ฟังก์ชัน SQLite MIN

ฟังก์ชันการรวม SQLite MIN ช่วยให้เราสามารถเลือกค่าต่ำสุด (ต่ำสุด) สำหรับคอลัมน์หนึ่ง ๆ ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT min(salary) FROM COMPANY;

คำสั่ง SQLite SQL ด้านบนจะสร้างสิ่งต่อไปนี้

min(salary)
-----------
10000.0

ฟังก์ชัน SQLite AVG

ฟังก์ชันการรวม SQLite AVG จะเลือกค่าเฉลี่ยสำหรับคอลัมน์ตารางบางคอลัมน์ ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT avg(salary) FROM COMPANY;

คำสั่ง SQLite SQL ด้านบนจะสร้างสิ่งต่อไปนี้

avg(salary)
----------------
37142.8571428572

ฟังก์ชัน SQLite SUM

ฟังก์ชันการรวม SQLite SUM อนุญาตให้เลือกผลรวมสำหรับคอลัมน์ตัวเลข ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT sum(salary) FROM COMPANY;

คำสั่ง SQLite SQL ด้านบนจะสร้างสิ่งต่อไปนี้

sum(salary)
-----------
260000.0

ฟังก์ชัน SQLite RANDOM

ฟังก์ชัน SQLite RANDOM ส่งคืนจำนวนเต็มสุ่มหลอกระหว่าง -9223372036854775808 และ +9223372036854775807 ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT random() AS Random;

คำสั่ง SQLite SQL ด้านบนจะสร้างสิ่งต่อไปนี้

Random
-------------------
5876796417670984050

ฟังก์ชัน SQLite ABS

ฟังก์ชัน SQLite ABS ส่งคืนค่าสัมบูรณ์ของอาร์กิวเมนต์ตัวเลข ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT abs(5), abs(-15), abs(NULL), abs(0), abs("ABC");

คำสั่ง SQLite SQL ด้านบนจะสร้างสิ่งต่อไปนี้

abs(5)      abs(-15)    abs(NULL)   abs(0)      abs("ABC")
----------  ----------  ----------  ----------  ----------
5           15                      0           0.0

ฟังก์ชัน SQLite UPPER

ฟังก์ชัน SQLite UPPER แปลงสตริงเป็นตัวอักษรตัวพิมพ์ใหญ่ ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT upper(name) FROM COMPANY;

คำสั่ง SQLite SQL ด้านบนจะสร้างสิ่งต่อไปนี้

upper(name)
-----------
PAUL
ALLEN
TEDDY
MARK
DAVID
KIM
JAMES

ฟังก์ชัน SQLite LOWER

ฟังก์ชัน SQLite LOWER แปลงสตริงเป็นอักษรตัวพิมพ์เล็ก ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT lower(name) FROM COMPANY;

คำสั่ง SQLite SQL ด้านบนจะสร้างสิ่งต่อไปนี้

lower(name)
-----------
paul
allen
teddy
mark
david
kim
james

ฟังก์ชัน SQLite LENGTH

ฟังก์ชัน SQLite LENGTH ส่งกลับความยาวของสตริง ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT name, length(name) FROM COMPANY;

คำสั่ง SQLite SQL ด้านบนจะสร้างสิ่งต่อไปนี้

NAME        length(name)
----------  ------------
Paul        4
Allen       5
Teddy       5
Mark        4
David       5
Kim         3
James       5

ฟังก์ชัน SQLite sqlite_version

ฟังก์ชัน SQLite sqlite_version ส่งคืนเวอร์ชันของไลบรารี SQLite ต่อไปนี้เป็นตัวอย่าง -

sqlite> SELECT sqlite_version() AS 'SQLite Version';

คำสั่ง SQLite SQL ด้านบนจะสร้างสิ่งต่อไปนี้

SQLite Version
--------------
3.6.20

ในบทนี้คุณจะได้เรียนรู้การใช้ SQLite ในโปรแกรม C / C ++

การติดตั้ง

ก่อนที่คุณจะเริ่มใช้ SQLite ในโปรแกรม C / C ++ คุณต้องแน่ใจว่าคุณได้ตั้งค่าไลบรารี SQLite ไว้ในเครื่องแล้ว คุณสามารถตรวจสอบบทการติดตั้ง SQLite เพื่อทำความเข้าใจกระบวนการติดตั้ง

API ของอินเตอร์เฟส C / C ++

ต่อไปนี้เป็นรูทีนอินเทอร์เฟซ C / C ++ SQLite ที่สำคัญซึ่งสามารถเพียงพอต่อความต้องการของคุณในการทำงานกับฐานข้อมูล SQLite จากโปรแกรม C / C ++ ของคุณ หากคุณกำลังมองหาแอปพลิเคชันที่ซับซ้อนมากขึ้นคุณสามารถดูเอกสารอย่างเป็นทางการของ SQLite

ซีเนียร์	API และคำอธิบาย
1	sqlite3_open(const char *filename, sqlite3 **ppDb) รูทีนนี้จะเปิดการเชื่อมต่อกับไฟล์ฐานข้อมูล SQLite และส่งคืนอ็อบเจ็กต์การเชื่อมต่อฐานข้อมูลที่จะใช้โดยรูทีน SQLite อื่น หากอาร์กิวเมนต์ชื่อไฟล์เป็น NULL หรือ ': memory:', sqlite3_open () จะสร้างฐานข้อมูลในหน่วยความจำใน RAM ซึ่งคงอยู่ในช่วงระยะเวลาของเซสชันเท่านั้น ถ้าชื่อไฟล์ไม่ใช่ NULL sqlite3_open () จะพยายามเปิดไฟล์ฐานข้อมูลโดยใช้ค่า หากไม่มีไฟล์ตามชื่อนั้น sqlite3_open () จะเปิดไฟล์ฐานข้อมูลใหม่ตามชื่อนั้น
2	sqlite3_exec(sqlite3*, const char *sql, sqlite_callback, void *data, char **errmsg) รูทีนนี้เป็นวิธีที่ง่ายและรวดเร็วในการดำเนินการคำสั่ง SQL ที่จัดเตรียมโดยอาร์กิวเมนต์ sql ซึ่งสามารถประกอบด้วยคำสั่ง SQL มากกว่าหนึ่งคำสั่ง ที่นี่อาร์กิวเมนต์แรกsqlite3คืออ็อบเจ็กต์ฐานข้อมูลแบบเปิดsqlite_callbackคือการเรียกกลับซึ่งข้อมูลเป็นอาร์กิวเมนต์แรกและ errmsg จะถูกส่งกลับเพื่อจับข้อผิดพลาดที่เกิดขึ้นจากรูทีน SQLite3_exec () รูทีนจะแยกวิเคราะห์และดำเนินการทุกคำสั่งที่กำหนดในไฟล์ sql อาร์กิวเมนต์จนกว่าจะถึงจุดสิ้นสุดของสตริงหรือพบข้อผิดพลาด
3	sqlite3_close(sqlite3*) รูทีนนี้ปิดการเชื่อมต่อฐานข้อมูลที่เปิดไว้ก่อนหน้านี้โดยการเรียกไปที่ sqlite3_open () ข้อความที่เตรียมไว้ทั้งหมดที่เกี่ยวข้องกับการเชื่อมต่อควรได้รับการสรุปก่อนที่จะปิดการเชื่อมต่อ หากยังคงมีการสืบค้นที่ยังไม่ได้สรุป sqlite3_close () จะส่งคืน SQLITE_BUSY พร้อมข้อความแสดงข้อผิดพลาดไม่สามารถปิดได้เนื่องจากคำสั่งที่ไม่ได้สรุป

เชื่อมต่อกับฐานข้อมูล

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

#include <stdio.h>
#include <sqlite3.h> 

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;

   rc = sqlite3_open("test.db", &db);

   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }
   sqlite3_close(db);
}

ตอนนี้เรามารวบรวมและเรียกใช้โปรแกรมด้านบนเพื่อสร้างฐานข้อมูลของเรา test.dbในไดเร็กทอรีปัจจุบัน คุณสามารถเปลี่ยนเส้นทางของคุณได้ตามความต้องการของคุณ

$gcc test.c -l sqlite3
$./a.out
Opened database successfully

หากคุณจะใช้ซอร์สโค้ด C ++ คุณสามารถคอมไพล์โค้ดของคุณได้ดังนี้ -

$g++ test.c -l sqlite3

ที่นี่เรากำลังเชื่อมโยงโปรแกรมของเรากับไลบรารี sqlite3 เพื่อจัดเตรียมฟังก์ชันที่จำเป็นให้กับโปรแกรม C สิ่งนี้จะสร้างไฟล์ฐานข้อมูล test.db ในไดเร็กทอรีของคุณและคุณจะได้ผลลัพธ์ดังต่อไปนี้

-rwxr-xr-x. 1 root root 7383 May 8 02:06 a.out
-rw-r--r--. 1 root root  323 May 8 02:05 test.c
-rw-r--r--. 1 root root    0 May 8 02:06 test.db

สร้างตาราง

กลุ่มรหัส C ต่อไปนี้จะถูกใช้เพื่อสร้างตารางในฐานข้อมูลที่สร้างไว้ก่อนหน้านี้ -

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
   int i;
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stdout, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "CREATE TABLE COMPANY("  \
      "ID INT PRIMARY KEY     NOT NULL," \
      "NAME           TEXT    NOT NULL," \
      "AGE            INT     NOT NULL," \
      "ADDRESS        CHAR(50)," \
      "SALARY         REAL );";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   
   if( rc != SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Table created successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

เมื่อโปรแกรมด้านบนได้รับการคอมไพล์และเรียกใช้งานโปรแกรมจะสร้างตาราง COMPANY ใน test.db ของคุณและรายชื่อสุดท้ายของไฟล์จะเป็นดังนี้ -

-rwxr-xr-x. 1 root root 9567 May 8 02:31 a.out
-rw-r--r--. 1 root root 1207 May 8 02:31 test.c
-rw-r--r--. 1 root root 3072 May 8 02:31 test.db

การทำงานของ INSERT

กลุ่มรหัส C ต่อไปนี้แสดงให้เห็นว่าคุณสามารถสร้างระเบียนในตาราง COMPANY ที่สร้างขึ้นในตัวอย่างข้างต้นได้อย่างไร -

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
   int i;
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (1, 'Paul', 32, 'California', 20000.00 ); " \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); "     \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );" \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   
   if( rc != SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Records created successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

เมื่อโปรแกรมด้านบนถูกคอมไพล์และดำเนินการโปรแกรมจะสร้างเรกคอร์ดที่กำหนดในตาราง COMPANY และจะแสดงสองบรรทัดต่อไปนี้ -

Opened database successfully
Records created successfully

เลือกการทำงาน

ก่อนที่จะดำเนินการตามตัวอย่างจริงในการดึงข้อมูลให้เราดูรายละเอียดบางอย่างเกี่ยวกับฟังก์ชันการโทรกลับซึ่งเราใช้ในตัวอย่างของเรา การเรียกกลับนี้เป็นวิธีการรับผลลัพธ์จากคำสั่ง SELECT มีประกาศดังต่อไปนี้ -

typedef int (*sqlite3_callback)(
   void*,    /* Data provided in the 4th argument of sqlite3_exec() */
   int,      /* The number of columns in row */
   char**,   /* An array of strings representing fields in the row */
   char**    /* An array of strings representing column names */
);

หากการเรียกกลับข้างต้นถูกจัดเตรียมไว้ในรูทีน sqlite_exec () เป็นอาร์กิวเมนต์ที่สาม SQLite จะเรียกฟังก์ชันการเรียกกลับนี้สำหรับแต่ละเร็กคอร์ดที่ประมวลผลในแต่ละคำสั่ง SELECT ที่ดำเนินการภายในอาร์กิวเมนต์ SQL

ต่อไปนี้ส่วนรหัส C แสดงวิธีการดึงข้อมูลและแสดงบันทึกจากตาราง COMPANY ที่สร้างขึ้นในตัวอย่างข้างต้น -

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName){
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++){
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

เมื่อโปรแกรมด้านบนถูกคอมไพล์และเรียกใช้งานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

อัปเดตการทำงาน

ต่อไปนี้ส่วนรหัส C แสดงให้เห็นว่าเราสามารถใช้คำสั่ง UPDATE เพื่ออัปเดตระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงบันทึกที่อัปเดตจากตาราง COMPANY

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName){
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create merged SQL statement */
   sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1; " \
         "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

เมื่อโปรแกรมด้านบนถูกคอมไพล์และเรียกใช้งานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

ลบการดำเนินการ

ต่อจากกลุ่มรหัส C จะแสดงวิธีที่คุณสามารถใช้คำสั่ง DELETE เพื่อลบระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่เหลือจากตาราง COMPANY

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName) {
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create merged SQL statement */
   sql = "DELETE from COMPANY where ID=2; " \
         "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

เมื่อโปรแกรมด้านบนถูกคอมไพล์และเรียกใช้งานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

ในบทนี้คุณจะได้เรียนรู้วิธีการใช้ SQLite ในโปรแกรม Java

การติดตั้ง

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

• ดาวน์โหลดsqlite-jdbc- (VERSION) .jarเวอร์ชันล่าสุดจากที่เก็บsqlite-jdbc

• เพิ่มไฟล์ jar ที่ดาวน์โหลดมาsqlite-jdbc- (VERSION) .jarในพา ธ คลาสของคุณหรือคุณสามารถใช้มันร่วมกับอ็อพชัน -classpath ตามที่อธิบายในตัวอย่างต่อไปนี้

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

เชื่อมต่อกับฐานข้อมูล

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

import java.sql.*;

public class SQLiteJDBC {
  public static void main( String args[] ) {
      Connection c = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Opened database successfully");
   }
}

ตอนนี้เรามารวบรวมและเรียกใช้โปรแกรมด้านบนเพื่อสร้างฐานข้อมูลของเรา test.dbในไดเร็กทอรีปัจจุบัน คุณสามารถเปลี่ยนเส้นทางของคุณได้ตามความต้องการของคุณ เราถือว่าเวอร์ชันปัจจุบันของไดรเวอร์ JDBC sqlite-jdbc-3.7.2.jarมีอยู่ในพา ธ ปัจจุบัน

$javac SQLiteJDBC.java $java -classpath ".:sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Open database successfully

หากคุณจะใช้เครื่อง Windows คุณสามารถคอมไพล์และรันโค้ดของคุณได้ดังนี้ -

$javac SQLiteJDBC.java $java -classpath ".;sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Opened database successfully

สร้างตาราง

โปรแกรม Java ต่อไปนี้จะใช้ในการสร้างตารางในฐานข้อมูลที่สร้างไว้ก่อนหน้านี้

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "CREATE TABLE COMPANY " +
                        "(ID INT PRIMARY KEY     NOT NULL," +
                        " NAME           TEXT    NOT NULL, " + 
                        " AGE            INT     NOT NULL, " + 
                        " ADDRESS        CHAR(50), " + 
                        " SALARY         REAL)"; 
         stmt.executeUpdate(sql);
         stmt.close();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Table created successfully");
   }
}

เมื่อโปรแกรมด้านบนได้รับการรวบรวมและดำเนินการโปรแกรมจะสร้างตาราง COMPANY ในไฟล์ test.db และรายการสุดท้ายของไฟล์จะเป็นดังนี้ -

-rw-r--r--. 1 root root 3201128 Jan 22 19:04 sqlite-jdbc-3.7.2.jar
-rw-r--r--. 1 root root    1506 May  8 05:43 SQLiteJDBC.class
-rw-r--r--. 1 root root     832 May  8 05:42 SQLiteJDBC.java
-rw-r--r--. 1 root root    3072 May  8 05:43 test.db

การทำงานของ INSERT

โปรแกรม Java ต่อไปนี้แสดงวิธีสร้างเรกคอร์ดในตาราง COMPANY ที่สร้างในตัวอย่างข้างต้น

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                        "VALUES (1, 'Paul', 32, 'California', 20000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (2, 'Allen', 25, 'Texas', 15000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );"; 
         stmt.executeUpdate(sql);

         stmt.close();
         c.commit();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Records created successfully");
   }
}

เมื่อโปรแกรมด้านบนถูกรวบรวมและดำเนินการโปรแกรมจะสร้างระเบียนที่กำหนดในตาราง COMPANY และจะแสดงสองบรรทัดถัดไป -

Opened database successfully
Records created successfully

เลือกการทำงาน

โปรแกรม Java ต่อไปนี้แสดงวิธีการดึงข้อมูลและแสดงบันทึกจากตาราง COMPANY ที่สร้างขึ้นในตัวอย่างข้างต้น

import java.sql.*;

public class SQLiteJDBC {

  public static void main( String args[] ) {

   Connection c = null;
   Statement stmt = null;
   try {
      Class.forName("org.sqlite.JDBC");
      c = DriverManager.getConnection("jdbc:sqlite:test.db");
      c.setAutoCommit(false);
      System.out.println("Opened database successfully");

      stmt = c.createStatement();
      ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
      
      while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
   } catch ( Exception e ) {
      System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      System.exit(0);
   }
   System.out.println("Operation done successfully");
  }
}

เมื่อโปรแกรมด้านบนถูกคอมไพล์และเรียกใช้งานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

อัปเดตการทำงาน

โค้ด Java ต่อไปนี้แสดงวิธีใช้คำสั่ง UPDATE เพื่ออัปเดตเรกคอร์ดจากนั้นดึงข้อมูลและแสดงเรกคอร์ดที่อัพเดตจากตาราง COMPANY

import java.sql.*;

public class SQLiteJDBC {

  public static void main( String args[] ) {
  
   Connection c = null;
   Statement stmt = null;
   
   try {
      Class.forName("org.sqlite.JDBC");
      c = DriverManager.getConnection("jdbc:sqlite:test.db");
      c.setAutoCommit(false);
      System.out.println("Opened database successfully");

      stmt = c.createStatement();
      String sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1;";
      stmt.executeUpdate(sql);
      c.commit();

      ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
      
      while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
   } catch ( Exception e ) {
      System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      System.exit(0);
   }
    System.out.println("Operation done successfully");
   }
}

เมื่อโปรแกรมด้านบนถูกคอมไพล์และเรียกใช้งานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

ลบการดำเนินการ

โค้ด Java ต่อไปนี้แสดงวิธีการใช้คำสั่ง DELETE เพื่อลบระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่เหลือจากตาราง COMPANY ของเรา

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "DELETE from COMPANY where ID=2;";
         stmt.executeUpdate(sql);
         c.commit();

         ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
         
         while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Operation done successfully");
   }
}

เมื่อโปรแกรมด้านบนถูกคอมไพล์และเรียกใช้งานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

ในบทนี้คุณจะได้เรียนรู้การใช้ SQLite ในโปรแกรม PHP

การติดตั้ง

ส่วนขยาย SQLite3 ถูกเปิดใช้งานโดยค่าเริ่มต้นที่ PHP 5.3.0 เป็นไปได้ที่จะปิดการใช้งานโดยใช้--without-sqlite3 ในเวลารวบรวม

ผู้ใช้ Windows ต้องเปิดใช้งาน php_sqlite3.dll เพื่อใช้ส่วนขยายนี้ DLL นี้มาพร้อมกับการแจกแจง Windows ของ PHP ตั้งแต่ PHP 5.3.0

สำหรับคำแนะนำในการติดตั้งโดยละเอียดโปรดดูบทช่วยสอน PHP และเว็บไซต์อย่างเป็นทางการ

PHP Interface API

ต่อไปนี้เป็นกิจวัตร PHP ที่สำคัญซึ่งสามารถเพียงพอกับความต้องการของคุณในการทำงานกับฐานข้อมูล SQLite จากโปรแกรม PHP ของคุณ หากคุณกำลังมองหาแอปพลิเคชันที่ซับซ้อนมากขึ้นคุณสามารถดูเอกสารอย่างเป็นทางการของ PHP

ซีเนียร์	API และคำอธิบาย
1	public void SQLite3::open ( filename, flags, encryption_key ) เปิดฐานข้อมูล SQLite 3 หากบิวด์มีการเข้ารหัสก็จะพยายามใช้คีย์ หากกำหนดชื่อไฟล์เป็น':memory:', SQLite3 :: open () จะสร้างฐานข้อมูลในหน่วยความจำใน RAM ที่คงอยู่ในช่วงระยะเวลาของเซสชันเท่านั้น ถ้าชื่อไฟล์เป็นชื่อไฟล์อุปกรณ์จริง SQLite3 :: open () จะพยายามเปิดไฟล์ฐานข้อมูลโดยใช้ค่า หากไม่มีไฟล์ตามชื่อนั้นไฟล์ฐานข้อมูลใหม่โดยใช้ชื่อนั้นจะถูกสร้างขึ้น แฟล็กทางเลือกที่ใช้เพื่อกำหนดวิธีการเปิดฐานข้อมูล SQLite โดยค่าเริ่มต้นเปิดใช้ SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE
2	public bool SQLite3::exec ( string $query ) รูทีนนี้เป็นวิธีที่ง่ายและรวดเร็วในการดำเนินการคำสั่ง SQL ที่จัดเตรียมโดยอาร์กิวเมนต์ sql ซึ่งอาจประกอบด้วยคำสั่ง SQL มากกว่าหนึ่งคำสั่ง รูทีนนี้ใช้เพื่อดำเนินการแบบสอบถามแบบไม่แสดงผลลัพธ์กับฐานข้อมูลที่กำหนด
3	public SQLite3Result SQLite3::query ( string $query ) รูทีนนี้เรียกใช้แบบสอบถาม SQL โดยส่งคืนไฟล์ SQLite3Result วัตถุถ้าแบบสอบถามส่งกลับผลลัพธ์
4	public int SQLite3::lastErrorCode ( void ) รูทีนนี้ส่งคืนรหัสผลลัพธ์ที่เป็นตัวเลขของคำขอ SQLite ที่ล้มเหลวล่าสุด
5	public string SQLite3::lastErrorMsg ( void ) รูทีนนี้ส่งคืนข้อความภาษาอังกฤษที่อธิบายคำขอ SQLite ที่ล้มเหลวล่าสุด
6	public int SQLite3::changes ( void ) รูทีนนี้ส่งคืนจำนวนแถวฐานข้อมูลที่ถูกอัพเดตแทรกหรือลบโดยคำสั่ง SQL ล่าสุด
7	public bool SQLite3::close ( void ) รูทีนนี้จะปิดการเชื่อมต่อฐานข้อมูลที่เปิดไว้ก่อนหน้านี้โดยการเรียก SQLite3 :: open ()
8	public string SQLite3::escapeString ( string $value ) รูทีนนี้ส่งคืนสตริงที่ได้รับการยกเว้นอย่างเหมาะสมสำหรับการรวมอย่างปลอดภัยในคำสั่ง SQL

เชื่อมต่อกับฐานข้อมูล

โค้ด PHP ต่อไปนี้จะแสดงวิธีการเชื่อมต่อกับฐานข้อมูลที่มีอยู่ หากไม่มีฐานข้อมูลจะมีการสร้างฐานข้อมูลและสุดท้ายจะส่งคืนวัตถุฐานข้อมูล

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
?>

ตอนนี้ให้เรียกใช้โปรแกรมด้านบนเพื่อสร้างฐานข้อมูลของเรา test.dbในไดเร็กทอรีปัจจุบัน คุณสามารถเปลี่ยนเส้นทางของคุณได้ตามความต้องการของคุณ หากสร้างฐานข้อมูลสำเร็จจะแสดงข้อความต่อไปนี้ -

Open database successfully

สร้างตาราง

โปรแกรม PHP ต่อไปนี้จะใช้สร้างตารางในฐานข้อมูลที่สร้างไว้ก่อนหน้านี้

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg(); } else { echo "Opened database successfully\n"; } $sql =<<<EOF
      CREATE TABLE COMPANY
      (ID INT PRIMARY KEY     NOT NULL,
      NAME           TEXT    NOT NULL,
      AGE            INT     NOT NULL,
      ADDRESS        CHAR(50),
      SALARY         REAL);
EOF;

   $ret = $db->exec($sql); if(!$ret){
      echo $db->lastErrorMsg(); } else { echo "Table created successfully\n"; } $db->close();
?>

เมื่อโปรแกรมด้านบนทำงานโปรแกรมจะสร้างตาราง COMPANY ในไฟล์ test.db และจะแสดงข้อความต่อไปนี้ -

Opened database successfully
Table created successfully

การทำงานของ INSERT

โปรแกรม PHP ต่อไปนี้จะแสดงวิธีการสร้างระเบียนในตาราง COMPANY ที่สร้างในตัวอย่างข้างต้น

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db){ echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }

   $sql =<<<EOF INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Paul', 32, 'California', 20000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (3, 'Teddy', 23, 'Norway', 20000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 ); EOF; $ret = $db->exec($sql);
   if(!$ret) { echo $db->lastErrorMsg();
   } else {
      echo "Records created successfully\n";
   }
   $db->close();
?>

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

Opened database successfully
Records created successfully

เลือกการทำงาน

โปรแกรม PHP ต่อไปนี้จะแสดงวิธีการดึงข้อมูลและแสดงบันทึกจากตาราง COMPANY ที่สร้างขึ้นในตัวอย่างข้างต้น -

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg(); } else { echo "Opened database successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;

   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

เมื่อโปรแกรมข้างต้นทำงานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

อัปเดตการทำงาน

โค้ด PHP ต่อไปนี้จะแสดงวิธีใช้คำสั่ง UPDATE เพื่ออัปเดตระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่อัปเดตจากตาราง COMPANY

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db) { echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
   $sql =<<<EOF UPDATE COMPANY set SALARY = 25000.00 where ID=1; EOF; $ret = $db->exec($sql);
   if(!$ret) { echo $db->lastErrorMsg();
   } else {
      echo $db->changes(), " Record updated successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;
   
   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

เมื่อโปรแกรมข้างต้นทำงานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
1 Record updated successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

ลบการดำเนินการ

โค้ด PHP ต่อไปนี้แสดงวิธีใช้คำสั่ง DELETE เพื่อลบบันทึกใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่เหลือจากตาราง COMPANY

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db) { echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
   $sql =<<<EOF DELETE from COMPANY where ID = 2; EOF; $ret = $db->exec($sql);
   if(!$ret){ echo $db->lastErrorMsg();
   } else {
      echo $db->changes(), " Record deleted successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;
   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

เมื่อโปรแกรมข้างต้นทำงานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
1 Record deleted successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

ในบทนี้คุณจะได้เรียนรู้วิธีการใช้ SQLite ในโปรแกรม Perl

การติดตั้ง

SQLite3 สามารถรวมเข้ากับ Perl โดยใช้โมดูล Perl DBI ซึ่งเป็นโมดูลการเข้าถึงฐานข้อมูลสำหรับภาษาโปรแกรม Perl กำหนดชุดวิธีการตัวแปรและการประชุมที่จัดเตรียมอินเตอร์เฟสฐานข้อมูลมาตรฐาน

ต่อไปนี้เป็นขั้นตอนง่ายๆในการติดตั้งโมดูล DBI บนเครื่อง Linux / UNIX ของคุณ -

$ wget http://search.cpan.org/CPAN/authors/id/T/TI/TIMB/DBI-1.625.tar.gz $ tar xvfz DBI-1.625.tar.gz
$ cd DBI-1.625 $ perl Makefile.PL
$ make $ make install

หากคุณต้องการติดตั้งไดรเวอร์ SQLite สำหรับ DBI สามารถติดตั้งได้ดังนี้ -

$ wget http://search.cpan.org/CPAN/authors/id/M/MS/MSERGEANT/DBD-SQLite-1.11.tar.gz $ tar xvfz DBD-SQLite-1.11.tar.gz
$ cd DBD-SQLite-1.11 $ perl Makefile.PL
$ make $ make install

DBI Interface API

ต่อไปนี้เป็นกิจวัตร DBI ที่สำคัญซึ่งสามารถเพียงพอต่อความต้องการของคุณในการทำงานกับฐานข้อมูล SQLite จากโปรแกรม Perl ของคุณ หากคุณกำลังมองหาแอปพลิเคชันที่ซับซ้อนมากขึ้นคุณสามารถดูเอกสารอย่างเป็นทางการของ Perl DBI

ซีเนียร์	API และคำอธิบาย
1	DBI->connect($data_source, "", "", \%attr) สร้างการเชื่อมต่อฐานข้อมูลหรือเซสชันกับ $ data_source ที่ร้องขอ ส่งคืนอ็อบเจ็กต์ตัวจัดการฐานข้อมูลหากการเชื่อมต่อสำเร็จ Datasource มีรูปแบบดังนี้ - DBI:SQLite:dbname = 'test.db'โดยที่ SQLite คือชื่อไดรเวอร์ SQLite และ test.db คือชื่อของไฟล์ฐานข้อมูล SQLite หากกำหนดชื่อไฟล์เป็น':memory:'มันจะสร้างฐานข้อมูลในหน่วยความจำใน RAM ซึ่งคงอยู่ในช่วงระยะเวลาของเซสชันเท่านั้น ถ้าชื่อไฟล์เป็นชื่อไฟล์อุปกรณ์จริงก็จะพยายามเปิดไฟล์ฐานข้อมูลโดยใช้ค่าของมัน หากไม่มีไฟล์ตามชื่อนั้นไฟล์ฐานข้อมูลใหม่โดยใช้ชื่อนั้นจะถูกสร้างขึ้น คุณเก็บพารามิเตอร์ที่สองและสามเป็นสตริงว่างและพารามิเตอร์สุดท้ายคือการส่งผ่านแอ็ตทริบิวต์ต่างๆดังที่แสดงในตัวอย่างต่อไปนี้
2	$dbh->do($sql) รูทีนนี้เตรียมและดำเนินการคำสั่ง SQL เดียว ส่งคืนจำนวนแถวที่ได้รับผลกระทบหรือ undef ในข้อผิดพลาด ค่าที่ส่งกลับเป็น -1 หมายถึงไม่ทราบจำนวนแถวไม่เกี่ยวข้องหรือไม่พร้อมใช้งาน ที่นี่ $ dbh คือหมายเลขอ้างอิงที่ส่งคืนโดย DBI-> connect () call
3	$dbh->prepare($sql) รูทีนนี้เตรียมคำสั่งสำหรับการดำเนินการในภายหลังโดยเอ็นจินฐานข้อมูลและส่งคืนการอ้างอิงไปยังอ็อบเจ็กต์การจัดการคำสั่ง
4	$sth->execute() รูทีนนี้ดำเนินการประมวลผลใด ๆ ที่จำเป็นเพื่อดำเนินการตามคำสั่งที่เตรียมไว้ ค่า undef จะถูกส่งกลับหากเกิดข้อผิดพลาด การดำเนินการที่ประสบความสำเร็จจะคืนค่าจริงเสมอโดยไม่คำนึงถึงจำนวนแถวที่ได้รับผลกระทบ ที่นี่$sth is a statement handle returned by $dbh-> จัดเตรียม ($ sql) โทร.
5	$sth->fetchrow_array() รูทีนนี้ดึงข้อมูลแถวถัดไปและส่งคืนเป็นรายการที่มีค่าฟิลด์ ฟิลด์ Null จะถูกส่งกลับเป็นค่า undef ในรายการ
6	$DBI::err ซึ่งเทียบเท่ากับ $ h-> err โดยที่ $h is any of the handle types like $dbh, $sth, or $drh. สิ่งนี้ส่งคืนรหัสข้อผิดพลาดเอ็นจินฐานข้อมูลเนทีฟจากเมธอดไดรเวอร์สุดท้ายที่เรียกว่า
7	$DBI::errstr ซึ่งเทียบเท่ากับ $ h-> errstr โดยที่ $h is any of the handle types like $dbh, $sth, or $drh. ส่งคืนข้อความแสดงข้อผิดพลาดเอ็นจินฐานข้อมูลเนทีฟจากเมธอด DBI ล่าสุดที่เรียก
8	$dbh->disconnect() รูทีนนี้จะปิดการเชื่อมต่อฐานข้อมูลที่เปิดไว้ก่อนหน้านี้โดยการโทรไปที่ DBI-> connect ()

เชื่อมต่อกับฐานข้อมูล

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

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite"; 
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) 
   or die $DBI::errstr;

print "Opened database successfully\n";

ตอนนี้ให้เรียกใช้โปรแกรมด้านบนเพื่อสร้างฐานข้อมูล test.db ในไดเร็กทอรีปัจจุบัน คุณสามารถเปลี่ยนเส้นทางของคุณได้ตามความต้องการของคุณ เก็บรหัสด้านบนไว้ในไฟล์ sqlite.pl และดำเนินการตามที่แสดงด้านล่าง หากสร้างฐานข้อมูลสำเร็จจะแสดงข้อความต่อไปนี้ -

$ chmod +x sqlite.pl
$ ./sqlite.pl
Open database successfully

สร้างตาราง

โปรแกรม Perl ต่อไปนี้ใช้สร้างตารางในฐานข้อมูลที่สร้างไว้ก่อนหน้านี้

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(CREATE TABLE COMPANY
   (ID INT PRIMARY KEY     NOT NULL,
      NAME           TEXT    NOT NULL,
      AGE            INT     NOT NULL,
      ADDRESS        CHAR(50),
      SALARY         REAL););

my $rv = $dbh->do($stmt); if($rv < 0) {
   print $DBI::errstr; } else { print "Table created successfully\n"; } $dbh->disconnect();

เมื่อโปรแกรมข้างต้นทำงานโปรแกรมจะสร้างตาราง COMPANY ใน test.db ของคุณและจะแสดงข้อความต่อไปนี้ -

Opened database successfully
Table created successfully

NOTE - ในกรณีที่คุณเห็นข้อผิดพลาดต่อไปนี้ในการดำเนินการใด ๆ -

DBD::SQLite::st execute failed: not an error(21) at dbdimp.c line 398

ในกรณีนี้ให้เปิด dbdimp.c file มีอยู่ในการติดตั้ง DBD-SQLite และค้นหา sqlite3_prepare() และเปลี่ยนอาร์กิวเมนต์ที่สามเป็น -1 แทนที่จะเป็น 0 สุดท้ายติดตั้ง DBD :: SQLite โดยใช้ make และทำ make install เพื่อแก้ไขปัญหา

การทำงานของ INSERT

โปรแกรม Perl ต่อไปนี้จะแสดงวิธีการสร้างเรกคอร์ดในตาราง COMPANY ที่สร้างในตัวอย่างข้างต้น

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite"; my $database = "test.db";
my $dsn = "DBI:$driver:dbname=$database"; my $userid = "";
my $password = ""; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Paul', 32, 'California', 20000.00 )); my $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
               VALUES (2, 'Allen', 25, 'Texas', 15000.00 ));
$rv = $dbh->do($stmt) or die $DBI::errstr;

$stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )); $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
               VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 ););

$rv = $dbh->do($stmt) or die $DBI::errstr;

print "Records created successfully\n";
$dbh->disconnect();

เมื่อโปรแกรมด้านบนทำงานโปรแกรมจะสร้างระเบียนที่กำหนดในตาราง COMPANY และจะแสดงสองบรรทัดต่อไปนี้ -

Opened database successfully
Records created successfully

เลือกการทำงาน

โปรแกรม Perl ต่อไปนี้จะแสดงวิธีการดึงข้อมูลและแสดงบันทึกจากตาราง COMPANY ที่สร้างขึ้นในตัวอย่างข้างต้น

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(SELECT id, name, address, salary from COMPANY;);
my $sth = $dbh->prepare( $stmt ); my $rv = $sth->execute() or die $DBI::errstr;

if($rv < 0) { print $DBI::errstr;
}

while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
      print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
      print "SALARY =  ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();

เมื่อโปรแกรมข้างต้นทำงานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  20000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

อัปเดตการทำงาน

ต่อไปนี้รหัส Perl จะแสดงวิธีการคำสั่ง UPDATE เพื่ออัปเดตระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่อัปเดตจากตาราง COMPANY

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite"; my $database = "test.db";
my $dsn = "DBI:$driver:dbname=$database"; my $userid = "";
my $password = ""; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(UPDATE COMPANY set SALARY = 25000.00 where ID=1;); my $rv = $dbh->do($stmt) or die $DBI::errstr; if( $rv < 0 ) {
   print $DBI::errstr; } else { print "Total number of rows updated : $rv\n";
}
$stmt = qq(SELECT id, name, address, salary from COMPANY;); my $sth = $dbh->prepare( $stmt );
$rv = $sth->execute() or die $DBI::errstr; if($rv < 0) {
   print $DBI::errstr; } while(my @row = $sth->fetchrow_array()) {
      print "ID = ". $row[0] . "\n"; print "NAME = ". $row[1] ."\n";
      print "ADDRESS = ". $row[2] ."\n"; print "SALARY = ". $row[3] ."\n\n";
}
print "Operation done successfully\n";
$dbh->disconnect();

เมื่อโปรแกรมข้างต้นทำงานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
Total number of rows updated : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  25000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

ลบการดำเนินการ

รหัส Perl ต่อไปนี้แสดงวิธีใช้คำสั่ง DELETE เพื่อลบระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่เหลือจากตาราง COMPANY -

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(DELETE from COMPANY where ID = 2;);
my $rv = $dbh->do($stmt) or die $DBI::errstr;

if( $rv < 0 ) { print $DBI::errstr;
} else {
   print "Total number of rows deleted : $rv\n"; } $stmt = qq(SELECT id, name, address, salary from COMPANY;);
my $sth = $dbh->prepare( $stmt ); $rv = $sth->execute() or die $DBI::errstr;

if($rv < 0) { print $DBI::errstr;
}

while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
      print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
      print "SALARY =  ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();

เมื่อโปรแกรมข้างต้นทำงานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
Total number of rows deleted : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

ในบทนี้คุณจะได้เรียนรู้การใช้ SQLite ในโปรแกรม Python

การติดตั้ง

SQLite3 สามารถรวมเข้ากับ Python โดยใช้โมดูล sqlite3 ซึ่งเขียนโดย Gerhard Haring มีอินเทอร์เฟซ SQL ที่สอดคล้องกับข้อกำหนด DB-API 2.0 ที่อธิบายโดย PEP 249 คุณไม่จำเป็นต้องติดตั้งโมดูลนี้แยกต่างหากเนื่องจากมีการจัดส่งโดยค่าเริ่มต้นพร้อมกับ Python เวอร์ชัน 2.5.x เป็นต้นไป

ในการใช้โมดูล sqlite3 ก่อนอื่นคุณต้องสร้างวัตถุการเชื่อมต่อที่แสดงถึงฐานข้อมูลจากนั้นคุณสามารถสร้างวัตถุเคอร์เซอร์ซึ่งจะช่วยคุณในการเรียกใช้คำสั่ง SQL ทั้งหมด

Python sqlite3 โมดูล API

ต่อไปนี้เป็นรูทีนโมดูล sqlite3 ที่สำคัญซึ่งสามารถเพียงพอต่อความต้องการของคุณในการทำงานกับฐานข้อมูล SQLite จากโปรแกรม Python ของคุณ หากคุณกำลังมองหาแอปพลิเคชันที่ซับซ้อนมากขึ้นคุณสามารถดูเอกสารอย่างเป็นทางการของโมดูล Python sqlite3

ซีเนียร์	API และคำอธิบาย
1	sqlite3.connect(database [,timeout ,other optional arguments]) API นี้เปิดการเชื่อมต่อกับไฟล์ฐานข้อมูล SQLite คุณสามารถใช้ ": memory:" เพื่อเปิดการเชื่อมต่อฐานข้อมูลกับฐานข้อมูลที่อยู่ใน RAM แทนบนดิสก์ หากเปิดฐานข้อมูลสำเร็จจะส่งคืนวัตถุการเชื่อมต่อ เมื่อฐานข้อมูลถูกเข้าถึงโดยการเชื่อมต่อหลายรายการและหนึ่งในกระบวนการแก้ไขฐานข้อมูลฐานข้อมูล SQLite จะถูกล็อกจนกว่าธุรกรรมนั้นจะถูกคอมมิต พารามิเตอร์การหมดเวลาระบุระยะเวลาที่การเชื่อมต่อควรรอให้การล็อกหายไปจนกว่าจะมีข้อยกเว้น ค่าเริ่มต้นสำหรับพารามิเตอร์การหมดเวลาคือ 5.0 (ห้าวินาที) หากไม่มีชื่อฐานข้อมูลที่ระบุการเรียกนี้จะสร้างฐานข้อมูล คุณสามารถระบุชื่อไฟล์ด้วยพา ธ ที่ต้องการได้เช่นกันหากคุณต้องการสร้างฐานข้อมูลที่อื่นยกเว้นในไดเร็กทอรีปัจจุบัน
2	connection.cursor([cursorClass]) กิจวัตรนี้จะสร้างไฟล์ cursorซึ่งจะใช้ตลอดการเขียนโปรแกรมฐานข้อมูลด้วย Python วิธีนี้ยอมรับ cursorClass พารามิเตอร์ทางเลือกเดียว หากให้มาต้องเป็นคลาสเคอร์เซอร์แบบกำหนดเองที่ขยาย sqlite3.Cursor
3	cursor.execute(sql [, optional parameters]) รูทีนนี้รันคำสั่ง SQL คำสั่ง SQL อาจถูกกำหนดพารามิเตอร์ (เช่นตัวยึดแทนตัวอักษร SQL) โมดูล sqlite3 รองรับตัวยึดตำแหน่งสองประเภท: เครื่องหมายคำถามและตัวยึดตำแหน่งที่ระบุชื่อ (สไตล์ที่ระบุชื่อ) For example - cursor.execute ("แทรกในค่าคน (?,?)", (ใครอายุ))
4	connection.execute(sql [, optional parameters]) รูทีนนี้เป็นทางลัดของวิธีการดำเนินการข้างต้นที่จัดเตรียมโดยวัตถุเคอร์เซอร์และจะสร้างวัตถุเคอร์เซอร์กลางโดยเรียกวิธีการเคอร์เซอร์จากนั้นเรียกวิธีการดำเนินการของเคอร์เซอร์ด้วยพารามิเตอร์ที่กำหนด
5	cursor.executemany(sql, seq_of_parameters) รูทีนนี้เรียกใช้คำสั่ง SQL กับลำดับพารามิเตอร์หรือการแม็พทั้งหมดที่พบในลำดับ sql
6	connection.executemany(sql[, parameters]) รูทีนนี้เป็นทางลัดที่สร้างวัตถุเคอร์เซอร์กลางโดยเรียกใช้วิธีเคอร์เซอร์จากนั้นเรียกวิธีการดำเนินการเคอร์เซอร์หลายวิธีด้วยพารามิเตอร์ที่กำหนด
7	cursor.executescript(sql_script) รูทีนนี้รันคำสั่ง SQL หลายคำสั่งพร้อมกันในรูปแบบของสคริปต์ มันออกคำสั่ง COMMIT ก่อนจากนั้นเรียกใช้สคริปต์ SQL ที่ได้รับเป็นพารามิเตอร์ คำสั่ง SQL ทั้งหมดควรคั่นด้วยเซมิโคลอน (;)
8	connection.executescript(sql_script) รูทีนนี้เป็นทางลัดที่สร้างวัตถุเคอร์เซอร์กลางโดยเรียกวิธีการเคอร์เซอร์จากนั้นเรียกเมธอด executescript ของเคอร์เซอร์ด้วยพารามิเตอร์ที่กำหนด
9	connection.total_changes() รูทีนนี้จะส่งคืนจำนวนแถวฐานข้อมูลทั้งหมดที่ถูกแก้ไขแทรกหรือลบไปตั้งแต่เปิดการเชื่อมต่อฐานข้อมูล
10	connection.commit() วิธีนี้ทำธุรกรรมปัจจุบัน หากคุณไม่เรียกใช้เมธอดนี้สิ่งที่คุณทำตั้งแต่การเรียกครั้งสุดท้ายเพื่อกระทำ () จะมองไม่เห็นจากการเชื่อมต่อฐานข้อมูลอื่น
11	connection.rollback() วิธีนี้ย้อนกลับการเปลี่ยนแปลงใด ๆ ในฐานข้อมูลตั้งแต่การเรียกครั้งสุดท้ายเพื่อกระทำ ()
12	connection.close() วิธีนี้จะปิดการเชื่อมต่อฐานข้อมูล โปรดทราบว่าสิ่งนี้ไม่ได้เรียกใช้การกระทำ () โดยอัตโนมัติ หากคุณเพียงแค่ปิดการเชื่อมต่อฐานข้อมูลโดยไม่เรียกคอมมิต () ก่อนการเปลี่ยนแปลงของคุณจะสูญหาย!
13	cursor.fetchone() วิธีนี้ดึงข้อมูลแถวถัดไปของชุดผลลัพธ์คิวรีส่งคืนลำดับเดียวหรือไม่มีเมื่อไม่มีข้อมูลเพิ่มเติม
14	cursor.fetchmany([size = cursor.arraysize]) รูทีนนี้ดึงข้อมูลชุดถัดไปของผลลัพธ์คิวรีโดยส่งคืนรายการ รายการว่างจะถูกส่งกลับเมื่อไม่มีแถวเพิ่มเติม วิธีนี้พยายามดึงข้อมูลหลายแถวตามที่ระบุโดยพารามิเตอร์ขนาด
15	cursor.fetchall() รูทีนนี้ดึงข้อมูลแถวทั้งหมด (ที่เหลือ) ของผลลัพธ์คิวรีโดยส่งคืนรายการ รายการว่างจะถูกส่งกลับเมื่อไม่มีแถว

เชื่อมต่อกับฐานข้อมูล

ตามโค้ด Python แสดงวิธีการเชื่อมต่อกับฐานข้อมูลที่มีอยู่ ถ้าฐานข้อมูลไม่มีอยู่ฐานข้อมูลนั้นจะถูกสร้างขึ้นและในที่สุดก็จะส่งคืนวัตถุฐานข้อมูล

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')

print "Opened database successfully";

ที่นี่คุณสามารถระบุชื่อฐานข้อมูลเป็นชื่อพิเศษได้ :memory:เพื่อสร้างฐานข้อมูลใน RAM ตอนนี้ให้เรียกใช้โปรแกรมด้านบนเพื่อสร้างฐานข้อมูลของเราtest.dbในไดเร็กทอรีปัจจุบัน คุณสามารถเปลี่ยนเส้นทางของคุณได้ตามความต้องการของคุณ เก็บรหัสด้านบนไว้ในไฟล์ sqlite.py และดำเนินการตามที่แสดงด้านล่าง หากสร้างฐานข้อมูลสำเร็จก็จะแสดงข้อความต่อไปนี้

$chmod +x sqlite.py $./sqlite.py
Open database successfully

สร้างตาราง

โปรแกรม Python ต่อไปนี้จะใช้สร้างตารางในฐานข้อมูลที่สร้างไว้ก่อนหน้านี้

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute('''CREATE TABLE COMPANY
         (ID INT PRIMARY KEY     NOT NULL,
         NAME           TEXT    NOT NULL,
         AGE            INT     NOT NULL,
         ADDRESS        CHAR(50),
         SALARY         REAL);''')
print "Table created successfully";

conn.close()

เมื่อโปรแกรมด้านบนทำงานโปรแกรมจะสร้างตาราง COMPANY ในไฟล์ test.db และจะแสดงข้อความต่อไปนี้ -

Opened database successfully
Table created successfully

การทำงานของ INSERT

โปรแกรม Python ต่อไปนี้แสดงวิธีการสร้างระเบียนในตาราง COMPANY ที่สร้างในตัวอย่างข้างต้น

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (1, 'Paul', 32, 'California', 20000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (2, 'Allen', 25, 'Texas', 15000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 )");

conn.commit()
print "Records created successfully";
conn.close()

เมื่อโปรแกรมด้านบนทำงานโปรแกรมจะสร้างระเบียนที่กำหนดในตาราง COMPANY และจะแสดงสองบรรทัดต่อไปนี้ -

Opened database successfully
Records created successfully

เลือกการทำงาน

โปรแกรม Python ต่อไปนี้จะแสดงวิธีการดึงข้อมูลและแสดงบันทึกจากตาราง COMPANY ที่สร้างขึ้นในตัวอย่างข้างต้น

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

เมื่อโปรแกรมข้างต้นทำงานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000.0

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

อัปเดตการทำงาน

รหัส Python ต่อไปนี้แสดงวิธีใช้คำสั่ง UPDATE เพื่ออัปเดตระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่อัปเดตจากตาราง COMPANY

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("UPDATE COMPANY set SALARY = 25000.00 where ID = 1")
conn.commit()
print "Total number of rows updated :", conn.total_changes

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

เมื่อโปรแกรมข้างต้นทำงานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
Total number of rows updated : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000.0

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

ลบการดำเนินการ

รหัส Python ต่อไปนี้แสดงวิธีใช้คำสั่ง DELETE เพื่อลบระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่เหลือจากตาราง COMPANY

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("DELETE from COMPANY where ID = 2;")
conn.commit()
print "Total number of rows deleted :", conn.total_changes

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

เมื่อโปรแกรมข้างต้นทำงานโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้

Opened database successfully
Total number of rows deleted : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully