SQLite - Hướng dẫn nhanh

Chương này giúp bạn hiểu SQLite là gì, nó khác với SQL như thế nào, tại sao nó lại cần thiết và cách nó xử lý các ứng dụng Cơ sở dữ liệu.

SQLite là một thư viện phần mềm triển khai một công cụ cơ sở dữ liệu SQL giao dịch độc lập, không máy chủ, không cấu hình, không giao dịch. SQLite là một trong những công cụ cơ sở dữ liệu phát triển nhanh nhất hiện nay, nhưng đó là sự phát triển về mức độ phổ biến, không liên quan gì đến kích thước của nó. Mã nguồn cho SQLite nằm trong miền công cộng.

SQLite là gì?

SQLite là một thư viện trong quá trình triển khai một công cụ cơ sở dữ liệu SQL giao dịch độc lập, không máy chủ, không cấu hình. Nó là một cơ sở dữ liệu, được cấu hình bằng không, có nghĩa là giống như các cơ sở dữ liệu khác, bạn không cần phải cấu hình nó trong hệ thống của mình.

SQLite engine không phải là một quy trình độc lập như các cơ sở dữ liệu khác, bạn có thể liên kết nó tĩnh hoặc động tùy theo yêu cầu của bạn với ứng dụng của bạn. SQLite truy cập trực tiếp vào các tệp lưu trữ của nó.

Tại sao sử dụng SQLite?

SQLite không yêu cầu một quy trình hoặc hệ thống máy chủ riêng biệt để hoạt động (serverless).
SQLite đi kèm với cấu hình không, có nghĩa là không cần thiết lập hoặc quản trị.
Cơ sở dữ liệu SQLite hoàn chỉnh được lưu trữ trong một tệp đĩa đa nền tảng.
SQLite rất nhỏ và trọng lượng nhẹ, dưới 400KiB được cấu hình đầy đủ hoặc dưới 250KiB với các tính năng tùy chọn bị bỏ qua.
SQLite là độc lập, có nghĩa là không có phụ thuộc bên ngoài.
Các giao dịch SQLite hoàn toàn tuân thủ ACID, cho phép truy cập an toàn từ nhiều quy trình hoặc chuỗi.
SQLite hỗ trợ hầu hết các tính năng ngôn ngữ truy vấn có trong tiêu chuẩn SQL92 (SQL2).
SQLite được viết bằng ANSI-C và cung cấp API đơn giản và dễ sử dụng.
SQLite có sẵn trên UNIX (Linux, Mac OS-X, Android, iOS) và Windows (Win32, WinCE, WinRT).

Lịch sử tóm tắt về SQLite

2000 - D. Richard Hipp đã thiết kế SQLite với mục đích không cần quản trị để vận hành một chương trình.
2000 - Vào tháng 8, SQLite 1.0 được phát hành với Trình quản lý cơ sở dữ liệu GNU.
2011 - Hipp thông báo thêm giao diện UNQl vào SQLite DB và phát triển UNQLite (Cơ sở dữ liệu hướng tài liệu).

Hạn chế của SQLite

Có một số tính năng không được hỗ trợ của SQL92 trong SQLite được liệt kê trong bảng sau.

Sr.No.	Sự miêu tả yếu tố
1	RIGHT OUTER JOIN Chỉ LEFT OUTER JOIN mới được triển khai.
2	FULL OUTER JOIN Chỉ LEFT OUTER JOIN mới được triển khai.
3	ALTER TABLE Các biến thể RENAME TABLE và ADD COLUMN của lệnh ALTER TABLE được hỗ trợ. Không hỗ trợ DROP COLUMN, ALTER COLUMN, ADD CONSTRAINT.
4	Trigger support Trình kích hoạt CHO MỖI ROW được hỗ trợ nhưng không hỗ trợ trình kích hoạt CHO MỖI THỐNG KÊ.
5	VIEWs VIEW trong SQLite là chế độ chỉ đọc. Bạn không thể thực hiện câu lệnh DELETE, INSERT hoặc UPDATE trên một dạng xem.
6	GRANT and REVOKE Các quyền truy cập duy nhất có thể được áp dụng là các quyền truy cập tệp bình thường của hệ điều hành cơ bản.

Lệnh SQLite

Các lệnh SQLite chuẩn để tương tác với cơ sở dữ liệu quan hệ tương tự như SQL. Chúng được TẠO, CHỌN, CHÈN, CẬP NHẬT, XÓA và DROP. Các lệnh này có thể được phân loại thành các nhóm dựa trên bản chất hoạt động của chúng -

DDL - Ngôn ngữ định nghĩa dữ liệu

Sr.No.	Lệnh & Mô tả
1	CREATE Tạo bảng mới, dạng xem bảng hoặc đối tượng khác trong cơ sở dữ liệu.
2	ALTER Sửa đổi đối tượng cơ sở dữ liệu hiện có, chẳng hạn như bảng.
3	DROP Xóa toàn bộ bảng, dạng xem bảng hoặc đối tượng khác trong cơ sở dữ liệu.

DML - Ngôn ngữ thao tác dữ liệu

Sr.No.	Lệnh & Mô tả
1	INSERT Tạo kỷ lục
2	UPDATE Sửa đổi hồ sơ
3	DELETE Xóa hồ sơ

DQL - Ngôn ngữ truy vấn dữ liệu

Sr.No.	Lệnh & Mô tả
1	SELECT Truy xuất các bản ghi nhất định từ một hoặc nhiều bảng

SQLite nổi tiếng với tính năng tuyệt vời là không cấu hình, có nghĩa là không cần thiết lập hoặc quản trị phức tạp. Chương này sẽ đưa bạn qua quá trình thiết lập SQLite trên Windows, Linux và Mac OS X.

Cài đặt SQLite trên Windows

Step 1- Truy cập trang tải xuống SQLite và tải xuống các tệp nhị phân được biên dịch trước từ phần Windows.
Step 2 - Tải xuống các tệp nén sqlite-shell-win32 - *. Zip và sqlite-dll-win32 - *. Zip.
Step 3 - Tạo thư mục C: \> sqlite và giải nén hai tệp đã nén ở trên trong thư mục này, thư mục này sẽ cung cấp cho bạn các tệp sqlite3.def, sqlite3.dll và sqlite3.exe.
Step 4 - Thêm C: \> sqlite vào biến môi trường PATH của bạn và cuối cùng vào dấu nhắc lệnh và đưa ra lệnh sqlite3, lệnh này sẽ hiển thị kết quả sau.

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>

Cài đặt SQLite trên Linux

Ngày nay, hầu hết tất cả các phiên bản của hệ điều hành Linux đang được vận chuyển cùng với SQLite. Vì vậy, bạn chỉ cần đưa ra lệnh sau để kiểm tra xem bạn đã cài đặt SQLite trên máy của mình chưa.

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

Nếu bạn không thấy kết quả trên thì có nghĩa là bạn chưa cài đặt SQLite trên máy Linux của mình. Sau đây là các bước sau để cài đặt SQLite:

Step 1- Truy cập trang tải xuống SQLite và tải xuống sqlite-autoconf - *. Tar.gz từ phần mã nguồn.
Step 2 - Chạy lệnh sau -

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

Lệnh trên sẽ kết thúc khi cài đặt SQLite trên máy Linux của bạn. Mà bạn có thể xác minh như đã giải thích ở trên.

Cài đặt SQLite trên Mac OS X

Mặc dù phiên bản Mac OS X mới nhất được cài đặt sẵn SQLite nhưng nếu bạn chưa có cài đặt sẵn thì chỉ cần làm theo các bước sau:

Step 1- Truy cập trang tải xuống SQLite và tải xuống sqlite-autoconf - *. Tar.gz từ phần mã nguồn.
Step 2 - Chạy lệnh sau -

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

Quy trình trên sẽ kết thúc khi cài đặt SQLite trên máy Mac OS X của bạn. Bạn có thể xác minh bằng cách sử dụng lệnh sau:

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

Cuối cùng, bạn có dấu nhắc lệnh SQLite nơi bạn có thể đưa ra các lệnh SQLite cho các bài tập của mình.

Chương này sẽ đưa bạn qua các lệnh đơn giản và hữu ích được các lập trình viên SQLite sử dụng. Các lệnh này được gọi là lệnh chấm SQLite và ngoại lệ với các lệnh này là chúng không được kết thúc bằng dấu chấm phẩy (;).

Hãy bắt đầu bằng cách nhập một sqlite3 lệnh tại dấu nhắc lệnh sẽ cung cấp cho bạn dấu nhắc lệnh SQLite nơi bạn sẽ đưa ra các lệnh SQLite khác nhau.

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

Để có danh sách các lệnh chấm có sẵn, bạn có thể nhập ".help" bất kỳ lúc nào. Ví dụ -

sqlite>.help

Lệnh trên sẽ hiển thị danh sách các lệnh chấm SQLite quan trọng khác nhau, được liệt kê trong bảng sau.

Sr.No.	Lệnh & Mô tả
1	.backup ?DB? FILE Sao lưu DB (mặc định "chính") thành FILE
2	.bail ON\|OFF Dừng lại sau khi gặp lỗi. TẮT mặc định
3	.databases Liệt kê tên và tệp của cơ sở dữ liệu đính kèm
4	.dump ?TABLE? Kết xuất cơ sở dữ liệu ở định dạng văn bản SQL. Nếu TABLE được chỉ định, chỉ kết xuất bảng phù hợp với mẫu LIKE TABLE
5	.echo ON\|OFF Bật hoặc tắt tiếng vọng lệnh
6	.exit Thoát lời nhắc SQLite
7	.explain ON\|OFF Bật hoặc tắt chế độ đầu ra phù hợp với EXPLAIN. Không có args, nó sẽ bật EXPLAIN
số 8	.header(s) ON\|OFF Bật hoặc tắt hiển thị tiêu đề
9	.help Hiển thị tin nhắn này
10	.import FILE TABLE Nhập dữ liệu từ FILE vào TABLE
11	.indices ?TABLE? Hiển thị tên của tất cả các chỉ số. Nếu TABLE được chỉ định, chỉ hiển thị chỉ số cho các bảng phù hợp với mẫu LIKE TABLE
12	.load FILE ?ENTRY? Tải thư viện tiện ích mở rộng
13	.log FILE\|off Bật hoặc tắt đăng nhập. FILE có thể là stderr / stdout
14	.mode MODE Đặt chế độ đầu ra trong đó MODE là một trong - csv - Các giá trị được phân tách bằng dấu phẩy column - Các cột căn trái. html - Mã HTML <table> insert - Câu lệnh chèn SQL cho TABLE line - Một giá trị trên mỗi dòng list - Các giá trị được phân tách bằng chuỗi .separator tabs - Các giá trị được phân tách bằng tab tcl - Phần tử danh sách TCL
15	.nullvalue STRING In STRING thay cho giá trị NULL
16	.output FILENAME Gửi đầu ra tới FILENAME
17	.output stdout Gửi kết quả ra màn hình
18	.print STRING... In chữ STRING
19	.prompt MAIN CONTINUE Thay thế lời nhắc tiêu chuẩn
20	.quit Thoát lời nhắc SQLite
21	.read FILENAME Thực thi SQL trong FILENAME
22	.schema ?TABLE? Hiển thị các câu lệnh CREATE. Nếu TABLE được chỉ định, chỉ hiển thị các bảng phù hợp với mẫu LIKE TABLE
23	.separator STRING Thay đổi dấu phân tách được sử dụng bởi chế độ đầu ra và .import
24	.show Hiển thị các giá trị hiện tại cho các cài đặt khác nhau
25	.stats ON\|OFF Bật hoặc tắt số liệu thống kê
26	.tables ?PATTERN? Liệt kê tên các bảng phù hợp với mẫu LIKE
27	.timeout MS Thử mở các bảng bị khóa trong MS mili giây
28	.width NUM NUM Đặt chiều rộng cột cho chế độ "cột"
29	.timer ON\|OFF Bật hoặc tắt tính năng đo bộ đếm thời gian CPU

Hãy thử .show để xem cài đặt mặc định cho dấu nhắc lệnh SQLite của bạn.

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

Đảm bảo không có khoảng trống giữa lệnh sqlite> prompt và dot, nếu không nó sẽ không hoạt động.

Định dạng đầu ra

Bạn có thể sử dụng chuỗi lệnh dấu chấm sau để định dạng đầu ra của mình.

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

Cài đặt trên sẽ tạo ra đầu ra ở định dạng sau.

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

Bảng sqlite_master

Bảng chính chứa thông tin quan trọng về các bảng cơ sở dữ liệu của bạn và nó được gọi là sqlite_master. Bạn có thể xem lược đồ của nó như sau:

sqlite>.schema sqlite_master

Điều này sẽ tạo ra kết quả sau.

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

SQLite được theo sau bởi một bộ quy tắc và hướng dẫn duy nhất được gọi là Cú pháp. Chương này liệt kê tất cả các Cú pháp SQLite cơ bản.

Phân biệt chữ hoa chữ thường

Điểm quan trọng cần lưu ý là SQLite là case insensitive, tức là các mệnh đề GLOB và glob có cùng ý nghĩa trong các câu lệnh SQLite.

Bình luận

Nhận xét SQLite là ghi chú bổ sung, bạn có thể thêm vào mã SQLite của mình để tăng khả năng đọc của nó và chúng có thể xuất hiện ở bất kỳ đâu; khoảng trắng có thể xảy ra, bao gồm cả các biểu thức bên trong và ở giữa các câu lệnh SQL khác nhưng chúng không thể lồng vào nhau.

Nhận xét SQL bắt đầu bằng hai ký tự "-" liên tiếp (ASCII 0x2d) và mở rộng đến và bao gồm cả ký tự dòng mới tiếp theo (ASCII 0x0a) hoặc cho đến khi kết thúc đầu vào, tùy điều kiện nào đến trước.

Bạn cũng có thể sử dụng chú thích kiểu C, bắt đầu bằng "/ *" và mở rộng đến và bao gồm cả cặp ký tự "* /" tiếp theo hoặc cho đến khi kết thúc đầu vào, tùy điều kiện nào đến trước. Nhận xét kiểu C có thể kéo dài nhiều dòng.

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

Câu lệnh SQLite

Tất cả các câu lệnh SQLite bắt đầu bằng bất kỳ từ khóa nào như SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, v.v. và tất cả các câu lệnh kết thúc bằng dấu chấm phẩy (;).

Câu lệnh SQLite ANALYZE

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

Mệnh đề AND / OR của SQLite

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

Câu lệnh SQLite ALTER TABLE

ALTER TABLE table_name ADD COLUMN column_def...;

Câu lệnh SQLite ALTER TABLE (Đổi tên)

ALTER TABLE table_name RENAME TO new_table_name;

Câu lệnh SQLite ATTACH DATABASE

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

SQLite BEGIN TRANSACTION Statement

BEGIN;
or
BEGIN EXCLUSIVE TRANSACTION;

SQLite BETWEEN mệnh đề

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

Tuyên bố CAM KẾT của SQLite

COMMIT;

Câu lệnh SQLite CREATE INDEX

CREATE INDEX index_name
ON table_name ( column_name COLLATE NOCASE );

SQLite TẠO Tuyên bố INDEX DUY NHẤT

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

Câu lệnh SQLite CREATE TABLE

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

Câu lệnh SQLite CREATE TRIGGER

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

Câu lệnh SQLite CREATE VIEW

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

Câu lệnh SQLite CREATE VIRTUAL TABLE

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

Tuyên bố GIAO DỊCH CAM KẾT của SQLite

COMMIT;

Mệnh đề COUNT trong SQLite

SELECT COUNT(column_name)
FROM table_name
WHERE CONDITION;

Câu lệnh SQLite DELETE

DELETE FROM table_name
WHERE {CONDITION};

Tuyên bố cơ sở dữ liệu DETACH của SQLite

DETACH DATABASE 'Alias-Name';

Mệnh đề DISTINCT của SQLite

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

Câu lệnh SQLite DROP INDEX

DROP INDEX database_name.index_name;

Câu lệnh SQLite DROP TABLE

DROP TABLE database_name.table_name;

Câu lệnh SQLite DROP VIEW

DROP INDEX database_name.view_name;

Câu lệnh SQLite DROP TRIGGER

DROP INDEX database_name.trigger_name;

Mệnh đề SQLite EXISTS

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

Câu lệnh SQLite EXPLAIN

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

Mệnh đề GLOB của SQLite

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

Mệnh đề GROUP BY trong SQLite

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

Mệnh đề HAVING của SQLite

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

SQLite INSERT INTO Statement

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

Mệnh đề SQLite IN

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

Mệnh đề giống SQLite

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

Mệnh đề KHÔNG TRONG SQLite

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

Mệnh đề ORDER BY trong SQLite

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

Câu lệnh SQLite PRAGMA

PRAGMA pragma_name;

For example:

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

Câu lệnh SQLite RELEASE SAVEPOINT

RELEASE savepoint_name;

Câu lệnh SQLite REINDEX

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

Câu lệnh SQLite ROLLBACK

ROLLBACK;
or
ROLLBACK TO SAVEPOINT savepoint_name;

Câu lệnh SQLite SAVEPOINT

SAVEPOINT savepoint_name;

Câu lệnh SQLite SELECT

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

Câu lệnh CẬP NHẬT SQLite

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

Câu lệnh SQLite VACUUM

VACUUM;

Mệnh đề WHERE trong SQLite

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

Kiểu dữ liệu SQLite là một thuộc tính chỉ định kiểu dữ liệu của bất kỳ đối tượng nào. Mỗi cột, biến và biểu thức có kiểu dữ liệu liên quan trong SQLite.

Bạn sẽ sử dụng các kiểu dữ liệu này trong khi tạo bảng của mình. SQLite sử dụng một hệ thống kiểu động tổng quát hơn. Trong SQLite, kiểu dữ liệu của một giá trị được liên kết với chính giá trị đó, không phải với vùng chứa của nó.

Các lớp lưu trữ SQLite

Mỗi giá trị được lưu trữ trong cơ sở dữ liệu SQLite có một trong các lớp lưu trữ sau:

Sr.No.	Lớp lưu trữ & Mô tả
1	NULL Giá trị là giá trị NULL.
2	INTEGER Giá trị là một số nguyên có dấu, được lưu trữ trong 1, 2, 3, 4, 6 hoặc 8 byte tùy thuộc vào độ lớn của giá trị.
3	REAL Giá trị là một giá trị dấu phẩy động, được lưu trữ dưới dạng số dấu phẩy động IEEE 8 byte.
4	TEXT Giá trị là một chuỗi văn bản, được lưu trữ bằng cách sử dụng mã hóa cơ sở dữ liệu (UTF-8, UTF-16BE hoặc UTF-16LE)
5	BLOB Giá trị là một khối dữ liệu, được lưu trữ chính xác như đầu vào.

Lớp lưu trữ SQLite tổng quát hơn một chút so với kiểu dữ liệu. Ví dụ, lớp lưu trữ INTEGER bao gồm 6 kiểu dữ liệu số nguyên khác nhau có độ dài khác nhau.

Loại sở thích SQLite

SQLite hỗ trợ khái niệm type affinitytrên các cột. Bất kỳ cột nào vẫn có thể lưu trữ bất kỳ loại dữ liệu nào nhưng lớp lưu trữ ưu tiên cho một cột được gọi làaffinity. Mỗi cột bảng trong cơ sở dữ liệu SQLite3 được gán một trong các kiểu sở thích sau:

Sr.No.	Sở thích & Mô tả
1	TEXT Cột này lưu trữ tất cả dữ liệu bằng cách sử dụng các lớp lưu trữ NULL, TEXT hoặc BLOB.
2	NUMERIC Cột này có thể chứa các giá trị sử dụng tất cả năm lớp lưu trữ.
3	INTEGER Hoạt động giống như cột có mối quan hệ NUMERIC, với một ngoại lệ trong biểu thức CAST.
4	REAL Hoạt động giống như một cột có mối quan hệ NUMERIC ngoại trừ việc nó buộc các giá trị số nguyên vào biểu diễn dấu phẩy động.
5	NONE Cột có mối quan hệ NONE không thích một lớp lưu trữ hơn lớp khác và không có nỗ lực nào được thực hiện để ép buộc dữ liệu từ lớp lưu trữ này sang lớp khác.

Tên loại và sở thích SQLite

Bảng sau liệt kê các tên kiểu dữ liệu khác nhau có thể được sử dụng trong khi tạo bảng SQLite3 với mối quan hệ được áp dụng tương ứng.

Loại dữ liệu	Sự giống nhau
INT INTEGER TINYINT SMALLINT MEDIUMINT BIGINT KHÔNG ĐĂNG KÝ LỚN INT INT2 INT8	INTEGER
CHARACTER(20) VARCHAR(255) KÝ TỰ VARYING (255) NCHAR(55) NHÂN VẬT TỰ NHIÊN (70) NVARCHAR(100) TEXT CLOB	BẢN VĂN
BLOB không có loại dữ liệu nào được chỉ định	KHÔNG AI
REAL DOUBLE CHÍNH XÁC ĐÔI FLOAT	THỰC TẾ
NUMERIC DECIMAL(10,5) BOOLEAN DATE DATETIME	SỐ

Boolean Datatype

SQLite không có lớp lưu trữ Boolean riêng biệt. Thay vào đó, các giá trị Boolean được lưu trữ dưới dạng số nguyên 0 (sai) và 1 (đúng).

Kiểu dữ liệu ngày và giờ

SQLite không có lớp lưu trữ riêng để lưu trữ ngày và / hoặc thời gian, nhưng SQLite có khả năng lưu trữ ngày và giờ dưới dạng giá trị TEXT, REAL hoặc INTEGER.

Sr.No.	Lớp lưu trữ & Định dạng ngày
1	TEXT Ngày có định dạng như "YYYY-MM-DD HH: MM: SS.SSS"
2	REAL Số ngày kể từ buổi trưa ở Greenwich vào ngày 24 tháng 11 năm 4714 trước Công nguyên
3	INTEGER Số giây kể từ 1970-01-01 00:00:00 UTC

Bạn có thể chọn lưu trữ ngày và giờ ở bất kỳ định dạng nào trong số này và tự do chuyển đổi giữa các định dạng bằng cách sử dụng các chức năng ngày và giờ được tích hợp sẵn.

Trong SQLite, sqlite3lệnh được sử dụng để tạo cơ sở dữ liệu SQLite mới. Bạn không cần phải có bất kỳ đặc quyền đặc biệt nào để tạo cơ sở dữ liệu.

Cú pháp

Sau đây là cú pháp cơ bản của lệnh sqlite3 để tạo cơ sở dữ liệu: -

$sqlite3 DatabaseName.db

Luôn luôn, tên cơ sở dữ liệu phải là duy nhất trong RDBMS.

Thí dụ

Nếu bạn muốn tạo một cơ sở dữ liệu mới <testDB.db>, thì câu lệnh SQLITE3 sẽ như sau:

$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>

Lệnh trên sẽ tạo một tệp testDB.dbtrong thư mục hiện tại. Tệp này sẽ được sử dụng làm cơ sở dữ liệu bởi SQLite engine. Nếu bạn nhận thấy trong khi tạo cơ sở dữ liệu, lệnh sqlite3 sẽ cung cấpsqlite> nhắc sau khi tạo tệp cơ sở dữ liệu thành công.

Sau khi cơ sở dữ liệu được tạo, bạn có thể xác minh nó trong danh sách cơ sở dữ liệu bằng cách sử dụng SQLite sau .databases chỉ huy.

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

Bạn sẽ sử dụng SQLite .quit lệnh thoát ra khỏi dấu nhắc sqlite như sau:

sqlite>.quit
$

Lệnh .dump

Bạn có thể dùng .dump lệnh dot để xuất cơ sở dữ liệu hoàn chỉnh trong một tệp văn bản bằng cách sử dụng lệnh SQLite sau tại dấu nhắc lệnh.

$sqlite3 testDB.db .dump > testDB.sql

Lệnh trên sẽ chuyển đổi toàn bộ nội dung của testDB.db cơ sở dữ liệu vào các câu lệnh SQLite và kết xuất nó vào tệp văn bản ASCII testDB.sql. Bạn có thể thực hiện khôi phục từ testDB.sql đã tạo theo cách đơn giản như sau:

$sqlite3 testDB.db < testDB.sql

Tại thời điểm này, cơ sở dữ liệu của bạn trống, vì vậy bạn có thể thử hai quy trình trên khi bạn có ít bảng và dữ liệu trong cơ sở dữ liệu của mình. Còn bây giờ, chúng ta hãy chuyển sang chương tiếp theo.

Hãy xem xét một trường hợp khi bạn có nhiều cơ sở dữ liệu và bạn muốn sử dụng bất kỳ cơ sở dữ liệu nào trong số chúng cùng một lúc. SQLiteATTACH DATABASE câu lệnh được sử dụng để chọn một cơ sở dữ liệu cụ thể và sau lệnh này, tất cả các câu lệnh SQLite sẽ được thực thi trong cơ sở dữ liệu đính kèm.

Cú pháp

Sau đây là cú pháp cơ bản của câu lệnh SQLite ATTACH DATABASE.

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

Lệnh trên cũng sẽ tạo cơ sở dữ liệu trong trường hợp cơ sở dữ liệu chưa được tạo, nếu không, nó sẽ chỉ đính kèm tên tệp cơ sở dữ liệu với cơ sở dữ liệu logic 'Alias-Name'.

Thí dụ

Nếu bạn muốn đính kèm một cơ sở dữ liệu hiện có testDB.db, thì câu lệnh ATTACH DATABASE sẽ như sau:

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

Sử dụng SQLite .database lệnh hiển thị cơ sở dữ liệu đính kèm.

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

Tên cơ sở dữ liệu main và tempđược dành riêng cho cơ sở dữ liệu chính và cơ sở dữ liệu để chứa các bảng tạm thời và các đối tượng dữ liệu tạm thời khác. Cả hai tên cơ sở dữ liệu này đều tồn tại cho mọi kết nối cơ sở dữ liệu và không nên được sử dụng để đính kèm, nếu không bạn sẽ nhận được thông báo cảnh báo sau.

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 DATABASEcâu lệnh được sử dụng để tách và tách cơ sở dữ liệu được đặt tên khỏi kết nối cơ sở dữ liệu đã được đính kèm trước đó bằng cách sử dụng câu lệnh ATTACH. Nếu cùng một tệp cơ sở dữ liệu đã được đính kèm với nhiều bí danh, thì lệnh DETACH sẽ chỉ ngắt kết nối với tên đã cho và phần còn lại của tệp đính kèm sẽ vẫn tiếp tục. Bạn không thể táchmain hoặc là temp cơ sở dữ liệu.

Nếu cơ sở dữ liệu là cơ sở dữ liệu trong bộ nhớ hoặc cơ sở dữ liệu tạm thời, cơ sở dữ liệu sẽ bị hủy và nội dung sẽ bị mất.

Cú pháp

Sau đây là cú pháp cơ bản của câu lệnh SQLite DETACH DATABASE 'Alias-Name'.

DETACH DATABASE 'Alias-Name';

Ở đây, 'Alias-Name' chính là bí danh mà bạn đã sử dụng khi đính kèm cơ sở dữ liệu bằng câu lệnh ATTACH.

Thí dụ

Hãy xem xét bạn có một cơ sở dữ liệu mà bạn đã tạo ở chương trước và đính kèm nó với 'test' và 'currentDB' như chúng ta có thể thấy bằng cách sử dụng .database chỉ huy.

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

Hãy thử tách 'currentDB' khỏi testDB.db bằng lệnh sau.

sqlite> DETACH DATABASE 'currentDB';

Bây giờ, nếu bạn kiểm tra phần đính kèm hiện tại, bạn sẽ thấy rằng testDB.db vẫn được kết nối với 'test' và 'main'.

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

SQLite CREATE TABLEđược sử dụng để tạo một bảng mới trong bất kỳ cơ sở dữ liệu đã cho. Tạo một bảng cơ bản bao gồm đặt tên cho bảng và xác định các cột của nó và kiểu dữ liệu của mỗi cột.

Cú pháp

Sau đây là cú pháp cơ bản của câu lệnh CREATE TABLE.

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

CREATE TABLE là từ khóa yêu cầu hệ thống cơ sở dữ liệu tạo một bảng mới. Tên hoặc định danh duy nhất cho bảng tuân theo câu lệnh CREATE TABLE. Theo tùy chọn, bạn có thể chỉ định database_name cùng với table_name .

Thí dụ

Sau đây là một ví dụ tạo một bảng COMPANY với ID là khóa chính và NOT NULL là các ràng buộc cho thấy rằng các trường này không thể là NULL khi tạo bản ghi trong bảng này.

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

Hãy để chúng tôi tạo thêm một bảng, chúng tôi sẽ sử dụng bảng này trong các bài tập của chúng tôi trong các chương tiếp theo.

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

Bạn có thể xác minh xem bảng của mình đã được tạo thành công hay chưa bằng lệnh SQLite .tables lệnh này sẽ được sử dụng để liệt kê tất cả các bảng trong cơ sở dữ liệu đính kèm.

sqlite>.tables
COMPANY     DEPARTMENT

Tại đây, bạn có thể thấy bảng COMPANY hai lần vì bảng COMPANY hiển thị cho cơ sở dữ liệu chính và bảng test.COMPANY cho bí danh 'test' được tạo cho testDB.db của bạn. Bạn có thể nhận được thông tin đầy đủ về một bảng bằng cách sử dụng SQLite sau.schema chỉ huy.

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 câu lệnh được sử dụng để xóa định nghĩa bảng và tất cả dữ liệu liên quan, chỉ mục, trình kích hoạt, ràng buộc và đặc tả quyền cho bảng đó.

Bạn phải cẩn thận khi sử dụng lệnh này vì khi một bảng bị xóa thì tất cả thông tin có sẵn trong bảng cũng sẽ bị mất vĩnh viễn.

Cú pháp

Sau đây là cú pháp cơ bản của câu lệnh DROP TABLE. Bạn có thể tùy chọn chỉ định tên cơ sở dữ liệu cùng với tên bảng như sau:

DROP TABLE database_name.table_name;

Thí dụ

Đầu tiên hãy để chúng tôi xác minh bảng COMPANY và sau đó chúng tôi sẽ xóa nó khỏi cơ sở dữ liệu.

sqlite>.tables
COMPANY       test.COMPANY

Điều này có nghĩa là bảng COMPANY có sẵn trong cơ sở dữ liệu, vì vậy hãy để chúng tôi loại bỏ nó như sau:

sqlite>DROP TABLE COMPANY;
sqlite>

Bây giờ, nếu bạn thử lệnh .TABLES, thì bạn sẽ không tìm thấy bảng COMPANY nữa.

sqlite>.tables
sqlite>

Nó không hiển thị gì có nghĩa là bảng từ cơ sở dữ liệu của bạn đã bị loại bỏ thành công.

SQLite INSERT INTO Câu lệnh được sử dụng để thêm các hàng dữ liệu mới vào một bảng trong cơ sở dữ liệu.

Cú pháp

Sau đây là hai cú pháp cơ bản của câu lệnh INSERT INTO.

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

Ở đây, column1, column2, ... columnN là tên của các cột trong bảng mà bạn muốn chèn dữ liệu vào.

Bạn có thể không cần chỉ định (các) tên cột trong truy vấn SQLite nếu bạn đang thêm giá trị cho tất cả các cột của bảng. Tuy nhiên, hãy đảm bảo rằng thứ tự của các giá trị theo cùng thứ tự với các cột trong bảng. Cú pháp INSERT INTO của SQLite sẽ như sau:

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

Thí dụ

Hãy xem xét bạn đã tạo bảng COMPANY trong testDB.db của mình như sau:

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

Bây giờ, các câu lệnh sau sẽ tạo sáu bản ghi trong bảng 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 );

Bạn có thể tạo bản ghi trong bảng COMPANY bằng cú pháp thứ hai như sau:

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

Tất cả các câu lệnh trên sẽ tạo các bản ghi sau trong bảng COMPANY. Trong chương tiếp theo, bạn sẽ học cách hiển thị tất cả các bản ghi này từ một bảng.

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

Điền vào một bảng bằng cách sử dụng một bảng khác

Bạn có thể điền dữ liệu vào một bảng thông qua câu lệnh select trên một bảng khác với điều kiện một bảng khác có một tập hợp các trường, bắt buộc phải điền vào bảng đầu tiên. Đây là cú pháp -

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

Hiện tại, bạn có thể bỏ qua câu lệnh trên. Đầu tiên, chúng ta hãy tìm hiểu các mệnh đề SELECT và WHERE sẽ được đề cập trong các chương tiếp theo.

SQLite SELECTcâu lệnh được sử dụng để tìm nạp dữ liệu từ bảng cơ sở dữ liệu SQLite, bảng này trả về dữ liệu ở dạng bảng kết quả. Các bảng kết quả này còn được gọi làresult sets.

Cú pháp

Sau đây là cú pháp cơ bản của câu lệnh SQLite SELECT.

SELECT column1, column2, columnN FROM table_name;

Ở đây, column1, column2 ... là các trường của một bảng, có các giá trị mà bạn muốn tìm nạp. Nếu bạn muốn tìm nạp tất cả các trường có sẵn trong trường, thì bạn có thể sử dụng cú pháp sau:

SELECT * FROM table_name;

Thí dụ

Xem xét bảng COMPANY với các bản ghi sau:

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

Sau đây là một ví dụ để tìm nạp và hiển thị tất cả các bản ghi này bằng cách sử dụng câu lệnh SELECT. Ở đây, ba lệnh đầu tiên đã được sử dụng để đặt đầu ra được định dạng đúng.

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

Cuối cùng, bạn sẽ nhận được kết quả sau.

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

Nếu bạn chỉ muốn tìm nạp các trường đã chọn của bảng COMPANY, thì hãy sử dụng truy vấn sau:

sqlite> SELECT ID, NAME, SALARY FROM COMPANY;

Truy vấn trên sẽ tạo ra kết quả sau.

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

Đặt chiều rộng cột đầu ra

Đôi khi, bạn sẽ gặp sự cố liên quan đến đầu ra bị cắt ngắn trong trường hợp .mode columnđiều này xảy ra do chiều rộng mặc định của cột được hiển thị. Những gì bạn có thể làm là, bạn có thể đặt chiều rộng cột có thể hiển thị bằng cách sử dụng.width num, num.... lệnh như sau:

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

Trên .width lệnh đặt chiều rộng cột đầu tiên là 10, chiều rộng cột thứ hai là 20 và chiều rộng cột thứ ba là 10. Cuối cùng, câu lệnh SELECT ở trên sẽ cho kết quả như sau.

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

Thông tin lược đồ

Như tất cả dot commands có sẵn tại lời nhắc SQLite, do đó trong khi lập trình với SQLite, bạn sẽ sử dụng câu lệnh SELECT sau với sqlite_master bảng để liệt kê tất cả các bảng được tạo trong cơ sở dữ liệu của bạn.

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

Giả sử bạn chỉ có bảng COMPANY trong testDB.db của mình, điều này sẽ tạo ra kết quả sau.

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

Bạn có thể liệt kê đầy đủ thông tin về bảng COMPANY như sau:

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

Giả sử bạn chỉ có bảng COMPANY trong testDB.db của mình, điều này sẽ tạo ra kết quả sau.

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

Toán tử trong SQLite là gì?

Toán tử là một từ dành riêng hoặc một ký tự được sử dụng chủ yếu trong mệnh đề WHERE của câu lệnh SQLite để thực hiện (các) hoạt động, chẳng hạn như so sánh và các phép toán số học.

Các toán tử được sử dụng để chỉ định các điều kiện trong một câu lệnh SQLite và dùng như các liên từ cho nhiều điều kiện trong một câu lệnh.

Toán tử số học
Toán tử so sánh
Toán tử logic
Toán tử bitwise

Toán tử số học SQLite

Giả sử biến a giữ 10 và biến b giữ 20, sau đó các toán tử số học SQLite sẽ được sử dụng như sau:

Hiển thị các ví dụ

Nhà điều hành	Sự miêu tả	Thí dụ
+ (Bổ sung)	Thêm các giá trị ở hai bên của toán tử	a + b sẽ cho 30
- (Phép trừ)	Trừ toán hạng bên phải khỏi toán hạng bên trái	a - b sẽ cho -10
* (Phép nhân)	Nhân các giá trị ở hai bên của toán tử	a * b sẽ cho 200
/ (Bộ phận)	Chia toán hạng bên trái cho toán hạng bên phải	b / a sẽ cho 2
% (Mô-đun)	Chia toán hạng bên trái cho toán hạng bên phải và trả về phần còn lại	b% a sẽ cho 0

Toán tử so sánh SQLite

Giả sử biến a giữ 10 và biến b giữ 20, sau đó các toán tử so sánh SQLite sẽ được sử dụng như sau

Hiển thị các ví dụ

Nhà điều hành	Sự miêu tả	Thí dụ
==	Kiểm tra xem giá trị của hai toán hạng có bằng nhau hay không, nếu có thì điều kiện trở thành true.	(a == b) không đúng.
=	Kiểm tra xem giá trị của hai toán hạng có bằng nhau hay không, nếu có thì điều kiện trở thành true.	(a = b) không đúng.
! =	Kiểm tra xem giá trị của hai toán hạng có bằng nhau hay không, nếu các giá trị không bằng nhau thì điều kiện trở thành true.	(a! = b) là đúng.
<>	Kiểm tra xem giá trị của hai toán hạng có bằng nhau hay không, nếu các giá trị không bằng nhau thì điều kiện trở thành true.	(a <> b) là đúng.
>	Kiểm tra xem giá trị của toán hạng bên trái có lớn hơn giá trị của toán hạng bên phải hay không, nếu có thì điều kiện trở thành true.	(a> b) không đúng.
<	Kiểm tra xem giá trị của toán hạng bên trái có nhỏ hơn giá trị của toán hạng bên phải hay không, nếu có thì điều kiện trở thành true.	(a <b) là đúng.
> =	Kiểm tra xem giá trị của toán hạng bên trái có lớn hơn hoặc bằng giá trị của toán hạng bên phải hay không, nếu có thì điều kiện trở thành true.	(a> = b) không đúng.
<=	Kiểm tra xem giá trị của toán hạng bên trái có nhỏ hơn hoặc bằng giá trị của toán hạng bên phải hay không, nếu có thì điều kiện trở thành true.	(a <= b) là đúng.
! <	Kiểm tra xem giá trị của toán hạng bên trái có nhỏ hơn giá trị của toán hạng bên phải hay không, nếu có thì điều kiện trở thành true.	(a! <b) là false.
!>	Kiểm tra nếu giá trị của toán hạng bên trái không lớn hơn giá trị của toán hạng bên phải, nếu có thì điều kiện trở thành true.	(a!> b) là đúng.

Toán tử lôgic SQLite

Đây là danh sách tất cả các toán tử logic có sẵn trong SQLite.

Hiển thị các ví dụ

Sr.No.	Nhà điều hành & Mô tả
1	AND Toán tử AND cho phép tồn tại nhiều điều kiện trong mệnh đề WHERE của câu lệnh SQL.
2	BETWEEN Toán tử BETWEEN được sử dụng để tìm kiếm các giá trị nằm trong một bộ giá trị, cho giá trị nhỏ nhất và giá trị lớn nhất.
3	EXISTS Toán tử EXISTS được sử dụng để tìm kiếm sự hiện diện của một hàng trong một bảng được chỉ định đáp ứng các tiêu chí nhất định.
4	IN Toán tử IN được sử dụng để so sánh một giá trị với danh sách các giá trị theo nghĩa đen đã được chỉ định.
5	NOT IN Sự phủ định của toán tử IN được sử dụng để so sánh một giá trị với một danh sách các giá trị theo nghĩa đen đã được chỉ định.
6	LIKE Toán tử LIKE được sử dụng để so sánh một giá trị với các giá trị tương tự bằng cách sử dụng các toán tử ký tự đại diện.
7	GLOB Toán tử GLOB được sử dụng để so sánh một giá trị với các giá trị tương tự bằng cách sử dụng các toán tử ký tự đại diện. Ngoài ra, GLOB phân biệt chữ hoa chữ thường, không giống như LIKE.
số 8	NOT Toán tử NOT đảo ngược ý nghĩa của toán tử logic mà nó được sử dụng. Ví dụ. KHÔNG TỒN TẠI, KHÔNG GIỮA, KHÔNG VÀO, v.v.This is negate operator.
9	OR Toán tử OR được sử dụng để kết hợp nhiều điều kiện trong mệnh đề WHERE của câu lệnh SQL.
10	IS NULL Toán tử NULL được sử dụng để so sánh một giá trị với một giá trị NULL.
11	IS Toán tử IS hoạt động giống như =
12	IS NOT Toán tử IS hoạt động như thế nào! =
13	\|\| Thêm hai chuỗi khác nhau và tạo một chuỗi mới.
14	UNIQUE Toán tử UNIQUE tìm kiếm mọi hàng của một bảng được chỉ định để tìm tính duy nhất (không trùng lặp).

Toán tử SQLite Bitwise

Toán tử bitwise hoạt động trên các bit và thực hiện hoạt động từng bit. Sau đây là bảng sự thật cho& và |.

p	q	p & q	p \| q
0	0	0	0
0	1	0	1
1	1	1	1
1	0	0	1

Giả sử nếu A= 60; vàB = 13, thì ở định dạng nhị phân, chúng sẽ như sau:

A = 0011 1100

B = 0000 1101

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

A&B = 0000 1100

A | B = 0011 1101

~ A = 1100 0011

Các toán tử Bitwise được ngôn ngữ SQLite hỗ trợ được liệt kê trong bảng sau. Giả sử biếnA giữ 60 và biến B giữ 13, sau đó -

Hiển thị các ví dụ

Nhà điều hành	Sự miêu tả	Thí dụ
&	Toán tử Binary AND sao chép một bit vào kết quả, nếu nó tồn tại trong cả hai toán hạng.	(A & B) sẽ cho kết quả 12 là 0000 1100
\|	Toán tử OR nhị phân sao chép một bit, nếu nó tồn tại trong một trong hai toán hạng.	(A \| B) sẽ cho 61 là 0011 1101
~	Toán tử bổ sung số nhị phân là một ngôi và có tác dụng 'lật' các bit.	(~ A) sẽ cho -61 là 1100 0011 ở dạng bổ sung của 2 do một số nhị phân có dấu
<<	Toán tử dịch chuyển trái nhị phân. Giá trị toán hạng bên trái được di chuyển sang trái bằng số bit được chỉ định bởi toán hạng bên phải.	A << 2 sẽ cho 240 là 1111 0000
>>	Toán tử Shift phải nhị phân. Giá trị của toán hạng bên trái được di chuyển sang phải bằng số bit được chỉ định bởi toán hạng bên phải.	A >> 2 sẽ cho 15 là 0000 1111

Một biểu thức là sự kết hợp của một hoặc nhiều giá trị, toán tử và hàm SQL đánh giá thành một giá trị.

Biểu thức SQL giống như công thức và chúng được viết bằng ngôn ngữ truy vấn. Bạn cũng có thể sử dụng để truy vấn cơ sở dữ liệu cho một tập dữ liệu cụ thể.

Cú pháp

Hãy xem xét cú pháp cơ bản của câu lệnh SELECT như sau:

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

Sau đây là các loại biểu thức SQLite khác nhau.

SQLite - Biểu thức Boolean

Biểu thức Boolean trong SQLite tìm nạp dữ liệu trên cơ sở đối sánh giá trị đơn lẻ. Sau đây là cú pháp:

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

Xem xét bảng COMPANY với các bản ghi sau:

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

Sau đây là một ví dụ đơn giản cho thấy việc sử dụng Biểu thức Boolean trong SQLite:

sqlite> SELECT * FROM COMPANY WHERE SALARY = 10000;

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

SQLite - Biểu thức số

Các biểu thức này được sử dụng để thực hiện bất kỳ phép toán nào trong bất kỳ truy vấn nào. Sau đây là cú pháp:

SELECT numerical_expression as OPERATION_NAME
[FROM table_name WHERE CONDITION] ;

Ở đây, biểu thức số được sử dụng cho biểu thức toán học hoặc bất kỳ công thức nào. Sau đây là một ví dụ đơn giản cho thấy việc sử dụng Biểu thức số SQLite.

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

Có một số chức năng tích hợp như avg(), sum(), count(), v.v., để thực hiện những gì được gọi là aggregate data calculations chống lại một bảng hoặc một cột bảng cụ thể.

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

SQLite - Biểu thức ngày

Biểu thức ngày trả về giá trị ngày và giờ hệ thống hiện tại. Các biểu thức này được sử dụng trong các thao tác dữ liệu khác nhau.

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

SQLite WHERE mệnh đề được sử dụng để chỉ định một điều kiện trong khi tìm nạp dữ liệu từ một bảng hoặc nhiều bảng.

Nếu điều kiện đã cho được thỏa mãn, nghĩa là đúng, thì nó trả về giá trị cụ thể từ bảng. Bạn sẽ phải sử dụng mệnh đề WHERE để lọc các bản ghi và chỉ tìm nạp các bản ghi cần thiết.

Mệnh đề WHERE không chỉ được sử dụng trong câu lệnh SELECT mà còn được sử dụng trong câu lệnh UPDATE, DELETE, v.v., sẽ được đề cập trong các chương tiếp theo.

Cú pháp

Sau đây là cú pháp cơ bản của câu lệnh SQLite SELECT với mệnh đề WHERE.

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

Thí dụ

Bạn có thể chỉ định một điều kiện bằng cách sử dụng Toán tử so sánh hoặc logic như>, <, =, LIKE, NOT, v.v. Hãy xem xét bảng COMPANY với các bản ghi sau:

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

Sau đây là một ví dụ đơn giản cho thấy việc sử dụng các toán tử logic của SQLite. Sau câu lệnh SELECT liệt kê tất cả các bản ghi có AGE lớn hơn hoặc bằng 25AND lương lớn hơn hoặc bằng 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

Sau câu lệnh SELECT liệt kê tất cả các bản ghi có AGE lớn hơn hoặc bằng 25 OR lương lớn hơn hoặc bằng 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

Sau câu lệnh SELECT liệt kê tất cả các bản ghi mà AGE không phải là NULL, có nghĩa là tất cả các bản ghi vì không bản ghi nào có AGE bằng 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

Câu lệnh SELECT sau liệt kê tất cả các bản ghi mà NAME bắt đầu bằng 'Ki', không quan trọng những gì đến sau 'Ki'.

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

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

Câu lệnh SELECT sau liệt kê tất cả các bản ghi mà NAME bắt đầu bằng 'Ki', không quan trọng những gì đến sau 'Ki'.

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

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

Sau câu lệnh SELECT liệt kê tất cả các bản ghi có giá trị AGE là 25 hoặc 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

Sau câu lệnh SELECT liệt kê tất cả các bản ghi có giá trị AGE không phải là 25 hoặc 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

Câu lệnh SELECT sau đây liệt kê tất cả các bản ghi có giá trị AGE nằm ở GIỮA 25 VÀ 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

Câu lệnh SELECT sau sử dụng truy vấn phụ SQL, trong đó truy vấn phụ tìm thấy tất cả các bản ghi có trường AGE có SALARY> 65000 và mệnh đề WHERE sau đó đang được sử dụng cùng với toán tử EXISTS để liệt kê tất cả các bản ghi có AGE từ truy vấn bên ngoài tồn tại trong kết quả trả về bởi truy vấn phụ -

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

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

Câu lệnh SELECT sau sử dụng truy vấn phụ SQL trong đó truy vấn phụ tìm thấy tất cả các bản ghi có trường AGE có SALARY> 65000 và mệnh đề WHERE sau đó đang được sử dụng cùng với toán tử> để liệt kê tất cả các bản ghi có AGE từ truy vấn bên ngoài lớn hơn so với tuổi trong kết quả được trả về bởi truy vấn phụ.

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 & ORtoán tử được sử dụng để biên dịch nhiều điều kiện để thu hẹp dữ liệu đã chọn trong một câu lệnh SQLite. Hai toán tử này được gọi làconjunctive operators.

Các toán tử này cung cấp một phương tiện để thực hiện nhiều phép so sánh với các toán tử khác nhau trong cùng một câu lệnh SQLite.

Toán tử AND

Các ANDtoán tử cho phép tồn tại nhiều điều kiện trong mệnh đề WHERE của câu lệnh SQLite. Trong khi sử dụng toán tử AND, điều kiện hoàn thành sẽ được giả định đúng khi tất cả các điều kiện đều đúng. Ví dụ: [condition1] AND [condition2] sẽ chỉ đúng khi cả condition1 và condition2 đều đúng.

Cú pháp

Sau đây là cú pháp cơ bản của toán tử AND với mệnh đề WHERE.

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

Bạn có thể kết hợp Nsố lượng điều kiện sử dụng toán tử AND. Đối với một hành động được thực hiện bởi câu lệnh SQLite, cho dù đó là một giao dịch hay truy vấn, tất cả các điều kiện được phân tách bởi AND phải là TRUE.

Thí dụ

Xem xét bảng COMPANY với các bản ghi sau:

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

Sau câu lệnh SELECT liệt kê tất cả các bản ghi có AGE lớn hơn hoặc bằng 25 AND lương lớn hơn hoặc bằng 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

Toán tử HOẶC

Toán tử OR cũng được sử dụng để kết hợp nhiều điều kiện trong mệnh đề WHERE của câu lệnh SQLite. Trong khi sử dụng toán tử OR, điều kiện hoàn thành sẽ được giả định đúng khi ít nhất bất kỳ điều kiện nào là đúng. Ví dụ: [condition1] OR [condition2] sẽ đúng nếu condition1 hoặc condition2 là đúng.

Cú pháp

Sau đây là cú pháp cơ bản của toán tử OR với mệnh đề WHERE.

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

Bạn có thể kết hợp Nsố điều kiện sử dụng toán tử OR. Đối với một hành động được thực hiện bởi câu lệnh SQLite, cho dù đó là một giao dịch hay truy vấn, chỉ bất kỳ MỘT trong các điều kiện được phân tách bằng OR phải là TRUE.

Thí dụ

Hãy xem xét bảng COMPANY với các bản ghi sau đây.

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

Sau câu lệnh SELECT liệt kê tất cả các bản ghi có AGE lớn hơn hoặc bằng 25 OR lương lớn hơn hoặc bằng 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 UPDATETruy vấn được sử dụng để sửa đổi các bản ghi hiện có trong bảng. Bạn có thể sử dụng mệnh đề WHERE với truy vấn UPDATE để cập nhật các hàng đã chọn, nếu không tất cả các hàng sẽ được cập nhật.

Cú pháp

Sau đây là cú pháp cơ bản của truy vấn UPDATE với mệnh đề WHERE.

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

Bạn có thể kết hợp N số lượng điều kiện sử dụng toán tử AND hoặc OR.

Thí dụ

Xem xét bảng COMPANY với các bản ghi sau:

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

Sau đây là một ví dụ, sẽ cập nhật ĐỊA CHỈ cho khách hàng có ID là 6.

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

Bây giờ, bảng COMPANY sẽ có các bản ghi sau.

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

Nếu bạn muốn sửa đổi tất cả các giá trị cột ĐỊA CHỈ và LƯƠNG trong bảng CÔNG TY, bạn không cần sử dụng mệnh đề WHERE và truy vấn CẬP NHẬT sẽ như sau:

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

Bây giờ, bảng COMPANY sẽ có các bản ghi sau:

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 DELETETruy vấn được sử dụng để xóa các bản ghi hiện có khỏi bảng. Bạn có thể sử dụng mệnh đề WHERE với truy vấn DELETE để xóa các hàng đã chọn, nếu không tất cả các bản ghi sẽ bị xóa.

Cú pháp

Sau đây là cú pháp cơ bản của truy vấn DELETE với mệnh đề WHERE.

DELETE FROM table_name
WHERE [condition];

Bạn có thể kết hợp N số lượng điều kiện sử dụng toán tử AND hoặc OR.

Thí dụ

Hãy xem xét bảng COMPANY với các bản ghi sau đây.

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

Sau đây là một ví dụ, sẽ XÓA một khách hàng có ID là 7.

sqlite> DELETE FROM COMPANY WHERE ID = 7;

Bây giờ bảng COMPANY sẽ có các bản ghi sau.

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

Nếu bạn muốn XÓA tất cả các bản ghi khỏi bảng CÔNG TY, bạn không cần sử dụng mệnh đề WHERE với truy vấn XÓA, mệnh đề này sẽ như sau:

sqlite> DELETE FROM COMPANY;

Bây giờ, bảng COMPANY không có bất kỳ bản ghi nào vì tất cả các bản ghi đã bị xóa bởi câu lệnh DELETE.

SQLite LIKEtoán tử được sử dụng để so khớp các giá trị văn bản với một mẫu bằng cách sử dụng ký tự đại diện. Nếu biểu thức tìm kiếm có thể được so khớp với biểu thức mẫu, toán tử LIKE sẽ trả về true, là 1. Có hai ký tự đại diện được sử dụng cùng với toán tử LIKE -

Dấu phần trăm (%)
Dấu gạch dưới (_)

Dấu phần trăm đại diện cho không, một hoặc nhiều số hoặc ký tự. Dấu gạch dưới thể hiện một số hoặc một ký tự. Các ký hiệu này có thể được sử dụng trong các tổ hợp.

Cú pháp

Sau đây là cú pháp cơ bản của% và _.

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_'

Bạn có thể kết hợp Nsố lượng điều kiện sử dụng toán tử AND hoặc OR. Ở đây, XXXX có thể là bất kỳ giá trị số hoặc chuỗi nào.

Thí dụ

Bảng sau liệt kê một số ví dụ cho thấy phần WHERE có mệnh đề LIKE khác nhau với các toán tử '%' và '_'.

Sr.No.	Tuyên bố & Mô tả
1	WHERE SALARY LIKE '200%' Tìm bất kỳ giá trị nào bắt đầu bằng 200
2	WHERE SALARY LIKE '%200%' Tìm bất kỳ giá trị nào có 200 ở bất kỳ vị trí nào
3	WHERE SALARY LIKE '_00%' Tìm bất kỳ giá trị nào có 00 ở vị trí thứ hai và thứ ba
4	WHERE SALARY LIKE '2_%_%' Tìm bất kỳ giá trị nào bắt đầu bằng 2 và có độ dài ít nhất 3 ký tự
5	WHERE SALARY LIKE '%2' Tìm bất kỳ giá trị nào kết thúc bằng 2
6	WHERE SALARY LIKE '_2%3' Tìm bất kỳ giá trị nào có số 2 ở vị trí thứ hai và kết thúc bằng số 3
7	WHERE SALARY LIKE '2___3' Tìm bất kỳ giá trị nào trong một số có năm chữ số bắt đầu bằng 2 và kết thúc bằng 3

Chúng ta hãy lấy một ví dụ thực tế, hãy xem xét bảng COMPANY với các bản ghi sau.

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

Sau đây là một ví dụ, sẽ hiển thị tất cả các bản ghi từ bảng COMPANY trong đó AGE bắt đầu bằng 2.

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

Điều này sẽ tạo ra kết quả sau.

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

Sau đây là một ví dụ, sẽ hiển thị tất cả các bản ghi từ bảng COMPANY trong đó ADDRESS sẽ có dấu gạch ngang (-) bên trong văn bản.

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

Điều này sẽ tạo ra kết quả sau.

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

SQLite GLOBtoán tử chỉ được sử dụng để đối sánh các giá trị văn bản với một mẫu sử dụng ký tự đại diện. Nếu biểu thức tìm kiếm có thể được so khớp với biểu thức mẫu, toán tử GLOB sẽ trả về true, là 1. Không giống như toán tử LIKE, GLOB phân biệt chữ hoa chữ thường và nó tuân theo cú pháp của UNIX để chỉ định các ký tự đại diện sau.

Dấu hoa thị (*)
Dấu chấm hỏi (?)

Dấu hoa thị (*) thể hiện số không hoặc nhiều số hoặc ký tự. Dấu chấm hỏi (?) Đại diện cho một số hoặc một ký tự.

Cú pháp

Sau đây là cú pháp cơ bản của * và ?.

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 '????'

Bạn có thể kết hợp Nsố lượng điều kiện sử dụng toán tử AND hoặc OR. Ở đây, XXXX có thể là bất kỳ giá trị số hoặc chuỗi nào.

Thí dụ

Bảng sau liệt kê một số ví dụ cho thấy phần WHERE có mệnh đề LIKE khác với '*' và '?' các toán tử.

Sr.No.	Tuyên bố & Mô tả
1	*WHERE SALARY GLOB '200'** Tìm bất kỳ giá trị nào bắt đầu bằng 200
2	*WHERE SALARY GLOB '200'* Tìm bất kỳ giá trị nào có 200 ở bất kỳ vị trí nào
3	*WHERE SALARY GLOB '?00'** Tìm bất kỳ giá trị nào có 00 ở vị trí thứ hai và thứ ba
4	WHERE SALARY GLOB '2??' Tìm bất kỳ giá trị nào bắt đầu bằng 2 và có độ dài ít nhất 3 ký tự
5	*WHERE SALARY GLOB '2'** Tìm bất kỳ giá trị nào kết thúc bằng 2
6	*WHERE SALARY GLOB '?23'** Tìm bất kỳ giá trị nào có số 2 ở vị trí thứ hai và kết thúc bằng số 3
7	WHERE SALARY GLOB '2???3' Tìm bất kỳ giá trị nào trong một số có năm chữ số bắt đầu bằng 2 và kết thúc bằng 3

Hãy để chúng tôi lấy một ví dụ thực tế, hãy xem xét bảng COMPANY với các bản ghi sau:

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

Sau đây là một ví dụ, sẽ hiển thị tất cả các bản ghi từ bảng COMPANY, trong đó AGE bắt đầu bằng 2.

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

Điều này sẽ tạo ra kết quả sau.

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

Sau đây là một ví dụ, sẽ hiển thị tất cả các bản ghi từ bảng COMPANY trong đó ADDRESS sẽ có dấu gạch ngang (-) bên trong văn bản -

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

Điều này sẽ tạo ra kết quả sau.

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

SQLite LIMIT mệnh đề được sử dụng để giới hạn lượng dữ liệu được trả về bởi câu lệnh SELECT.

Cú pháp

Sau đây là cú pháp cơ bản của câu lệnh SELECT với mệnh đề LIMIT.

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

Sau đây là cú pháp của mệnh đề LIMIT khi nó được sử dụng cùng với mệnh đề OFFSET.

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

Công cụ SQLite sẽ trả về các hàng bắt đầu từ hàng tiếp theo đến OFFSET đã cho như được hiển thị bên dưới trong ví dụ cuối cùng.

Thí dụ

Xem xét bảng COMPANY với các bản ghi sau:

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

Sau đây là một ví dụ, giới hạn hàng trong bảng theo số hàng bạn muốn lấy từ bảng.

sqlite> SELECT * FROM COMPANY LIMIT 6;

Điều này sẽ tạo ra kết quả sau.

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

Tuy nhiên, trong một số tình huống nhất định, bạn có thể cần chọn một tập hợp các bản ghi từ một khoảng chênh lệch cụ thể. Đây là một ví dụ, chọn 3 bản ghi bắt đầu từ vị trí ^thứ 3 .

sqlite> SELECT * FROM COMPANY LIMIT 3 OFFSET 2;

Điều này sẽ tạo ra kết quả sau.

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 mệnh đề được sử dụng để sắp xếp dữ liệu theo thứ tự tăng dần hoặc giảm dần, dựa trên một hoặc nhiều cột.

Cú pháp

Sau đây là cú pháp cơ bản của mệnh đề ORDER BY.

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

Bạn có thể sử dụng nhiều cột trong mệnh đề ORDER BY. Đảm bảo rằng bất kỳ cột nào bạn đang sử dụng để sắp xếp, cột đó sẽ có sẵn trong danh sách cột.

Thí dụ

Hãy xem xét bảng COMPANY với các bản ghi sau đây.

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

Sau đây là một ví dụ, sẽ sắp xếp kết quả theo thứ tự giảm dần theo LƯƠNG.

sqlite> SELECT * FROM COMPANY ORDER BY SALARY ASC;

Điều này sẽ tạo ra kết quả sau.

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

Sau đây là một ví dụ, sẽ sắp xếp kết quả theo thứ tự giảm dần theo TÊN và LƯƠNG.

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

Điều này sẽ tạo ra kết quả sau.

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

Sau đây là một ví dụ, sẽ sắp xếp kết quả theo thứ tự giảm dần theo NAME.

sqlite> SELECT * FROM COMPANY ORDER BY NAME DESC;

Điều này sẽ tạo ra kết quả sau.

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 mệnh đề được sử dụng phối hợp với câu lệnh SELECT để sắp xếp dữ liệu giống nhau thành các nhóm.

Mệnh đề GROUP BY theo sau mệnh đề WHERE trong câu lệnh SELECT và đứng trước mệnh đề ORDER BY.

Cú pháp

Sau đây là cú pháp cơ bản của mệnh đề GROUP BY. Mệnh đề GROUP BY phải tuân theo các điều kiện trong mệnh đề WHERE và phải đứng trước mệnh đề ORDER BY nếu được sử dụng.

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

Bạn có thể sử dụng nhiều hơn một cột trong mệnh đề GROUP BY. Đảm bảo rằng bất kỳ cột nào bạn đang sử dụng để nhóm, cột đó sẽ có sẵn trong danh sách cột.

Thí dụ

Hãy xem xét bảng COMPANY với các bản ghi sau đây.

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

Nếu bạn muốn biết tổng số tiền lương của mỗi khách hàng, thì truy vấn GROUP BY sẽ như sau:

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

Điều này sẽ tạo ra kết quả sau:

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

Bây giờ, chúng ta hãy tạo thêm ba bản ghi trong bảng COMPANY bằng cách sử dụng các câu lệnh INSERT sau.

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 );

Bây giờ, bảng của chúng tôi có các bản ghi sau với tên trùng lặp.

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

Một lần nữa, chúng ta hãy sử dụng cùng một câu lệnh để nhóm theo tất cả các bản ghi bằng cột NAME như sau:

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

Điều này sẽ tạo ra kết quả sau.

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

Hãy để chúng tôi sử dụng mệnh đề ORDER BY cùng với mệnh đề GROUP BY như sau:

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

Điều này sẽ tạo ra kết quả sau.

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

Mệnh đề HAVING cho phép bạn chỉ định các điều kiện lọc kết quả nhóm nào xuất hiện trong kết quả cuối cùng.

Mệnh đề WHERE đặt điều kiện vào các cột đã chọn, trong khi mệnh đề HAVING đặt điều kiện cho các nhóm được tạo bởi mệnh đề GROUP BY.

Cú pháp

Sau đây là vị trí của mệnh đề HAVING trong một truy vấn SELECT.

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

Mệnh đề HAVING phải theo sau mệnh đề GROUP BY trong một truy vấn và cũng phải đứng trước mệnh đề ORDER BY nếu được sử dụng. Sau đây là cú pháp của câu lệnh SELECT, bao gồm mệnh đề HAVING.

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

Thí dụ

Hãy xem xét bảng COMPANY với các bản ghi sau đây.

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

Sau đây là ví dụ, sẽ hiển thị bản ghi có số lượng tên nhỏ hơn 2.

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

Điều này sẽ tạo ra kết quả sau.

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

Sau đây là ví dụ, sẽ hiển thị bản ghi có số lượng tên lớn hơn 2.

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

Điều này sẽ tạo ra kết quả sau.

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

SQLite DISTINCT từ khóa được sử dụng cùng với câu lệnh SELECT để loại bỏ tất cả các bản ghi trùng lặp và chỉ tìm nạp các bản ghi duy nhất.

Có thể có một tình huống khi bạn có nhiều bản ghi trùng lặp trong một bảng. Trong khi tìm nạp các bản ghi như vậy, sẽ hợp lý hơn nếu chỉ tìm nạp các bản ghi duy nhất thay vì tìm nạp các bản ghi trùng lặp.

Cú pháp

Sau đây là cú pháp cơ bản của từ khóa DISTINCT để loại bỏ các bản ghi trùng lặp.

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

Thí dụ

Hãy xem xét bảng COMPANY với các bản ghi sau đây.

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

Trước tiên, hãy xem cách truy vấn SELECT sau đây trả về các bản ghi lương trùng lặp.

sqlite> SELECT name FROM COMPANY;

Điều này sẽ tạo ra kết quả sau.

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

Bây giờ, hãy để chúng tôi sử dụng DISTINCT từ khóa với truy vấn SELECT ở trên và xem kết quả.

sqlite> SELECT DISTINCT name FROM COMPANY;

Điều này sẽ tạo ra kết quả sau, nơi không có mục nhập trùng lặp.

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

SQLite PRAGMAlệnh là một lệnh đặc biệt được sử dụng để điều khiển các biến môi trường và cờ trạng thái khác nhau trong môi trường SQLite. Giá trị PRAGMA có thể được đọc và nó cũng có thể được đặt dựa trên các yêu cầu.

Cú pháp

Để truy vấn giá trị PRAGMA hiện tại, chỉ cần cung cấp tên của pragma.

PRAGMA pragma_name;

Để đặt giá trị mới cho PRAGMA, hãy sử dụng cú pháp sau.

PRAGMA pragma_name = value;

Chế độ đặt có thể là tên hoặc số nguyên tương đương nhưng giá trị trả về sẽ luôn là số nguyên.

auto_vacuum Pragma

Các auto_vacuumpragma nhận hoặc đặt chế độ tự động hút bụi. Sau đây là cú pháp đơn giản.

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

Ở đâu mode có thể là bất kỳ điều nào sau đây -

Sr.No.	Giá trị & Mô tả Pragma
1	0 or NONE Tính năng hút bụi tự động bị tắt. Đây là chế độ mặc định có nghĩa là tệp cơ sở dữ liệu sẽ không bao giờ thu nhỏ kích thước trừ khi nó được hút chân không theo cách thủ công bằng lệnh VACUUM.
2	1 or FULL Tự động hút chân không được bật và hoàn toàn tự động cho phép tệp cơ sở dữ liệu thu nhỏ khi dữ liệu bị xóa khỏi cơ sở dữ liệu.
3	2 or INCREMENTAL Tự động hút chân không được bật nhưng phải được kích hoạt bằng tay. Trong chế độ này, dữ liệu tham chiếu được duy trì, nhưng các trang miễn phí chỉ được đưa vào danh sách miễn phí. Các trang này có thể được khôi phục bằng cách sử dụngincremental_vacuum pragma Bất cứ lúc nào.

cache_size Pragma

Các cache_sizepragma có thể lấy hoặc tạm thời đặt kích thước tối đa của bộ nhớ đệm trang trong bộ nhớ. Sau đây là cú pháp đơn giản.

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

Các pagesgiá trị đại diện cho số trang trong bộ nhớ cache. Bộ đệm trang tích hợp có kích thước mặc định là 2.000 trang và kích thước tối thiểu là 10 trang.

case_sensitive_like Pragma

Các case_sensitive_likepragma kiểm soát độ phân biệt chữ hoa chữ thường của biểu thức LIKE tích hợp sẵn. Theo mặc định, pragma này là false, có nghĩa là toán tử LIKE tích hợp bỏ qua chữ cái. Sau đây là cú pháp đơn giản.

PRAGMA case_sensitive_like = [true|false];

Không có cách nào để truy vấn trạng thái hiện tại của pragma này.

count_changes Pragma

count_changespragma nhận hoặc đặt giá trị trả về của các câu lệnh thao tác dữ liệu như INSERT, UPDATE và DELETE. Sau đây là cú pháp đơn giản.

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

Theo mặc định, pragma này là false và các câu lệnh này không trả về bất cứ điều gì. Nếu được đặt thành true, mỗi câu lệnh được đề cập sẽ trả về bảng một cột, một hàng bao gồm một giá trị số nguyên duy nhất cho biết các hàng bị tác động bởi thao tác.

database_list Pragma

Các database_listpragma sẽ được sử dụng để liệt kê tất cả các cơ sở dữ liệu được đính kèm. Sau đây là cú pháp đơn giản.

PRAGMA database_list;

Pragma này sẽ trả về một bảng ba cột với một hàng cho mỗi cơ sở dữ liệu đang mở hoặc được đính kèm với số thứ tự cơ sở dữ liệu, tên của nó và tệp được liên kết.

mã hóa Pragma

Các encodingpragma kiểm soát cách chuỗi được mã hóa và lưu trữ trong tệp cơ sở dữ liệu. Sau đây là cú pháp đơn giản.

PRAGMA encoding;
PRAGMA encoding = format;

Giá trị định dạng có thể là một trong số UTF-8, UTF-16le, hoặc là UTF-16be.

freelist_count Pragma

Các freelist_countpragma trả về một số nguyên duy nhất cho biết có bao nhiêu trang cơ sở dữ liệu hiện được đánh dấu là miễn phí và khả dụng. Sau đây là cú pháp đơn giản.

PRAGMA [database.]freelist_count;

Giá trị định dạng có thể là một trong số UTF-8, UTF-16le, hoặc là UTF-16be.

index_info Pragma

Các index_infopragma trả về thông tin về chỉ mục cơ sở dữ liệu. Sau đây là cú pháp đơn giản.

PRAGMA [database.]index_info( index_name );

Tập hợp kết quả sẽ chứa một hàng cho mỗi cột chứa trong chỉ mục cung cấp trình tự cột, chỉ số cột với bảng và tên cột.

index_list Pragma

index_listpragma liệt kê tất cả các chỉ mục được liên kết với một bảng. Sau đây là cú pháp đơn giản.

PRAGMA [database.]index_list( table_name );

Tập kết quả sẽ chứa một hàng cho mỗi chỉ mục cung cấp chuỗi chỉ mục, tên chỉ mục và cờ cho biết chỉ mục có phải là duy nhất hay không.

Journal_mode Pragma

Các journal_modepragma nhận hoặc đặt chế độ nhật ký kiểm soát cách tệp nhật ký được lưu trữ và xử lý. Sau đây là cú pháp đơn giản.

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

Có năm chế độ nhật ký được hỗ trợ như được liệt kê trong bảng sau.

Sr.No.	Giá trị & Mô tả Pragma
1	DELETE Đây là chế độ mặc định. Tại đây khi kết thúc một giao dịch, tệp nhật ký sẽ bị xóa.
2	TRUNCATE Tệp nhật ký được cắt bớt độ dài bằng 0 byte.
3	PERSIST Tệp tạp chí được giữ nguyên, nhưng tiêu đề bị ghi đè để cho biết tạp chí không còn hợp lệ.
4	MEMORY Bản ghi nhật ký được lưu trong bộ nhớ chứ không phải trên đĩa.
5	OFF Không có hồ sơ nhật ký nào được lưu giữ.

max_page_count Pragma

Các max_page_countpragma nhận hoặc đặt số lượng trang tối đa được phép cho cơ sở dữ liệu. Sau đây là cú pháp đơn giản.

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

Giá trị mặc định là 1,073,741,823, là một giga-page, có nghĩa là nếu kích thước trang mặc định 1 KB, điều này cho phép cơ sở dữ liệu phát triển lên đến một terabyte.

page_count Pragma

Các page_countpragma trả về số trang hiện tại trong cơ sở dữ liệu. Sau đây là cú pháp đơn giản:

PRAGMA [database.]page_count;

Kích thước của tệp cơ sở dữ liệu phải là page_count * page_size.

page_size Pragma

Các page_sizepragma nhận hoặc đặt kích thước của các trang cơ sở dữ liệu. Sau đây là cú pháp đơn giản.

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

Theo mặc định, các kích thước được phép là 512, 1024, 2048, 4096, 8192, 16384 và 32768 byte. Cách duy nhất để thay đổi kích thước trang trên cơ sở dữ liệu hiện có là đặt kích thước trang và sau đó VACUUM ngay lập tức cơ sở dữ liệu.

parser_trace Pragma

Các parser_tracepragma kiểm soát việc in trạng thái gỡ lỗi khi nó phân tích cú pháp các lệnh SQL. Sau đây là cú pháp đơn giản.

PRAGMA parser_trace = [true|false];

Theo mặc định, nó được đặt thành false nhưng khi được kích hoạt bằng cách đặt nó thành true, trình phân tích cú pháp SQL sẽ in trạng thái của nó khi nó phân tích các lệnh SQL.

recursive_triggers Pragma

Các recursive_triggerspragma nhận hoặc đặt chức năng kích hoạt đệ quy. Nếu trình kích hoạt đệ quy không được bật, một hành động kích hoạt sẽ không kích hoạt một trình kích hoạt khác. Sau đây là cú pháp đơn giản.

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

schema_version Pragma

Các schema_versionpragma nhận hoặc đặt giá trị phiên bản lược đồ được lưu trữ trong tiêu đề cơ sở dữ liệu. Sau đây là cú pháp đơn giản.

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

Đây là một giá trị số nguyên có dấu 32-bit để theo dõi các thay đổi của giản đồ. Bất cứ khi nào một lệnh thay đổi lược đồ được thực thi (như, CREATE ... hoặc DROP ...), giá trị này sẽ tăng lên.

secure_delete Pragma

Các secure_deletepragma được sử dụng để kiểm soát cách nội dung bị xóa khỏi cơ sở dữ liệu. Sau đây là cú pháp đơn giản.

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

Giá trị mặc định cho cờ xóa an toàn thường bị tắt, nhưng điều này có thể được thay đổi với tùy chọn xây dựng SQLITE_SECURE_DELETE.

sql_trace Pragma

Các sql_tracepragma được sử dụng để kết xuất các kết quả theo dõi SQL ra màn hình. Sau đây là cú pháp đơn giản.

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

SQLite phải được biên dịch với chỉ thị SQLITE_DEBUG để đưa pragma này vào.

Pragma đồng bộ

Các synchronouspragma nhận hoặc đặt chế độ đồng bộ hóa đĩa hiện tại, chế độ này kiểm soát mức độ mạnh mẽ của SQLite sẽ ghi dữ liệu vào bộ nhớ vật lý. Sau đây là cú pháp đơn giản.

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

SQLite hỗ trợ các chế độ đồng bộ hóa sau như được liệt kê trong bảng.

Sr.No.	Giá trị & Mô tả Pragma
1	0 or OFF Không có đồng bộ hóa nào cả
2	1 or NORMAL Đồng bộ hóa sau mỗi chuỗi hoạt động đĩa quan trọng
3	2 or FULL Đồng bộ hóa sau mỗi lần vận hành đĩa quan trọng

temp_store Pragma

Các temp_storepragma nhận hoặc đặt chế độ lưu trữ được sử dụng bởi các tệp cơ sở dữ liệu tạm thời. Sau đây là cú pháp đơn giản.

PRAGMA temp_store;
PRAGMA temp_store = mode;

SQLite hỗ trợ các chế độ lưu trữ sau.

Sr.No.	Giá trị & Mô tả Pragma
1	0 or DEFAULT Sử dụng mặc định thời gian biên dịch. Thông thường FILE.
2	1 or FILE Sử dụng lưu trữ dựa trên tệp.
3	2 or MEMORY Sử dụng lưu trữ dựa trên bộ nhớ.

temp_store_directory Pragma

Các temp_store_directorypragma nhận hoặc đặt vị trí được sử dụng cho các tệp cơ sở dữ liệu tạm thời. Sau đây là cú pháp đơn giản.

PRAGMA temp_store_directory;
PRAGMA temp_store_directory = 'directory_path';

user_version Pragma

Các user_versionpragma nhận hoặc đặt giá trị phiên bản do người dùng xác định được lưu trữ trong tiêu đề cơ sở dữ liệu. Sau đây là cú pháp đơn giản.

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

Đây là giá trị số nguyên có dấu 32 bit, có thể được nhà phát triển đặt cho mục đích theo dõi phiên bản.

writeable_schema Pragma

Các writable_schemapragma nhận hoặc thiết lập khả năng sửa đổi các bảng hệ thống. Sau đây là cú pháp đơn giản.

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

Nếu pragma này được đặt, các bảng bắt đầu bằng sqlite_ có thể được tạo và sửa đổi, bao gồm cả bảng sqlite_master. Hãy cẩn thận khi sử dụng pragma vì nó có thể dẫn đến hỏng toàn bộ cơ sở dữ liệu.

Ràng buộc là các quy tắc được thực thi trên một cột dữ liệu trên bảng. Chúng được sử dụng để giới hạn loại dữ liệu có thể đi vào bảng. Điều này đảm bảo tính chính xác và độ tin cậy của dữ liệu trong cơ sở dữ liệu.

Các ràng buộc có thể là cấp cột hoặc cấp bảng. Các ràng buộc mức cột chỉ được áp dụng cho một cột, trong khi các ràng buộc mức bảng được áp dụng cho toàn bộ bảng.

Sau đây là các ràng buộc thường được sử dụng có sẵn trong SQLite.

NOT NULL Constraint - Đảm bảo rằng một cột không thể có giá trị NULL.
DEFAULT Constraint - Cung cấp giá trị mặc định cho một cột khi không có cột nào được chỉ định.
UNIQUE Constraint - Đảm bảo rằng tất cả các giá trị trong một cột là khác nhau.
PRIMARY Key - Nhận dạng duy nhất từng hàng / bản ghi trong bảng cơ sở dữ liệu.
CHECK Constraint - Đảm bảo rằng tất cả các giá trị trong một cột thỏa mãn các điều kiện nhất định.

Ràng buộc KHÔNG ĐẦY ĐỦ

Theo mặc định, một cột có thể chứa giá trị NULL. Nếu bạn không muốn một cột có giá trị NULL, thì bạn cần xác định ràng buộc như vậy trên cột này, xác định rằng NULL bây giờ không được phép cho cột đó.

NULL không giống như không có dữ liệu, đúng hơn, nó đại diện cho dữ liệu không xác định.

Thí dụ

Ví dụ: câu lệnh SQLite sau tạo một bảng mới có tên là COMPANY và thêm năm cột, ba trong số đó, ID và NAME và AGE, chỉ định không chấp nhận NULL.

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

Ràng buộc DEFAULT

Ràng buộc DEFAULT cung cấp giá trị mặc định cho một cột khi câu lệnh INSERT INTO không cung cấp giá trị cụ thể.

Thí dụ

Ví dụ: câu lệnh SQLite sau đây tạo một bảng mới có tên là COMPANY và thêm năm cột. Ở đây, cột LƯƠNG được đặt thành 5000,00 theo mặc định, do đó trong trường hợp câu lệnh INSERT INTO không cung cấp giá trị cho cột này, thì theo mặc định, cột này sẽ được đặt thành 5000,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
);

Hạn chế duy nhất

Ràng buộc DUY NHẤT ngăn hai bản ghi có các giá trị giống nhau trong một cột cụ thể. Ví dụ: trong bảng COMPANY, bạn có thể muốn ngăn hai hoặc nhiều người có độ tuổi giống nhau.

Thí dụ

Ví dụ: câu lệnh SQLite sau đây tạo một bảng mới có tên là COMPANY và thêm năm cột. Ở đây, cột TUỔI được đặt thành DUY NHẤT, do đó bạn không thể có hai bản ghi có cùng độ tuổi -

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
);

Ràng buộc CHÍNH CHÍNH

Ràng buộc PRIMARY KEY xác định duy nhất từng bản ghi trong bảng cơ sở dữ liệu. Có thể có nhiều cột DUY NHẤT, nhưng chỉ có một khóa chính trong bảng. Khóa chính rất quan trọng khi thiết kế bảng cơ sở dữ liệu. Khóa chính là ID duy nhất.

Chúng tôi sử dụng chúng để tham chiếu đến các hàng trong bảng. Khóa chính trở thành khóa ngoại trong các bảng khác, khi tạo quan hệ giữa các bảng. Do 'giám sát mã hóa lâu đời', khóa chính có thể là NULL trong SQLite. Đây không phải là trường hợp của các cơ sở dữ liệu khác.

Khóa chính là một trường trong bảng xác định duy nhất từng hàng / bản ghi trong bảng cơ sở dữ liệu. Khóa chính phải chứa các giá trị duy nhất. Một cột khóa chính không được có giá trị NULL.

Một bảng chỉ có thể có một khóa chính, có thể bao gồm một hoặc nhiều trường. Khi nhiều trường được sử dụng làm khóa chính, chúng được gọi làcomposite key.

Nếu một bảng có khóa chính được xác định trên (các) trường bất kỳ, thì bạn không thể có hai bản ghi có cùng giá trị của (các) trường đó.

Thí dụ

Bạn đã thấy nhiều ví dụ khác nhau ở trên trong đó chúng tôi đã tạo bảng COMPANY với ID làm khóa chính.

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

Ràng buộc KIỂM TRA

Ràng buộc CHECK cho phép một điều kiện để kiểm tra giá trị đang được nhập vào bản ghi. Nếu điều kiện đánh giá là false, bản ghi vi phạm ràng buộc và không được nhập vào bảng.

Thí dụ

Ví dụ: SQLite sau đây tạo một bảng mới có tên là COMPANY và thêm năm cột. Ở đây, chúng tôi thêm cột KIỂM TRA với LƯƠNG, để bạn không thể có bất kỳ Số không có LƯƠNG nào.

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)
);

Ràng buộc bỏ qua

SQLite hỗ trợ một tập hợp con giới hạn của ALTER TABLE. Lệnh ALTER TABLE trong SQLite cho phép người dùng đổi tên bảng hoặc thêm cột mới vào bảng hiện có. Không thể đổi tên cột, xóa cột hoặc thêm hoặc xóa các ràng buộc khỏi bảng.

SQLite Joinsmệnh đề được sử dụng để kết hợp các bản ghi từ hai hoặc nhiều bảng trong cơ sở dữ liệu. JOIN là một phương tiện để kết hợp các trường từ hai bảng bằng cách sử dụng các giá trị chung cho mỗi bảng.

SQL định nghĩa ba kiểu nối chính:

THAM GIA CROSS
THAM GIA INNER
THAM GIA NGOÀI TRỜI

Trước khi tiếp tục, chúng ta hãy xem xét hai bảng COMPANY và DEPARTMENT. Chúng ta đã thấy các câu lệnh INSERT để điền vào bảng COMPANY. Vì vậy, hãy giả sử danh sách các bản ghi có sẵn trong bảng 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

Một bảng khác là DEPARTMENT với định nghĩa sau:

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

Đây là danh sách các câu lệnh INSERT để điền vào bảng 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 );

Cuối cùng, chúng tôi có danh sách các bản ghi sau có sẵn trong bảng DEPARTMENT -

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

THAM GIA CROSS

CROSS JOIN khớp mọi hàng của bảng đầu tiên với mọi hàng của bảng thứ hai. Nếu bảng đầu vào có hàng x và hàng y tương ứng, bảng kết quả sẽ có hàng x * y. Vì các CROSS JOIN có khả năng tạo ra các bảng cực kỳ lớn, nên phải cẩn thận để chỉ sử dụng chúng khi thích hợp.

Sau đây là cú pháp của CROSS JOIN:

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

Dựa trên các bảng trên, bạn có thể viết CROSS JOIN như sau:

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

Truy vấn trên sẽ tạo ra kết quả sau:

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

THAM GIA INNER

INNER JOIN tạo một bảng kết quả mới bằng cách kết hợp các giá trị cột của hai bảng (table1 và table2) dựa trên vị từ nối. Truy vấn so sánh từng hàng của bảng1 với từng hàng của bảng2 để tìm tất cả các cặp hàng thỏa mãn vị từ nối. Khi vị từ nối được thỏa mãn, các giá trị cột cho mỗi cặp hàng A và B đã so khớp được kết hợp thành một hàng kết quả.

INNER JOIN là kiểu tham gia mặc định và phổ biến nhất. Bạn có thể sử dụng từ khóa INNER tùy ý.

Sau đây là cú pháp của INNER JOIN:

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

Để tránh dư thừa và giữ cho cụm từ ngắn hơn, điều kiện INNER JOIN có thể được khai báo bằng USINGbiểu hiện. Biểu thức này chỉ định một danh sách gồm một hoặc nhiều cột.

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

NATURAL JOIN tương tự như một JOIN...USING, chỉ nó tự động kiểm tra sự bình đẳng giữa các giá trị của mọi cột tồn tại trong cả hai bảng -

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

Dựa trên các bảng trên, bạn có thể viết INNER JOIN như sau:

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

Truy vấn trên sẽ tạo ra kết quả sau:

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

THAM GIA NGOÀI TRỜI

OUTER JOIN là một phần mở rộng của INNER JOIN. Mặc dù tiêu chuẩn SQL định nghĩa ba loại THAM GIA NGOÀI RA: LEFT, RIGHT và FULL, SQLite chỉ hỗ trợLEFT OUTER JOIN.

OUTER JOIN có một điều kiện giống với INNER JOIN, được biểu thị bằng từ khóa ON, USING hoặc NATURAL. Bảng kết quả ban đầu được tính theo cách tương tự. Sau khi phép tính JOIN chính, một OUTER JOIN sẽ lấy bất kỳ hàng không liên kết nào từ một hoặc cả hai bảng, đệm chúng bằng NULL và nối chúng vào bảng kết quả.

Sau đây là cú pháp của LEFT OUTER JOIN -

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

Để tránh dư thừa và giữ cho cụm từ ngắn hơn, điều kiện OUTER JOIN có thể được khai báo bằng biểu thức USING. Biểu thức này chỉ định một danh sách gồm một hoặc nhiều cột.

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

Dựa trên các bảng trên, bạn có thể viết một phép nối bên trong như sau:

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

Truy vấn trên sẽ tạo ra kết quả sau:

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

SQLite UNION mệnh đề / toán tử được sử dụng để kết hợp các kết quả của hai hoặc nhiều câu lệnh SELECT mà không trả về bất kỳ hàng trùng lặp nào.

Để sử dụng UNION, mỗi SELECT phải có cùng số cột được chọn, cùng số biểu thức cột, cùng kiểu dữ liệu và có cùng thứ tự, nhưng chúng không nhất thiết phải có cùng độ dài.

Cú pháp

Sau đây là cú pháp cơ bản của UNION.

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

UNION

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

Ở đây, điều kiện đã cho có thể là bất kỳ biểu thức nhất định nào dựa trên yêu cầu của bạn.

Thí dụ

Hãy xem xét hai bảng sau, (a) bảng COMPANY như sau:

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) Một bảng khác là DEPARTMENT như sau:

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

Bây giờ chúng ta hãy nối hai bảng này bằng cách sử dụng câu lệnh SELECT cùng với mệnh đề UNION như sau:

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;

Điều này sẽ tạo ra kết quả sau.

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

Mệnh đề UNION ALL

Toán tử UNION ALL được sử dụng để kết hợp các kết quả của hai câu lệnh SELECT bao gồm các hàng trùng lặp.

Các quy tắc tương tự áp dụng cho UNION cũng áp dụng cho nhà điều hành UNION ALL.

Cú pháp

Sau đây là cú pháp cơ bản của UNION ALL.

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

UNION ALL

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

Ở đây, điều kiện đã cho có thể là bất kỳ biểu thức nhất định nào dựa trên yêu cầu của bạn.

Thí dụ

Bây giờ, chúng ta hãy nối hai bảng được đề cập ở trên trong câu lệnh SELECT như sau:

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;

Điều này sẽ tạo ra kết quả sau.

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 NULLlà thuật ngữ được sử dụng để biểu thị một giá trị bị thiếu. Giá trị NULL trong bảng là giá trị trong trường có vẻ như là trống.

Trường có giá trị NULL là trường không có giá trị. Điều rất quan trọng là phải hiểu rằng giá trị NULL khác với giá trị 0 hoặc một trường có chứa khoảng trắng.

Cú pháp

Sau đây là cú pháp cơ bản của việc sử dụng NULL trong khi tạo bảng.

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

Đây, NOT NULLbiểu thị rằng cột phải luôn chấp nhận một giá trị rõ ràng của kiểu dữ liệu đã cho. Có hai cột mà chúng tôi không sử dụng NOT NULL có nghĩa là các cột này có thể là NULL.

Trường có giá trị NULL là trường đã bị bỏ trống trong quá trình tạo bản ghi.

Thí dụ

Giá trị NULL có thể gây ra vấn đề khi chọn dữ liệu, vì khi so sánh một giá trị chưa biết với bất kỳ giá trị nào khác, kết quả luôn không xác định và không được đưa vào kết quả cuối cùng. Hãy xem xét bảng sau đây, COMPANY với các bản ghi sau:

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

Chúng ta hãy sử dụng câu lệnh UPDATE để đặt một vài giá trị có thể nullable thành NULL như sau:

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

Bây giờ, bảng COMPANY sẽ có các bản ghi sau.

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

Tiếp theo, hãy để chúng tôi xem việc sử dụng IS NOT NULL toán tử để liệt kê tất cả các bản ghi mà SALARY không phải là NULL.

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

Câu lệnh SQLite trên sẽ tạo ra kết quả sau:

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

Sau đây là cách sử dụng IS NULL toán tử này sẽ liệt kê tất cả các bản ghi có SALARY là NULL.

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

Câu lệnh SQLite trên sẽ tạo ra kết quả sau.

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

Bạn có thể tạm thời đổi tên một bảng hoặc một cột bằng cách đặt một tên khác, được gọi là ALIAS. Việc sử dụng bí danh bảng có nghĩa là đổi tên bảng trong một câu lệnh SQLite cụ thể. Đổi tên là một thay đổi tạm thời và tên bảng thực tế không thay đổi trong cơ sở dữ liệu.

Bí danh cột được sử dụng để đổi tên các cột của bảng cho mục đích của một truy vấn SQLite cụ thể.

Cú pháp

Sau đây là cú pháp cơ bản của table bí danh.

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

Sau đây là cú pháp cơ bản của column bí danh.

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

Thí dụ

Hãy xem xét hai bảng sau, (a) bảng COMPANY như sau:

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) Một bảng khác là DEPARTMENT như sau:

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

Bây giờ, sau đây là cách sử dụng TABLE ALIAS trong đó chúng tôi sử dụng C và D làm bí danh cho các bảng COMPANY và DEPARTMENT tương ứng -

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

Câu lệnh SQLite trên sẽ tạo ra kết quả sau:

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

Hãy xem xét một ví dụ cho việc sử dụng COLUMN ALIAS trong đó COMPANY_ID là bí danh của cột ID và COMPANY_NAME là bí danh của cột tên.

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;

Câu lệnh SQLite trên sẽ tạo ra kết quả sau:

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 Triggerslà các hàm gọi lại cơ sở dữ liệu, được tự động thực hiện / gọi khi một sự kiện cơ sở dữ liệu cụ thể xảy ra. Sau đây là những điểm quan trọng về trình kích hoạt SQLite:

Trình kích hoạt SQLite có thể được chỉ định để kích hoạt bất cứ khi nào XÓA, CHÈN hoặc CẬP NHẬT của một bảng cơ sở dữ liệu cụ thể xảy ra hoặc bất cứ khi nào CẬP NHẬT xảy ra trên một hoặc nhiều cột được chỉ định của bảng.
Tại thời điểm này, SQLite chỉ hỗ trợ trình kích hoạt CHO MỖI ROW, không hỗ trợ trình kích hoạt CHO TỪNG THỐNG KÊ. Do đó, chỉ định rõ ràng CHO TỪNG ROW là tùy chọn.
Cả mệnh đề WHEN và các hành động kích hoạt đều có thể truy cập các phần tử của hàng đang được chèn, xóa hoặc cập nhật bằng cách sử dụng các tham chiếu của biểu mẫu NEW.column-name và OLD.column-name, trong đó tên-cột là tên của một cột từ bảng mà trình kích hoạt được liên kết với.
Nếu mệnh đề WHEN được cung cấp, các câu lệnh SQL được chỉ định chỉ được thực thi cho các hàng mà mệnh đề WHEN là đúng. Nếu không cung cấp mệnh đề WHEN, câu lệnh SQL được thực thi cho tất cả các hàng.
Từ khóa BEFORE hoặc AFTER xác định khi nào các hành động kích hoạt sẽ được thực hiện liên quan đến việc chèn, sửa đổi hoặc loại bỏ hàng được liên kết.
Trình kích hoạt sẽ tự động bị loại bỏ khi bảng liên kết với chúng bị loại bỏ.
Bảng được sửa đổi phải tồn tại trong cùng một cơ sở dữ liệu với bảng hoặc dạng xem mà trình kích hoạt được đính kèm và người ta phải sử dụng tablename không phải database.tablename.
Một hàm SQL đặc biệt RAISE () có thể được sử dụng trong một chương trình kích hoạt để đưa ra một ngoại lệ.

Cú pháp

Sau đây là cú pháp cơ bản để tạo trigger.

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

Đây, event_namecó thể là INSERT, DELETE và UPDATE cơ sở dữ liệu hoạt động trên bảng được đề cậptable_name. Bạn có thể tùy chọn chỉ định CHO TỪNG ROW sau tên bảng.

Sau đây là cú pháp để tạo trình kích hoạt trên thao tác CẬP NHẬT trên một hoặc nhiều cột được chỉ định của bảng.

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

Thí dụ

Chúng ta hãy xem xét một trường hợp mà chúng ta muốn tiếp tục kiểm tra thử cho mọi bản ghi đang được chèn vào bảng COMPANY, mà chúng ta tạo mới như sau (Bỏ bảng COMPANY nếu bạn đã có).

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

Để tiếp tục thử nghiệm kiểm toán, chúng tôi sẽ tạo một bảng mới có tên AUDIT nơi các thông báo nhật ký sẽ được chèn vào bất cứ khi nào có mục nhập trong bảng COMPANY cho một bản ghi mới.

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

Ở đây, ID là ID bản ghi AUDIT và EMP_ID là ID sẽ đến từ bảng COMPANY và DATE sẽ giữ dấu thời gian khi bản ghi sẽ được tạo trong bảng COMPANY. Bây giờ hãy tạo một trình kích hoạt trên bảng COMPANY như sau:

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

Bây giờ, chúng ta sẽ bắt đầu công việc thực tế, Hãy bắt đầu chèn bản ghi vào bảng COMPANY, điều này sẽ dẫn đến việc tạo bản ghi nhật ký kiểm toán trong bảng AUDIT. Tạo một bản ghi trong bảng COMPANY như sau:

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

Thao tác này sẽ tạo một bản ghi trong bảng COMPANY, như sau:

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

Đồng thời, một bản ghi sẽ được tạo trong bảng AUDIT. Bản ghi này là kết quả của một trình kích hoạt, mà chúng tôi đã tạo trên thao tác INSERT trong bảng COMPANY. Tương tự, bạn có thể tạo trình kích hoạt của mình trên các hoạt động CẬP NHẬT và XÓA dựa trên yêu cầu của bạn.

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

Trình kích hoạt danh sách

Bạn có thể liệt kê tất cả các trình kích hoạt từ sqlite_master bảng như sau -

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

Câu lệnh SQLite ở trên sẽ chỉ liệt kê một mục nhập như sau:

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

Nếu bạn muốn liệt kê các trình kích hoạt trên một bảng cụ thể, thì hãy sử dụng mệnh đề AND với tên bảng như sau:

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

Câu lệnh SQLite ở trên cũng sẽ chỉ liệt kê một mục nhập như sau:

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

Giảm kích hoạt

Sau đây là lệnh DROP, có thể được sử dụng để thả một trình kích hoạt hiện có.

sqlite> DROP TRIGGER trigger_name;

Chỉ mục là các bảng tra cứu đặc biệt mà công cụ tìm kiếm cơ sở dữ liệu có thể sử dụng để tăng tốc độ truy xuất dữ liệu. Nói một cách đơn giản, mộtindexlà một con trỏ tới dữ liệu trong bảng. Một chỉ mục trong cơ sở dữ liệu rất giống với một chỉ mục ở phía sau một cuốn sách.

Ví dụ: nếu bạn muốn tham chiếu đến tất cả các trang trong một cuốn sách thảo luận về một chủ đề nhất định, trước tiên bạn tham khảo chỉ mục, mục lục này liệt kê tất cả các chủ đề theo thứ tự bảng chữ cái và sau đó được tham chiếu đến một hoặc nhiều số trang cụ thể.

Một chỉ mục giúp tăng tốc các truy vấn SELECT và mệnh đề WHERE, nhưng nó làm chậm quá trình nhập dữ liệu, với các câu lệnh UPDATE và INSERT. Chỉ mục có thể được tạo hoặc giảm mà không ảnh hưởng đến dữ liệu.

Việc tạo chỉ mục bao gồm câu lệnh CREATE INDEX, cho phép bạn đặt tên cho chỉ mục, chỉ định bảng và cột hoặc các cột nào cần lập chỉ mục và cho biết chỉ mục theo thứ tự tăng dần hay giảm dần.

Các chỉ mục cũng có thể là duy nhất, tương tự như ràng buộc UNIQUE, trong đó chỉ mục ngăn các mục nhập trùng lặp trong cột hoặc tổ hợp các cột mà trên đó có chỉ mục.

Lệnh CREATE INDEX

Sau đây là cú pháp cơ bản của CREATE INDEX.

CREATE INDEX index_name ON table_name;

Chỉ mục một cột

Chỉ mục một cột là chỉ mục được tạo chỉ dựa trên một cột của bảng. Cú pháp cơ bản như sau:

CREATE INDEX index_name
ON table_name (column_name);

Chỉ mục duy nhất

Chỉ mục duy nhất không chỉ được sử dụng cho hiệu suất mà còn cho tính toàn vẹn của dữ liệu. Chỉ mục duy nhất không cho phép chèn bất kỳ giá trị trùng lặp nào vào bảng. Cú pháp cơ bản như sau:

CREATE UNIQUE INDEX index_name
on table_name (column_name);

Chỉ mục tổng hợp

Chỉ mục tổng hợp là một chỉ mục trên hai hoặc nhiều cột của bảng. Cú pháp cơ bản như sau:

CREATE INDEX index_name
on table_name (column1, column2);

Cho dù tạo chỉ mục cột đơn hay chỉ mục tổng hợp, hãy xem xét (các) cột mà bạn có thể sử dụng rất thường xuyên trong mệnh đề WHERE của truy vấn làm điều kiện lọc.

Nếu chỉ có một cột được sử dụng, chỉ mục một cột nên là lựa chọn. Nếu có hai hoặc nhiều cột thường được sử dụng trong mệnh đề WHERE làm bộ lọc, chỉ mục tổng hợp sẽ là lựa chọn tốt nhất.

Chỉ mục ngầm định

Chỉ mục ngầm định là chỉ mục được tạo tự động bởi máy chủ cơ sở dữ liệu khi một đối tượng được tạo. Chỉ mục được tạo tự động cho các ràng buộc khóa chính và các ràng buộc duy nhất.

Example

Dưới đây là một ví dụ mà chúng ta sẽ tạo một chỉ mục trong bảng COMPANY cho cột lương -

sqlite> CREATE INDEX salary_index ON COMPANY (salary);

Bây giờ, hãy liệt kê tất cả các chỉ số có sẵn trong bảng COMPANY bằng cách sử dụng .indices lệnh như sau:

sqlite> .indices COMPANY

Điều này sẽ tạo ra kết quả sau, trong đó sqlite_autoindex_COMPANY_1 là một chỉ mục ngầm định được tạo khi chính bảng được tạo.

salary_index
sqlite_autoindex_COMPANY_1

Bạn có thể liệt kê toàn bộ cơ sở dữ liệu chỉ mục như sau:

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

Lệnh DROP INDEX

Một chỉ mục có thể bị loại bỏ bằng cách sử dụng SQLite DROPchỉ huy. Cần cẩn thận khi giảm chỉ số vì hiệu suất có thể bị chậm lại hoặc được cải thiện.

Sau đây là cú pháp cơ bản như sau:

DROP INDEX index_name;

Bạn có thể sử dụng câu lệnh sau để xóa chỉ mục đã tạo trước đó.

sqlite> DROP INDEX salary_index;

Khi nào thì các chỉ mục nên được tránh?

Mặc dù các chỉ mục nhằm mục đích nâng cao hiệu suất của cơ sở dữ liệu, nhưng đôi khi chúng nên được tránh. Các hướng dẫn sau đây cho biết khi nào việc sử dụng một chỉ mục nên được xem xét lại.

Chỉ mục không nên được sử dụng trong -

Bàn nhỏ.
Các bảng có hoạt động cập nhật hoặc chèn hàng loạt lớn, thường xuyên.
Các cột chứa nhiều giá trị NULL.
Các cột được thao tác thường xuyên.

Mệnh đề "INDEXED BY index-name" chỉ định rằng chỉ mục được đặt tên phải được sử dụng để tra cứu các giá trị trên bảng trước.

Nếu tên-chỉ mục không tồn tại hoặc không thể được sử dụng cho truy vấn, thì việc chuẩn bị câu lệnh SQLite không thành công.

Mệnh đề "NOT INDEXED" quy định rằng không có chỉ mục nào sẽ được sử dụng khi truy cập bảng trước đó, bao gồm các chỉ số ngụ ý được tạo bởi các ràng buộc UNIQUE và PRIMARY KEY.

Tuy nhiên, KHÓA CHÍNH CỦA INTEGER vẫn có thể được sử dụng để tra cứu các mục nhập ngay cả khi "NOT INDEXED" được chỉ định.

Cú pháp

Sau đây là cú pháp cho mệnh đề INDEXED BY và nó có thể được sử dụng với câu lệnh DELETE, UPDATE hoặc SELECT.

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

Thí dụ

Xem xét bảng COMPANY Chúng tôi sẽ tạo một chỉ mục và sử dụng nó để thực hiện thao tác INDEXED BY.

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

Bây giờ chọn dữ liệu từ bảng COMPANY, bạn có thể sử dụng mệnh đề INDEXED BY như sau:

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

Điều này sẽ tạo ra kết quả sau.

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 TABLElệnh sửa đổi bảng hiện có mà không thực hiện kết xuất đầy đủ và tải lại dữ liệu. Bạn có thể đổi tên bảng bằng câu lệnh ALTER TABLE và có thể thêm các cột bổ sung vào bảng hiện có bằng câu lệnh ALTER TABLE.

Không có hoạt động nào khác được hỗ trợ bởi lệnh ALTER TABLE trong SQLite ngoại trừ đổi tên bảng và thêm cột trong bảng hiện có.

Cú pháp

Sau đây là cú pháp cơ bản của ALTER TABLE để RENAME một bảng hiện có.

ALTER TABLE database_name.table_name RENAME TO new_table_name;

Sau đây là cú pháp cơ bản của ALTER TABLE để thêm một cột mới trong bảng hiện có.

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

Thí dụ

Hãy xem xét bảng COMPANY với các bản ghi sau:

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ây giờ, hãy thử đổi tên bảng này bằng cách sử dụng câu lệnh ALTER TABLE như sau:

sqlite> ALTER TABLE COMPANY RENAME TO OLD_COMPANY;

Câu lệnh SQLite trên sẽ đổi tên bảng COMPANY thành OLD_COMPANY. Bây giờ, hãy thử thêm một cột mới trong bảng OLD_COMPANY như sau:

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

Bảng COMPANY hiện đã được thay đổi và sau đây sẽ là kết quả từ câu lệnh 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

Cần lưu ý rằng cột mới được thêm vào chứa các giá trị NULL.

Rất tiếc, chúng tôi không có lệnh TRUNCATE TABLE trong SQLite nhưng bạn có thể sử dụng SQLite DELETE lệnh xóa dữ liệu hoàn chỉnh khỏi bảng hiện có, mặc dù bạn nên sử dụng lệnh DROP TABLE để xóa bảng hoàn chỉnh và tạo lại một lần nữa.

Cú pháp

Sau đây là cú pháp cơ bản của lệnh DELETE.

sqlite> DELETE FROM table_name;

Sau đây là cú pháp cơ bản của DROP TABLE.

sqlite> DROP TABLE table_name;

Nếu bạn đang sử dụng lệnh DELETE TABLE để xóa tất cả các bản ghi, bạn nên sử dụng VACUUM lệnh xóa không gian không sử dụng.

Thí dụ

Hãy xem xét bảng COMPANY với các bản ghi sau đây.

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

Sau đây là ví dụ để cắt ngắn bảng trên:

SQLite> DELETE FROM COMPANY;
SQLite> VACUUM;

Bây giờ, bảng COMPANY đã được cắt ngắn hoàn toàn và không có gì sẽ là đầu ra từ câu lệnh SELECT.

Một khung nhìn không gì khác hơn là một câu lệnh SQLite được lưu trữ trong cơ sở dữ liệu với một tên liên quan. Nó thực sự là một thành phần của một bảng dưới dạng một truy vấn SQLite được xác định trước.

Một dạng xem có thể chứa tất cả các hàng của bảng hoặc các hàng được chọn từ một hoặc nhiều bảng. Một dạng xem có thể được tạo từ một hoặc nhiều bảng phụ thuộc vào truy vấn SQLite đã viết để tạo dạng xem.

Chế độ xem là một loại bảng ảo, cho phép người dùng -

Cấu trúc dữ liệu theo cách mà người dùng hoặc lớp người dùng thấy tự nhiên hoặc trực quan.
Hạn chế quyền truy cập vào dữ liệu để người dùng chỉ có thể xem dữ liệu hạn chế thay vì một bảng hoàn chỉnh.
Tổng hợp dữ liệu từ các bảng khác nhau, có thể được sử dụng để tạo báo cáo.

Dạng xem SQLite là dạng chỉ đọc và do đó bạn có thể không thực hiện được câu lệnh DELETE, INSERT hoặc UPDATE trên một dạng xem. Tuy nhiên, bạn có thể tạo trình kích hoạt trên một dạng xem kích hoạt khi cố gắng XÓA, CHÈN hoặc CẬP NHẬT một dạng xem và thực hiện những gì bạn cần trong phần thân của trình kích hoạt.

Tạo chế độ xem

Dạng xem SQLite được tạo bằng cách sử dụng CREATE VIEWtuyên bố. Dạng xem SQLite có thể được tạo từ một bảng, nhiều bảng hoặc một dạng xem khác.

Sau đây là cú pháp CREATE VIEW cơ bản.

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

Bạn có thể bao gồm nhiều bảng trong câu lệnh SELECT của mình theo cách tương tự như khi bạn sử dụng chúng trong một truy vấn SQL SELECT thông thường. Nếu có từ khóa TEMP hoặc TEMPORARY tùy chọn, dạng xem sẽ được tạo trong cơ sở dữ liệu tạm thời.

Thí dụ

Xem xét bảng COMPANY với các bản ghi sau:

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

Sau đây là một ví dụ để tạo một dạng xem từ bảng COMPANY. Chế độ xem này sẽ được sử dụng để chỉ có một vài cột từ bảng COMPANY.

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

Giờ đây, bạn có thể truy vấn COMPANY_VIEW theo cách tương tự như khi bạn truy vấn một bảng thực tế. Sau đây là một ví dụ -

sqlite> SELECT * FROM COMPANY_VIEW;

Điều này sẽ tạo ra kết quả sau.

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

Giảm lượt xem

Để bỏ một chế độ xem, chỉ cần sử dụng câu lệnh DROP VIEW với view_name. Cú pháp DROP VIEW cơ bản như sau:

sqlite> DROP VIEW view_name;

Lệnh sau sẽ xóa chế độ xem COMPANY_VIEW mà chúng ta đã tạo trong phần trước.

sqlite> DROP VIEW COMPANY_VIEW;

Giao dịch là một đơn vị công việc được thực hiện dựa trên cơ sở dữ liệu. Giao dịch là các đơn vị hoặc chuỗi công việc được thực hiện theo một thứ tự logic, cho dù theo cách thủ công bởi người dùng hay tự động bởi một số loại chương trình cơ sở dữ liệu.

Giao dịch là sự truyền bá một hoặc nhiều thay đổi đối với cơ sở dữ liệu. Ví dụ: nếu bạn đang tạo, cập nhật hoặc xóa bản ghi khỏi bảng, thì bạn đang thực hiện giao dịch trên bảng. Điều quan trọng là kiểm soát các giao dịch để đảm bảo tính toàn vẹn của dữ liệu và xử lý các lỗi cơ sở dữ liệu.

Trên thực tế, bạn sẽ kết hợp nhiều truy vấn SQLite thành một nhóm và bạn sẽ thực hiện tất cả chúng cùng nhau như một phần của giao dịch.

Thuộc tính của giao dịch

Giao dịch có bốn thuộc tính tiêu chuẩn sau đây, thường được gọi bằng từ viết tắt ACID.

Atomicity- Đảm bảo rằng tất cả các hoạt động trong đơn vị công việc được hoàn thành thành công; nếu không, giao dịch bị hủy bỏ tại điểm không thành công và các hoạt động trước đó được khôi phục lại trạng thái cũ của chúng.
Consistency - Đảm bảo rằng cơ sở dữ liệu thay đổi đúng trạng thái khi giao dịch được cam kết thành công.
Isolation - Cho phép các giao dịch hoạt động độc lập và minh bạch với nhau.
Durability - Đảm bảo rằng kết quả hoặc hiệu lực của giao dịch đã cam kết vẫn tồn tại trong trường hợp hệ thống bị lỗi.

Kiểm soát giao dịch

Sau đây là các lệnh sau được sử dụng để kiểm soát các giao dịch:

BEGIN TRANSACTION - Để bắt đầu giao dịch.
COMMIT - Để lưu các thay đổi, bạn có thể sử dụng END TRANSACTION chỉ huy.
ROLLBACK - Để khôi phục các thay đổi.

Các lệnh điều khiển giao dịch chỉ được sử dụng với các lệnh DML INSERT, UPDATE và DELETE. Chúng không thể được sử dụng trong khi tạo bảng hoặc bỏ chúng vì các hoạt động này được tự động cam kết trong cơ sở dữ liệu.

BEGIN TRANSACTION Command

Có thể bắt đầu giao dịch bằng BEGIN TRANSACTION hoặc đơn giản là lệnh BEGIN. Các giao dịch như vậy thường tồn tại cho đến khi gặp lệnh COMMIT hoặc ROLLBACK tiếp theo. Tuy nhiên, một giao dịch cũng sẽ ROLLBACK nếu cơ sở dữ liệu bị đóng hoặc nếu xảy ra lỗi. Sau đây là cú pháp đơn giản để bắt đầu một giao dịch.

BEGIN;
or 
BEGIN TRANSACTION;

Lệnh COMMIT

Lệnh COMMIT là lệnh giao dịch được sử dụng để lưu các thay đổi được gọi bởi một giao dịch vào cơ sở dữ liệu.

Lệnh COMMIT lưu tất cả các giao dịch vào cơ sở dữ liệu kể từ lệnh COMMIT hoặc ROLLBACK cuối cùng.

Sau đây là cú pháp cho lệnh COMMIT.

COMMIT;
or
END TRANSACTION;

Lệnh ROLLBACK

Lệnh ROLLBACK là lệnh giao dịch được sử dụng để hoàn tác các giao dịch chưa được lưu vào cơ sở dữ liệu.

Lệnh ROLLBACK chỉ có thể được sử dụng để hoàn tác các giao dịch kể từ khi lệnh COMMIT hoặc ROLLBACK cuối cùng được phát hành.

Sau đây là cú pháp cho lệnh ROLLBACK.

ROLLBACK;

Example

Hãy xem xét bảng COMPANY với các bản ghi sau đây.

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ây giờ, hãy bắt đầu một giao dịch và xóa các bản ghi khỏi bảng có age = 25. Sau đó, sử dụng lệnh ROLLBACK để hoàn tác tất cả các thay đổi.

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> ROLLBACK;

Bây giờ, nếu bạn kiểm tra bảng COMPANY, nó vẫn có các bản ghi sau:

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

Hãy bắt đầu một giao dịch khác và xóa các bản ghi khỏi bảng có age = 25 và cuối cùng chúng ta sử dụng lệnh COMMIT để cam kết tất cả các thay đổi.

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> COMMIT;

Nếu bây giờ bạn kiểm tra bảng CÔNG TY vẫn còn các bản ghi sau:

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

Truy vấn con hoặc Truy vấn bên trong hoặc Truy vấn lồng nhau là một truy vấn bên trong một truy vấn SQLite khác và được nhúng trong mệnh đề WHERE.

Một truy vấn con được sử dụng để trả về dữ liệu sẽ được sử dụng trong truy vấn chính như một điều kiện để hạn chế hơn nữa dữ liệu được truy xuất.

Truy vấn con có thể được sử dụng với các câu lệnh SELECT, INSERT, UPDATE và DELETE cùng với các toán tử như =, <,>,> =, <=, IN, BETWEEN, v.v.

Có một số quy tắc mà các truy vấn con phải tuân theo:

Truy vấn con phải được đặt trong dấu ngoặc đơn.
Một truy vấn con chỉ có thể có một cột trong mệnh đề SELECT, trừ khi có nhiều cột trong truy vấn chính để truy vấn con so sánh các cột đã chọn của nó.
Không thể sử dụng ORDER BY trong truy vấn phụ, mặc dù truy vấn chính có thể sử dụng ORDER BY. GROUP BY có thể được sử dụng để thực hiện chức năng tương tự như ORDER BY trong một truy vấn con.
Truy vấn con trả về nhiều hơn một hàng chỉ có thể được sử dụng với nhiều toán tử giá trị, chẳng hạn như toán tử IN.
Toán tử BETWEEN không thể được sử dụng với một truy vấn con; tuy nhiên, BETWEEN có thể được sử dụng trong truy vấn con.

Truy vấn con với Câu lệnh SELECT

Truy vấn con được sử dụng thường xuyên nhất với câu lệnh SELECT. Cú pháp cơ bản như sau:

SELECT column_name [, column_name ]
FROM table1 [, table2 ]
WHERE column_name OPERATOR
   (SELECT column_name [, column_name ]
      FROM table1 [, table2 ]
      [WHERE])

Thí dụ

Hãy xem xét bảng COMPANY với các bản ghi sau đây.

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ây giờ, chúng ta hãy kiểm tra truy vấn con sau với câu lệnh SELECT.

sqlite> SELECT * 
   FROM COMPANY 
   WHERE ID IN (SELECT ID 
      FROM COMPANY 
      WHERE SALARY > 45000) ;

Điều này sẽ tạo ra kết quả sau.

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

Truy vấn con với câu lệnh INSERT

Truy vấn con cũng có thể được sử dụng với câu lệnh INSERT. Câu lệnh INSERT sử dụng dữ liệu trả về từ truy vấn con để chèn vào một bảng khác. Dữ liệu đã chọn trong truy vấn con có thể được sửa đổi bằng bất kỳ hàm ký tự, ngày tháng hoặc số nào.

Sau đây là cú pháp cơ bản như sau:

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

Thí dụ

Hãy xem xét một bảng COMPANY_BKP có cấu trúc tương tự như bảng COMPANY và có thể được tạo bằng cách sử dụng cùng một BẢNG TẠO bằng cách sử dụng COMPANY_BKP làm tên bảng. Để sao chép bảng COMPANY hoàn chỉnh vào COMPANY_BKP, sau đây là cú pháp:

sqlite> INSERT INTO COMPANY_BKP
   SELECT * FROM COMPANY 
   WHERE ID IN (SELECT ID 
      FROM COMPANY) ;

Truy vấn phụ với Tuyên bố CẬP NHẬT

Truy vấn con có thể được sử dụng cùng với câu lệnh UPDATE. Có thể cập nhật một hoặc nhiều cột trong bảng khi sử dụng truy vấn con với câu lệnh UPDATE.

Sau đây là cú pháp cơ bản như sau:

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
      FROM TABLE_NAME)
   [ WHERE) ]

Thí dụ

Giả sử, chúng ta có sẵn bảng COMPANY_BKP, đây là bản sao lưu của bảng COMPANY.

Ví dụ sau cập nhật LƯƠNG gấp 0,50 lần trong bảng CÔNG TY cho tất cả khách hàng có TUỔI lớn hơn hoặc bằng 27.

sqlite> UPDATE COMPANY
   SET SALARY = SALARY * 0.50
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
      WHERE AGE >= 27 );

Điều này sẽ ảnh hưởng đến hai hàng và cuối cùng bảng COMPANY sẽ có các bản ghi sau:

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

Truy vấn con với Tuyên bố DELETE

Truy vấn con có thể được sử dụng cùng với câu lệnh DELETE giống như bất kỳ câu lệnh nào khác được đề cập ở trên.

Sau đây là cú pháp cơ bản như sau:

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
      FROM TABLE_NAME)
   [ WHERE) ]

Thí dụ

Giả sử, chúng ta có sẵn bảng COMPANY_BKP, đây là bản sao lưu của bảng COMPANY.

Ví dụ sau đây xóa các bản ghi khỏi bảng COMPANY cho tất cả các khách hàng có AGE lớn hơn hoặc bằng 27.

sqlite> DELETE FROM COMPANY
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
   WHERE AGE > 27 );

Điều này sẽ ảnh hưởng đến hai hàng và cuối cùng bảng COMPANY sẽ có các bản ghi sau:

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 AUTOINCREMENTlà một từ khóa được sử dụng để tự động tăng giá trị của một trường trong bảng. Chúng tôi có thể tự động tăng giá trị trường bằng cách sử dụngAUTOINCREMENT từ khóa khi tạo bảng với tên cột cụ thể để tăng tự động.

Từ khóa AUTOINCREMENT chỉ có thể được sử dụng với trường INTEGER.

Cú pháp

Cách sử dụng cơ bản của AUTOINCREMENT từ khóa như sau -

CREATE TABLE table_name(
   column1 INTEGER AUTOINCREMENT,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

Thí dụ

Hãy xem xét bảng COMPANY sẽ được tạo như sau:

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

Bây giờ, hãy chèn các bản ghi sau vào bảng 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 );

Điều này sẽ chèn 7 bộ giá trị vào bảng COMPANY và COMPANY sẽ có các bản ghi sau:

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

Nếu bạn lấy thông tin đầu vào của người dùng thông qua một trang web và chèn nó vào cơ sở dữ liệu SQLite, có khả năng bạn đã để ngỏ cho mình một vấn đề bảo mật được gọi là SQL Injection. Trong chương này, bạn sẽ học cách giúp ngăn điều này xảy ra và giúp bạn bảo mật các tập lệnh và câu lệnh SQLite của mình.

Injection thường xảy ra khi bạn yêu cầu người dùng nhập vào, như tên của họ, và thay vì tên, họ cung cấp cho bạn một câu lệnh SQLite mà bạn sẽ vô tình chạy trên cơ sở dữ liệu của mình.

Không bao giờ tin tưởng dữ liệu do người dùng cung cấp, chỉ xử lý dữ liệu này sau khi xác nhận; như một quy luật, điều này được thực hiện bằng cách đối sánh mẫu. Trong ví dụ sau, tên người dùng bị hạn chế đối với các ký tự chữ và số cộng với dấu gạch dưới và có độ dài từ 8 đến 20 ký tự - hãy sửa đổi các quy tắc này nếu cần.

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";
}

Để chứng minh vấn đề, hãy xem đoạn trích này -

$name = "Qadir'; DELETE FROM users;";
@$db->query("SELECT * FROM users WHERE username = '{$name}'");

Lời gọi hàm được cho là lấy một bản ghi từ bảng người dùng trong đó cột tên khớp với tên do người dùng chỉ định. Trong những trường hợp bình thường,$namesẽ chỉ chứa các ký tự chữ và số và có thể là khoảng trắng, chẳng hạn như chuỗi ilia. Tuy nhiên trong trường hợp này, bằng cách thêm một truy vấn hoàn toàn mới vào $ name, lệnh gọi đến cơ sở dữ liệu sẽ trở thành một thảm họa: truy vấn DELETE được đưa vào sẽ xóa tất cả các bản ghi khỏi người dùng.

Có những giao diện cơ sở dữ liệu không cho phép xếp chồng truy vấn hoặc thực thi nhiều truy vấn trong một lệnh gọi hàm duy nhất. Nếu bạn cố gắng xếp chồng các truy vấn, cuộc gọi không thành công nhưng SQLite và PostgreSQL, vui vẻ thực hiện các truy vấn xếp chồng, thực thi tất cả các truy vấn được cung cấp trong một chuỗi và tạo ra một vấn đề bảo mật nghiêm trọng.

Ngăn chặn SQL Injection

Bạn có thể xử lý tất cả các ký tự thoát một cách thông minh bằng các ngôn ngữ lập trình như PERL và PHP. Ngôn ngữ lập trình PHP cung cấp chức năngstring sqlite_escape_string() để thoát các ký tự đầu vào đặc biệt đối với SQLite.

if (get_magic_quotes_gpc()) {
   $name = sqlite_escape_string($name);
}
$result = @$db->query("SELECT * FROM users WHERE username = '{$name}'");

Mặc dù mã hóa giúp chèn dữ liệu an toàn, nhưng nó sẽ hiển thị các so sánh văn bản đơn giản và LIKE các mệnh đề trong truy vấn của bạn không thể sử dụng được cho các cột chứa dữ liệu nhị phân.

Note - addslashes()KHÔNG được sử dụng để trích dẫn các chuỗi của bạn cho các truy vấn SQLite; nó sẽ dẫn đến kết quả lạ khi lấy dữ liệu của bạn.

Câu lệnh SQLite có thể được đặt trước từ khóa "EXPLAIN" hoặc bởi cụm từ "EXPLAIN QUERY PLAN" được sử dụng để mô tả chi tiết của bảng.

Một trong hai sửa đổi khiến câu lệnh SQLite hoạt động như một truy vấn và trả về thông tin về cách câu lệnh SQLite sẽ hoạt động nếu từ khóa hoặc cụm từ EXPLAIN bị bỏ qua.

Kết quả từ KẾ HOẠCH GIẢI THÍCH và GIẢI THÍCH chỉ dành cho phân tích tương tác và khắc phục sự cố.
Các chi tiết của định dạng đầu ra có thể thay đổi từ bản phát hành SQLite này sang bản tiếp theo.
Ứng dụng không nên sử dụng KẾ HOẠCH GIẢI THÍCH hoặc GIẢI THÍCH CÂU HỎI vì hành vi chính xác của chúng có thể thay đổi và chỉ được ghi lại một phần.

Cú pháp

cú pháp cho EXPLAIN như sau -

EXPLAIN [SQLite Query]

cú pháp cho EXPLAIN QUERY PLAN như sau -

EXPLAIN  QUERY PLAN [SQLite Query]

Thí dụ

Xem xét bảng COMPANY với các bản ghi sau:

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ây giờ, chúng ta hãy kiểm tra truy vấn con sau với câu lệnh SELECT -

sqlite> EXPLAIN SELECT * FROM COMPANY WHERE Salary >= 20000;

Điều này sẽ tạo ra kết quả sau.

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

Bây giờ, chúng ta hãy kiểm tra những điều sau Explain Query Plan với câu lệnh SELECT -

SQLite> EXPLAIN QUERY PLAN SELECT * FROM COMPANY WHERE Salary >= 20000;

order       from        detail
----------  ----------  -------------
0           0           TABLE COMPANY

Lệnh VACUUM dọn dẹp cơ sở dữ liệu chính bằng cách sao chép nội dung của nó vào một tệp cơ sở dữ liệu tạm thời và tải lại tệp cơ sở dữ liệu gốc từ bản sao. Điều này giúp loại bỏ các trang miễn phí, căn chỉnh dữ liệu bảng để liền kề và làm sạch cấu trúc tệp cơ sở dữ liệu.

Lệnh VACUUM có thể thay đổi ROWID của các mục nhập trong bảng không có KHÓA CHÍNH INTEGER rõ ràng. Lệnh VACUUM chỉ hoạt động trên cơ sở dữ liệu chính. Không thể VACUUM tệp cơ sở dữ liệu đính kèm.

Lệnh VACUUM sẽ không thành công nếu có một giao dịch đang hoạt động. Lệnh VACUUM là lệnh cấm đối với cơ sở dữ liệu trong bộ nhớ. Khi lệnh VACUUM xây dựng lại tệp cơ sở dữ liệu từ đầu, VACUUM cũng có thể được sử dụng để sửa đổi nhiều tham số cấu hình cơ sở dữ liệu cụ thể.

VACUUM thủ công

Sau đây là một cú pháp đơn giản để đưa ra lệnh VACUUM cho toàn bộ cơ sở dữ liệu từ dấu nhắc lệnh:

$sqlite3 database_name "VACUUM;"

Bạn cũng có thể chạy VACUUM từ lời nhắc SQLite như sau:

sqlite> VACUUM;

Bạn cũng có thể chạy VACUUM trên một bảng cụ thể như sau:

sqlite> VACUUM table_name;

Auto-VACCUM

SQLite Auto-VACUUM không làm giống như VACUUM mà nó chỉ di chuyển các trang miễn phí đến cuối cơ sở dữ liệu do đó làm giảm kích thước cơ sở dữ liệu. Làm như vậy nó có thể phân mảnh đáng kể cơ sở dữ liệu trong khi VACUUM đảm bảo chống phân mảnh. Do đó, Auto-VACUUM chỉ giữ cho cơ sở dữ liệu nhỏ.

Bạn có thể bật / tắt tính năng tự động hút bụi của SQLite bằng các pragmas sau đang chạy tại lời nhắc 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

Bạn có thể chạy lệnh sau từ dấu nhắc lệnh để kiểm tra cài đặt tự động hút bụi -

$sqlite3 database_name "PRAGMA auto_vacuum;"

SQLite hỗ trợ năm hàm ngày và giờ như sau:

Sr.No.	Chức năng	Thí dụ
1	ngày (chuỗi thời gian, bổ ngữ ...)	Điều này trả về ngày ở định dạng sau: YYYY-MM-DD
2	thời gian (chuỗi thời gian, bổ ngữ ...)	Điều này trả về thời gian là HH: MM: SS
3	datetime (thời gian, công cụ sửa đổi ...)	Điều này trả về YYYY-MM-DD HH: MM: SS
4	julianday (định thời gian, bổ ngữ ...)	Điều này trả về số ngày kể từ buổi trưa ở Greenwich vào ngày 24 tháng 11 năm 4714 trước Công nguyên
5	strftime (chuỗi thời gian, bổ ngữ ...)	Điều này trả về ngày được định dạng theo chuỗi định dạng được chỉ định làm đối số đầu tiên được định dạng theo các định dạng được giải thích bên dưới.

Tất cả năm hàm ngày và giờ ở trên lấy chuỗi thời gian làm đối số. Chuỗi thời gian được theo sau bởi không hoặc nhiều bổ ngữ. Hàm strftime () cũng nhận một chuỗi định dạng làm đối số đầu tiên của nó. Phần sau sẽ cung cấp cho bạn chi tiết về các loại chuỗi thời gian và công cụ sửa đổi.

Chuỗi thời gian

Chuỗi thời gian có thể ở bất kỳ định dạng nào sau đây:

Sr.No.	Chuỗi thời gian	Thí dụ
1	YYYY-MM-DD	2010-12-30
2	YYYY-MM-DD HH: MM	2010-12-30 12:10
3	YYYY-MM-DD HH: MM: SS.SSS	2010-12-30 12: 10: 04.100
4	MM-DD-YYYY HH: MM	30-12-2010 12:10
5	HH: MM	12:10
6	YYYY-MM-DDTHH: MM	2010-12-30 12:10
7	HH: MM: SS	12:10:01
số 8	YYYYMMDD HHMMSS	20101230 121001
9	hiện nay	2013-05-07

Bạn có thể sử dụng chữ "T" như một ký tự chữ phân tách ngày và giờ.

Bổ ngữ

Chuỗi thời gian có thể được theo sau bởi không hoặc nhiều công cụ sửa đổi sẽ thay đổi ngày và / hoặc thời gian được trả về bởi bất kỳ hàm nào trong số năm hàm trên. Các bổ ngữ được áp dụng từ trái sang phải.

Các modifers sau có sẵn trong SQLite:

NNN ngày
NNN giờ
NNN phút
NNN.NNNN giây
NNN tháng
NNN năm
đầu tháng
đầu năm
bắt đầu một ngày
ngày trong tuần N
unixepoch
localtime
utc

Bộ định dạng

SQLite cung cấp một chức năng rất tiện dụng strftime()để định dạng bất kỳ ngày và giờ nào. Bạn có thể sử dụng các thay thế sau để định dạng ngày và giờ của mình.

Thay thế	Sự miêu tả
% d	Ngày trong tháng, 01-31
% f	Phân số giây, SS.SSS
% H	Giờ, 00-23
% j	Ngày trong năm, 001-366
% J	Số ngày Julian, DDDD.DDDD
% m	Tháng, 00-12
% M	Phút, 00-59
%S	Giây kể từ 1970-01-01
%S	Giây, 00-59
% w	Ngày trong tuần, 0-6 (0 là Chủ nhật)
% W	Tuần trong năm, 01-53
% Y	Năm, YYYY
%%	% Biểu tượng

Ví dụ

Bây giờ chúng ta hãy thử các ví dụ khác nhau bằng cách sử dụng lời nhắc SQLite. Lệnh sau tính toán ngày hiện tại.

sqlite> SELECT date('now');
2013-05-07

Lệnh sau tính ngày cuối cùng của tháng hiện tại.

sqlite> SELECT date('now','start of month','+1 month','-1 day');
2013-05-31

Lệnh sau tính toán ngày và giờ cho một dấu thời gian UNIX nhất định 1092941466.

sqlite> SELECT datetime(1092941466, 'unixepoch');
2004-08-19 18:51:06

Lệnh sau tính toán ngày và giờ cho một dấu thời gian UNIX nhất định 1092941466 và bù cho múi giờ địa phương của bạn.

sqlite> SELECT datetime(1092941466, 'unixepoch', 'localtime');
2004-08-19 13:51:06

Lệnh sau tính toán dấu thời gian UNIX hiện tại.

sqlite> SELECT strftime('%s','now');
1393348134

Lệnh sau tính toán số ngày kể từ ngày ký Tuyên ngôn Độc lập của Hoa Kỳ.

sqlite> SELECT julianday('now') - julianday('1776-07-04');
86798.7094695023

Lệnh sau tính số giây kể từ một thời điểm cụ thể trong năm 2004.

sqlite> SELECT strftime('%s','now') - strftime('%s','2004-01-01 02:34:56');
295001572

Lệnh sau tính toán ngày của thứ ba đầu tiên trong tháng 10 cho năm hiện tại.

sqlite> SELECT date('now','start of year','+9 months','weekday 2');
2013-10-01

Lệnh sau tính toán thời gian kể từ kỷ nguyên UNIX tính bằng giây (như strftime ('% s', 'now') ngoại trừ bao gồm phần phân số).

sqlite> SELECT (julianday('now') - 2440587.5)*86400.0;
1367926077.12598

Để chuyển đổi giữa các giá trị UTC và giờ địa phương khi định dạng ngày, hãy sử dụng công cụ sửa đổi utc hoặc localtime như sau:

sqlite> SELECT time('12:00', 'localtime');
05:00:00

sqlite> SELECT time('12:00', 'utc');
19:00:00

SQLite được tích hợp sẵn nhiều hàm để thực hiện xử lý trên dữ liệu chuỗi hoặc số. Sau đây là danh sách một số hàm tích hợp sẵn trong SQLite hữu ích và tất cả đều phân biệt chữ hoa chữ thường, nghĩa là bạn có thể sử dụng các hàm này ở dạng viết thường hoặc viết hoa hoặc ở dạng hỗn hợp. Để biết thêm chi tiết, bạn có thể kiểm tra tài liệu chính thức cho SQLite.

Sr.No.	Mô tả chức năng
1	SQLite COUNT Function Hàm tổng hợp SQLite COUNT được sử dụng để đếm số hàng trong bảng cơ sở dữ liệu.
2	SQLite MAX Function Hàm tổng hợp SQLite MAX cho phép chúng ta chọn giá trị cao nhất (lớn nhất) cho một cột nhất định.
3	SQLite MIN Function Hàm tổng hợp SQLite MIN cho phép chúng ta chọn giá trị thấp nhất (nhỏ nhất) cho một cột nhất định.
4	SQLite AVG Function Hàm tổng hợp SQLite AVG chọn giá trị trung bình cho cột bảng nhất định.
5	SQLite SUM Function Hàm tổng hợp SQLite SUM cho phép chọn tổng số cho một cột số.
6	SQLite RANDOM Function Hàm RANDOM trong SQLite trả về một số nguyên giả ngẫu nhiên giữa -9223372036854775808 và +9223372036854775807.
7	SQLite ABS Function Hàm ABS trong SQLite trả về giá trị tuyệt đối của đối số số.
số 8	SQLite UPPER Function Hàm UPPER của SQLite chuyển đổi một chuỗi thành các chữ cái viết hoa.
9	SQLite LOWER Function Hàm LOWER của SQLite chuyển đổi một chuỗi thành các chữ thường.
10	SQLite LENGTH Function Hàm LENGTH trong SQLite trả về độ dài của một chuỗi.
11	SQLite sqlite_version Function Hàm sqlite_version của SQLite trả về phiên bản của thư viện SQLite.

Trước khi chúng tôi bắt đầu đưa ra các ví dụ về các chức năng nêu trên, hãy xem xét bảng COMPANY với các bản ghi sau.

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

Hàm COUNT trong SQLite

Hàm tổng hợp SQLite COUNT được sử dụng để đếm số hàng trong bảng cơ sở dữ liệu. Sau đây là một ví dụ -

sqlite> SELECT count(*) FROM COMPANY;

Câu lệnh SQLite SQL trên sẽ tạo ra như sau.

count(*)
----------
7

Hàm MAX trong SQLite

Hàm tổng hợp SQLite MAX cho phép chúng ta chọn giá trị cao nhất (lớn nhất) cho một cột nhất định. Sau đây là một ví dụ -

sqlite> SELECT max(salary) FROM COMPANY;

Câu lệnh SQLite SQL trên sẽ tạo ra như sau.

max(salary)
-----------
85000.0

Hàm MIN trong SQLite

Hàm tổng hợp SQLite MIN cho phép chúng ta chọn giá trị thấp nhất (nhỏ nhất) cho một cột nhất định. Sau đây là một ví dụ -

sqlite> SELECT min(salary) FROM COMPANY;

Câu lệnh SQLite SQL trên sẽ tạo ra như sau.

min(salary)
-----------
10000.0

Hàm AVG của SQLite

Hàm tổng hợp SQLite AVG chọn giá trị trung bình cho một cột bảng nhất định. Sau đây là một ví dụ -

sqlite> SELECT avg(salary) FROM COMPANY;

Câu lệnh SQLite SQL trên sẽ tạo ra như sau.

avg(salary)
----------------
37142.8571428572

Hàm SUM trong SQLite

Hàm tổng hợp SQLite SUM cho phép chọn tổng số cho một cột số. Sau đây là một ví dụ -

sqlite> SELECT sum(salary) FROM COMPANY;

Câu lệnh SQLite SQL trên sẽ tạo ra như sau.

sum(salary)
-----------
260000.0

Hàm RANDOM trong SQLite

Hàm RANDOM trong SQLite trả về một số nguyên giả ngẫu nhiên giữa -9223372036854775808 và +9223372036854775807. Sau đây là một ví dụ -

sqlite> SELECT random() AS Random;

Câu lệnh SQLite SQL trên sẽ tạo ra như sau.

Random
-------------------
5876796417670984050

Hàm ABS trong SQLite

Hàm ABS trong SQLite trả về giá trị tuyệt đối của đối số số. Sau đây là một ví dụ -

sqlite> SELECT abs(5), abs(-15), abs(NULL), abs(0), abs("ABC");

Câu lệnh SQLite SQL trên sẽ tạo ra như sau.

abs(5)      abs(-15)    abs(NULL)   abs(0)      abs("ABC")
----------  ----------  ----------  ----------  ----------
5           15                      0           0.0

Hàm UPPER của SQLite

Hàm UPPER của SQLite chuyển đổi một chuỗi thành các chữ cái viết hoa. Sau đây là một ví dụ -

sqlite> SELECT upper(name) FROM COMPANY;

Câu lệnh SQLite SQL trên sẽ tạo ra như sau.

upper(name)
-----------
PAUL
ALLEN
TEDDY
MARK
DAVID
KIM
JAMES

Hàm LOWER của SQLite

Hàm LOWER của SQLite chuyển đổi một chuỗi thành các chữ thường. Sau đây là một ví dụ -

sqlite> SELECT lower(name) FROM COMPANY;

Câu lệnh SQLite SQL trên sẽ tạo ra như sau.

lower(name)
-----------
paul
allen
teddy
mark
david
kim
james

Hàm LENGTH trong SQLite

Hàm LENGTH trong SQLite trả về độ dài của một chuỗi. Sau đây là một ví dụ -

sqlite> SELECT name, length(name) FROM COMPANY;

The above SQLite SQL statement will produce the following.

NAME        length(name)
----------  ------------
Paul        4
Allen       5
Teddy       5
Mark        4
David       5
Kim         3
James       5

SQLite sqlite_version Function

SQLite sqlite_version function returns the version of the SQLite library. Following is an example −

sqlite> SELECT sqlite_version() AS 'SQLite Version';

The above SQLite SQL statement will produce the following.

SQLite Version
--------------
3.6.20

In this chapter, you will learn how to use SQLite in C/C++ programs.

Installation

Before you start using SQLite in our C/C++ programs, you need to make sure that you have SQLite library set up on the machine. You can check SQLite Installation chapter to understand the installation process.

C/C++ Interface APIs

Following are important C/C++ SQLite interface routines, which can suffice your requirement to work with SQLite database from your C/C++ program. If you are looking for a more sophisticated application, then you can look into SQLite official documentation.

Sr.No.	API & Description
1	*sqlite3_open(const char filename, sqlite3 ppDb) This routine opens a connection to an SQLite database file and returns a database connection object to be used by other SQLite routines. If the filename argument is NULL or ':memory:', sqlite3_open() will create an in-memory database in RAM that lasts only for the duration of the session. If the filename is not NULL, sqlite3_open() attempts to open the database file by using its value. If no file by that name exists, sqlite3_open() will open a new database file by that name.
2	*sqlite3_exec(sqlite3, const char sql, sqlite_callback, void data, char errmsg) This routine provides a quick, easy way to execute SQL commands provided by sql argument which can consist of more than one SQL command. Here, the first argument sqlite3 is an open database object, sqlite_callback is a call back for which data is the 1st argument and errmsg will be returned to capture any error raised by the routine. SQLite3_exec() routine parses and executes every command given in the sql argument until it reaches the end of the string or encounters an error.
3	*sqlite3_close(sqlite3)** This routine closes a database connection previously opened by a call to sqlite3_open(). All prepared statements associated with the connection should be finalized prior to closing the connection. If any queries remain that have not been finalized, sqlite3_close() will return SQLITE_BUSY with the error message Unable to close due to unfinalized statements.

Connect To Database

Following C code segment shows how to connect to an existing database. If the database does not exist, then it will be created and finally a database object will be returned.

#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);
}

Now, let's compile and run the above program to create our database test.db in the current directory. You can change your path as per your requirement.

$gcc test.c -l sqlite3
$./a.out
Opened database successfully

If you are going to use C++ source code, then you can compile your code as follows −

$g++ test.c -l sqlite3

Here, we are linking our program with sqlite3 library to provide required functions to C program. This will create a database file test.db in your directory and you will have the following result.

-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

Create a Table

Following C code segment will be used to create a table in the previously created database −

#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;
}

When the above program is compiled and executed, it will create COMPANY table in your test.db and the final listing of the file will be as follows −

-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 Operation

Following C code segment shows how you can create records in COMPANY table created in the above example −

#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;
}

When the above program is compiled and executed, it will create the given records in COMPANY table and will display the following two lines −

Opened database successfully
Records created successfully

SELECT Operation

Before proceeding with actual example to fetch records, let us look at some detail about the callback function, which we are using in our examples. This callback provides a way to obtain results from SELECT statements. It has the following declaration −

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 */
);

If the above callback is provided in sqlite_exec() routine as the third argument, SQLite will call this callback function for each record processed in each SELECT statement executed within the SQL argument.

Đoạn mã C sau đây cho thấy cách bạn có thể tìm nạp và hiển thị các bản ghi từ bảng COMPANY được tạo trong ví dụ trên -

#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;
}

Khi chương trình trên được biên dịch và thực thi, nó sẽ cho ra kết quả như sau.

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ẬP NHẬT Hoạt động

Đoạn mã C sau đây cho thấy cách chúng ta có thể sử dụng câu lệnh UPDATE để cập nhật bất kỳ bản ghi nào và sau đó tìm nạp và hiển thị các bản ghi đã cập nhật từ bảng 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;
}

Khi chương trình trên được biên dịch và thực thi, nó sẽ cho ra kết quả như sau.

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

Thao tác DELETE

Đoạn mã C sau đây cho thấy cách bạn có thể sử dụng câu lệnh DELETE để xóa bất kỳ bản ghi nào, sau đó tìm nạp và hiển thị các bản ghi còn lại từ bảng 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;
}

Khi chương trình trên được biên dịch và thực thi, nó sẽ cho ra kết quả như sau.

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

Trong chương này, bạn sẽ học cách sử dụng SQLite trong các chương trình Java.

Cài đặt

Trước khi bắt đầu sử dụng SQLite trong các chương trình Java của chúng tôi, bạn cần đảm bảo rằng bạn đã thiết lập SQLite JDBC Driver và Java trên máy. Bạn có thể xem hướng dẫn Java để cài đặt Java trên máy của mình. Bây giờ, chúng ta hãy kiểm tra cách thiết lập trình điều khiển SQLite JDBC.

Tải xuống phiên bản mới nhất của sqlite-jdbc- (VERSION) .jar từ kho lưu trữ sqlite-jdbc .
Thêm tệp jar đã tải xuống sqlite-jdbc- (VERSION) .jar vào đường dẫn lớp của bạn hoặc bạn có thể sử dụng nó cùng với tùy chọn -classpath như được giải thích trong các ví dụ sau.

Phần sau giả sử bạn có ít kiến thức về các khái niệm Java JDBC. Nếu bạn không, thì bạn nên dành nửa giờ với Hướng dẫn của JDBC để trở nên thoải mái với các khái niệm được giải thích bên dưới.

Kết nối với Cơ sở dữ liệu

Các chương trình Java sau đây chỉ ra cách kết nối với cơ sở dữ liệu hiện có. Nếu cơ sở dữ liệu không tồn tại, thì nó sẽ được tạo và cuối cùng một đối tượng cơ sở dữ liệu sẽ được trả về.

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");
   }
}

Bây giờ, hãy biên dịch và chạy chương trình trên để tạo cơ sở dữ liệu của chúng tôi test.dbtrong thư mục hiện tại. Bạn có thể thay đổi đường dẫn của mình theo yêu cầu của bạn. Chúng tôi giả sử phiên bản hiện tại của trình điều khiển JDBC sqlite-jdbc-3.7.2.jar có sẵn trong đường dẫn hiện tại.

$javac SQLiteJDBC.java $java -classpath ".:sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Open database successfully

Nếu bạn định sử dụng máy Windows, thì bạn có thể biên dịch và chạy mã của mình như sau:

$javac SQLiteJDBC.java $java -classpath ".;sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Opened database successfully

Tạo bảng

Chương trình Java sau sẽ được sử dụng để tạo một bảng trong cơ sở dữ liệu đã tạo trước đó.

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");
   }
}

Khi chương trình trên được biên dịch và thực thi, nó sẽ tạo ra bảng COMPANY trong test.db và danh sách cuối cùng của tệp sẽ như sau:

-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 hoạt động

Chương trình Java sau đây trình bày cách tạo các bản ghi trong bảng COMPANY được tạo trong ví dụ trên.

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");
   }
}

Khi chương trình trên được biên dịch và thực thi, nó sẽ tạo các bản ghi đã cho trong bảng COMPANY và sẽ hiển thị hai dòng sau:

Opened database successfully
Records created successfully

CHỌN hoạt động

Chương trình Java sau đây trình bày cách tìm nạp và hiển thị các bản ghi từ bảng COMPANY được tạo trong ví dụ trên.

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");
  }
}

Khi chương trình trên được biên dịch và thực thi, nó sẽ cho ra kết quả như sau.

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

CẬP NHẬT Hoạt động

Mã Java sau đây cho thấy cách sử dụng câu lệnh UPDATE để cập nhật bất kỳ bản ghi nào, sau đó tìm nạp và hiển thị các bản ghi đã cập nhật từ bảng 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");
   }
}

Khi chương trình trên được biên dịch và thực thi, nó sẽ cho ra kết quả như sau.

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

Thao tác DELETE

Mã Java sau đây cho thấy cách sử dụng lệnh DELETE để xóa bất kỳ bản ghi nào, sau đó tìm nạp và hiển thị các bản ghi còn lại từ bảng COMPANY của chúng ta.

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");
   }
}

Khi chương trình trên được biên dịch và thực thi, nó sẽ cho ra kết quả như sau.

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

Trong chương này, bạn sẽ học cách sử dụng SQLite trong các chương trình PHP.

Cài đặt

Phần mở rộng SQLite3 được bật theo mặc định kể từ phiên bản PHP 5.3.0. Có thể vô hiệu hóa nó bằng cách sử dụng--without-sqlite3 tại thời điểm biên dịch.

Người dùng Windows phải bật php_sqlite3.dll để sử dụng tiện ích mở rộng này. DLL này được bao gồm trong các bản phân phối Windows của PHP kể từ phiên bản PHP 5.3.0.

Để biết hướng dẫn cài đặt chi tiết, vui lòng kiểm tra hướng dẫn PHP của chúng tôi và trang web chính thức của nó.

API giao diện PHP

Sau đây là các quy trình PHP quan trọng có thể đáp ứng đủ yêu cầu của bạn để làm việc với cơ sở dữ liệu SQLite từ chương trình PHP của bạn. Nếu bạn đang tìm kiếm một ứng dụng phức tạp hơn, thì bạn có thể xem tài liệu chính thức của PHP.

Sr.No.	API & Mô tả
1	public void SQLite3::open ( filename, flags, encryption_key ) Mở Cơ sở dữ liệu SQLite 3. Nếu bản dựng bao gồm mã hóa, thì nó sẽ cố gắng sử dụng khóa. Nếu tên tệp được cung cấp là':memory:', SQLite3 :: open () sẽ tạo cơ sở dữ liệu trong bộ nhớ trong RAM chỉ kéo dài trong khoảng thời gian của phiên. Nếu tên tệp là tên tệp thiết bị thực, SQLite3 :: open () cố gắng mở tệp cơ sở dữ liệu bằng cách sử dụng giá trị của nó. Nếu không có tệp nào có tên đó tồn tại, thì tệp cơ sở dữ liệu mới có tên đó sẽ được tạo. Cờ tùy chọn được sử dụng để xác định cách mở cơ sở dữ liệu SQLite. Theo mặc định, mở sử dụng SQLITE3_OPEN_READWRITE \| SQLITE3_OPEN_CREATE.
2	public bool SQLite3::exec ( string $query ) Quy trình này cung cấp một cách nhanh chóng, dễ dàng để thực hiện các lệnh SQL được cung cấp bởi đối số sql, có thể bao gồm nhiều hơn một lệnh SQL. Quy trình này được sử dụng để thực hiện một truy vấn không có kết quả đối với một cơ sở dữ liệu nhất định.
3	public SQLite3Result SQLite3::query ( string $query ) Quy trình này thực hiện một truy vấn SQL, trả về một SQLite3Result đối tượng nếu truy vấn trả về kết quả.
4	public int SQLite3::lastErrorCode ( void ) Quy trình này trả về mã kết quả số của yêu cầu SQLite không thành công gần đây nhất.
5	public string SQLite3::lastErrorMsg ( void ) Quy trình này trả về văn bản tiếng Anh mô tả yêu cầu SQLite không thành công gần đây nhất.
6	public int SQLite3::changes ( void ) Quy trình này trả về số hàng cơ sở dữ liệu đã được cập nhật, chèn hoặc xóa bởi câu lệnh SQL gần đây nhất.
7	public bool SQLite3::close ( void ) Quy trình này đóng một kết nối cơ sở dữ liệu đã mở trước đó bằng một cuộc gọi tới SQLite3 :: open ().
số 8	public string SQLite3::escapeString ( string $value ) Quy trình này trả về một chuỗi đã được thoát đúng cách để đưa vào một câu lệnh SQL một cách an toàn.

Kết nối với Cơ sở dữ liệu

Mã PHP sau đây cho thấy cách kết nối với cơ sở dữ liệu hiện có. Nếu cơ sở dữ liệu không tồn tại, thì nó sẽ được tạo và cuối cùng một đối tượng cơ sở dữ liệu sẽ được trả về.

<?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";
   }
?>

Bây giờ, hãy chạy chương trình trên để tạo cơ sở dữ liệu của chúng tôi test.dbtrong thư mục hiện tại. Bạn có thể thay đổi đường dẫn của mình theo yêu cầu của bạn. Nếu cơ sở dữ liệu được tạo thành công, thì nó sẽ hiển thị thông báo sau:

Open database successfully

Tạo bảng

Chương trình PHP sau sẽ được sử dụng để tạo một bảng trong cơ sở dữ liệu đã tạo trước đó.

<?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();
?>

Khi chương trình trên được thực thi, nó sẽ tạo ra bảng COMPANY trong test.db và nó sẽ hiển thị các thông báo sau:

Opened database successfully
Table created successfully

INSERT hoạt động

Chương trình PHP sau đây trình bày cách tạo các bản ghi trong bảng COMPANY được tạo trong ví dụ trên.

<?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();
?>

Khi chương trình trên được thực thi, nó sẽ tạo các bản ghi đã cho trong bảng COMPANY và sẽ hiển thị hai dòng sau.

Opened database successfully
Records created successfully

CHỌN hoạt động

Chương trình PHP sau đây cho thấy cách tìm nạp và hiển thị các bản ghi từ bảng COMPANY được tạo trong ví dụ trên:

<?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();
?>

Khi chương trình trên được thực thi, nó sẽ cho ra kết quả như sau.

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

CẬP NHẬT Hoạt động

Đoạn mã PHP sau đây cho thấy cách sử dụng câu lệnh UPDATE để cập nhật bất kỳ bản ghi nào, sau đó tìm nạp và hiển thị các bản ghi đã cập nhật từ bảng 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();
?>

Khi chương trình trên được thực thi, nó sẽ cho ra kết quả như sau.

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

Thao tác DELETE

Đoạn mã PHP sau đây cho thấy cách sử dụng câu lệnh DELETE để xóa bất kỳ bản ghi nào, sau đó tìm nạp và hiển thị các bản ghi còn lại từ bảng 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();
?>

Khi chương trình trên được thực thi, nó sẽ cho ra kết quả như sau.

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

Trong chương này, bạn sẽ học cách sử dụng SQLite trong các chương trình Perl.

Cài đặt

SQLite3 có thể được tích hợp với Perl bằng cách sử dụng mô-đun Perl DBI, đây là một mô-đun truy cập cơ sở dữ liệu cho ngôn ngữ lập trình Perl. Nó định nghĩa một tập hợp các phương thức, biến và quy ước cung cấp giao diện cơ sở dữ liệu chuẩn.

Sau đây là các bước đơn giản để cài đặt mô-đun DBI trên máy Linux / UNIX của bạn -

$ 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

Nếu bạn cần cài đặt trình điều khiển SQLite cho DBI, thì nó có thể được cài đặt như sau:

$ 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

API giao diện DBI

Sau đây là các thủ tục DBI quan trọng, có thể đáp ứng yêu cầu của bạn để làm việc với cơ sở dữ liệu SQLite từ chương trình Perl của bạn. Nếu bạn đang tìm kiếm một ứng dụng phức tạp hơn, thì bạn có thể xem tài liệu chính thức của Perl DBI.

Sr.No.	API & Mô tả
1	DBI->connect($data_source, "", "", \%attr) Thiết lập kết nối cơ sở dữ liệu hoặc phiên, tới $ data_source được yêu cầu. Trả về một đối tượng xử lý cơ sở dữ liệu nếu kết nối thành công. Datasource có dạng như sau - DBI:SQLite:dbname = 'test.db'trong đó SQLite là tên trình điều khiển SQLite và test.db là tên của tệp cơ sở dữ liệu SQLite. Nếu tên tệp được cung cấp là':memory:', nó sẽ tạo cơ sở dữ liệu trong bộ nhớ trong RAM chỉ tồn tại trong khoảng thời gian của phiên. Nếu tên tệp là tên tệp thiết bị thực, thì nó sẽ cố gắng mở tệp cơ sở dữ liệu bằng cách sử dụng giá trị của nó. Nếu không có tệp nào có tên đó tồn tại, thì tệp cơ sở dữ liệu mới có tên đó sẽ được tạo. Bạn giữ tham số thứ hai và thứ ba dưới dạng chuỗi trống và tham số cuối cùng là chuyển các thuộc tính khác nhau như được hiển thị trong ví dụ sau.
2	$dbh->do($sql) Quy trình này chuẩn bị và thực thi một câu lệnh SQL duy nhất. Trả về số lượng hàng bị ảnh hưởng hoặc hoàn tác do lỗi. Giá trị trả về -1 có nghĩa là số hàng không được biết, không áp dụng được hoặc không có sẵn. Ở đây, $ dbh là một xử lý được trả về bởi lệnh gọi DBI-> connect ().
3	$dbh->prepare($sql) Quy trình này chuẩn bị một câu lệnh để thực thi sau bởi cơ sở dữ liệu và trả về một tham chiếu đến một đối tượng xử lý câu lệnh.
4	$sth->execute() Quy trình này thực hiện bất kỳ quá trình xử lý nào cần thiết để thực hiện câu lệnh đã chuẩn bị. Một undef được trả về nếu một lỗi xảy ra. Thực thi thành công luôn trả về true bất kể số hàng bị ảnh hưởng. Đây,$sth is a statement handle returned by $dbh-> chuẩn bị cuộc gọi ($ sql).
5	$sth->fetchrow_array() Quy trình này tìm nạp dòng dữ liệu tiếp theo và trả về nó dưới dạng danh sách chứa các giá trị trường. Các trường rỗng được trả về dưới dạng giá trị undef trong danh sách.
6	$DBI::err Điều này tương đương với $ h-> err, trong đó $h is any of the handle types like $dbh, $sth, or $drh. Điều này trả về mã lỗi công cụ cơ sở dữ liệu gốc từ phương thức trình điều khiển cuối cùng được gọi.
7	$DBI::errstr Điều này tương đương với $ h-> errstr, trong đó $h is any of the handle types like $dbh, $sth, or $drh. Điều này trả về thông báo lỗi công cụ cơ sở dữ liệu gốc từ phương thức DBI cuối cùng được gọi.
số 8	$dbh->disconnect() Quy trình này đóng một kết nối cơ sở dữ liệu đã mở trước đó bằng lệnh gọi đến DBI-> connect ().

Kết nối với cơ sở dữ liệu

Sau mã Perl cho thấy cách kết nối với cơ sở dữ liệu hiện có. Nếu cơ sở dữ liệu không tồn tại, thì nó sẽ được tạo và cuối cùng một đối tượng cơ sở dữ liệu sẽ được trả về.

#!/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";

Bây giờ, hãy chạy chương trình trên để tạo cơ sở dữ liệu test.db của chúng tôi trong thư mục hiện tại. Bạn có thể thay đổi đường dẫn của mình theo yêu cầu của bạn. Giữ đoạn mã trên trong tệp sqlite.pl và thực thi nó như hình dưới đây. Nếu cơ sở dữ liệu được tạo thành công, thì nó sẽ hiển thị thông báo sau:

$ chmod +x sqlite.pl
$ ./sqlite.pl
Open database successfully

Tạo bảng

Chương trình Perl sau được sử dụng để tạo một bảng trong cơ sở dữ liệu đã tạo trước đó.

#!/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();

Khi chương trình trên được thực thi, nó sẽ tạo bảng COMPANY trong test.db của bạn và nó sẽ hiển thị các thông báo sau:

Opened database successfully
Table created successfully

NOTE - Trong trường hợp bạn gặp lỗi sau trong bất kỳ thao tác nào -

DBD::SQLite::st execute failed: not an error(21) at dbdimp.c line 398

Trong trường hợp đó, hãy mở dbdimp.c file có sẵn trong cài đặt DBD-SQLite và tìm hiểu sqlite3_prepare() và thay đổi đối số thứ ba của nó thành -1 thay vì 0. Cuối cùng, cài đặt DBD :: SQLite bằng cách sử dụng make và làm make install để giải quyết vấn đề.

INSERT hoạt động

Sau đây chương trình Perl trình bày cách tạo các bản ghi trong bảng COMPANY đã tạo trong ví dụ trên.

#!/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();

Khi chương trình trên được thực thi, nó sẽ tạo các bản ghi đã cho trong bảng COMPANY và nó sẽ hiển thị hai dòng sau:

Opened database successfully
Records created successfully

CHỌN hoạt động

Chương trình Perl sau đây chỉ ra cách tìm nạp và hiển thị các bản ghi từ bảng COMPANY được tạo trong ví dụ trên.

#!/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();

Khi chương trình trên được thực thi, nó sẽ cho ra kết quả như sau.

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

CẬP NHẬT Hoạt động

Mã Perl sau đây chỉ ra cách CẬP NHẬT câu lệnh để cập nhật bất kỳ bản ghi nào, sau đó tìm nạp và hiển thị các bản ghi đã cập nhật từ bảng 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();

Khi chương trình trên được thực thi, nó sẽ cho ra kết quả như sau.

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

Thao tác DELETE

Mã Perl sau đây cho thấy cách sử dụng câu lệnh DELETE để xóa bất kỳ bản ghi nào, sau đó tìm nạp và hiển thị các bản ghi còn lại từ bảng 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();

Khi chương trình trên được thực thi, nó sẽ cho ra kết quả như sau.

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

Trong chương này, bạn sẽ học cách sử dụng SQLite trong các chương trình Python.

Cài đặt

SQLite3 có thể được tích hợp với Python bằng cách sử dụng mô-đun sqlite3, được viết bởi Gerhard Haring. Nó cung cấp giao diện SQL tuân thủ đặc tả DB-API 2.0 được mô tả bởi PEP 249. Bạn không cần cài đặt riêng mô-đun này vì nó được vận chuyển theo mặc định cùng với phiên bản Python 2.5.x trở đi.

Để sử dụng mô-đun sqlite3, trước tiên bạn phải tạo một đối tượng kết nối đại diện cho cơ sở dữ liệu và sau đó tùy ý bạn có thể tạo một đối tượng con trỏ, đối tượng này sẽ giúp bạn thực thi tất cả các câu lệnh SQL.

API mô-đun sqlite3 của Python

Sau đây là các quy trình quan trọng của mô-đun sqlite3, có thể đủ yêu cầu của bạn để làm việc với cơ sở dữ liệu SQLite từ chương trình Python của bạn. Nếu bạn đang tìm kiếm một ứng dụng phức tạp hơn, thì bạn có thể xem tài liệu chính thức của mô-đun Python sqlite3.

Sr.No.	API & Mô tả
1	sqlite3.connect(database [,timeout ,other optional arguments]) API này mở một kết nối đến tệp cơ sở dữ liệu SQLite. Bạn có thể sử dụng ": memory:" để mở kết nối cơ sở dữ liệu tới cơ sở dữ liệu nằm trong RAM thay vì trên đĩa. Nếu cơ sở dữ liệu được mở thành công, nó sẽ trả về một đối tượng kết nối. Khi cơ sở dữ liệu được truy cập bởi nhiều kết nối và một trong các quy trình sửa đổi cơ sở dữ liệu, cơ sở dữ liệu SQLite sẽ bị khóa cho đến khi giao dịch đó được cam kết. Tham số thời gian chờ chỉ định thời gian kết nối sẽ chờ khóa biến mất cho đến khi tạo ra một ngoại lệ. Giá trị mặc định cho thông số thời gian chờ là 5,0 (năm giây). Nếu tên cơ sở dữ liệu đã cho không tồn tại thì lệnh gọi này sẽ tạo cơ sở dữ liệu. Bạn cũng có thể chỉ định tên tệp với đường dẫn bắt buộc nếu bạn muốn tạo cơ sở dữ liệu ở bất kỳ nơi nào khác ngoại trừ trong thư mục hiện tại.
2	connection.cursor([cursorClass]) Quy trình này tạo ra một cursorsẽ được sử dụng trong suốt quá trình lập trình cơ sở dữ liệu của bạn với Python. Phương thức này chấp nhận một tham số tùy chọn duy nhất là cursorClass. Nếu được cung cấp, đây phải là lớp con trỏ tùy chỉnh mở rộng sqlite3.Cursor.
3	cursor.execute(sql [, optional parameters]) Quy trình này thực thi một câu lệnh SQL. Câu lệnh SQL có thể được tham số hóa (tức là trình giữ chỗ thay vì các ký tự SQL). Mô-đun sqlite3 hỗ trợ hai loại trình giữ chỗ: dấu chấm hỏi và trình giữ chỗ được đặt tên (kiểu được đặt tên). For example - cursor.execute ("chèn vào giá trị người (?,?)", (Ai, tuổi))
4	connection.execute(sql [, optional parameters]) Quy trình này là một lối tắt của phương thức thực thi ở trên được cung cấp bởi đối tượng con trỏ và nó tạo ra một đối tượng con trỏ trung gian bằng cách gọi phương thức con trỏ, sau đó gọi phương thức thực thi của con trỏ với các tham số đã cho.
5	cursor.executemany(sql, seq_of_parameters) Quy trình này thực thi một lệnh SQL chống lại tất cả các chuỗi tham số hoặc ánh xạ được tìm thấy trong chuỗi sql.
6	connection.executemany(sql[, parameters]) Quy trình này là một lối tắt tạo đối tượng con trỏ trung gian bằng cách gọi phương thức con trỏ, sau đó gọi phương thức thực thi cursor.s với các tham số đã cho.
7	cursor.executescript(sql_script) Quy trình này thực thi nhiều câu lệnh SQL cùng một lúc được cung cấp dưới dạng tập lệnh. Nó đưa ra một câu lệnh COMMIT trước, sau đó thực thi tập lệnh SQL mà nó nhận được như một tham số. Tất cả các câu lệnh SQL phải được phân tách bằng dấu chấm phẩy (;).
số 8	connection.executescript(sql_script) Quy trình này là một lối tắt tạo đối tượng con trỏ trung gian bằng cách gọi phương thức con trỏ, sau đó gọi phương thức thực thi của con trỏ với các tham số đã cho.
9	connection.total_changes() Quy trình này trả về tổng số hàng cơ sở dữ liệu đã được sửa đổi, chèn hoặc xóa kể từ khi kết nối cơ sở dữ liệu được mở.
10	connection.commit() Phương thức này cam kết giao dịch hiện tại. Nếu bạn không gọi phương thức này, bất kỳ điều gì bạn đã làm kể từ lần gọi cuối cùng tới commit () sẽ không hiển thị từ các kết nối cơ sở dữ liệu khác.
11	connection.rollback() Phương thức này sẽ quay trở lại bất kỳ thay đổi nào đối với cơ sở dữ liệu kể từ lần gọi cuối cùng tới commit ().
12	connection.close() Phương thức này đóng kết nối cơ sở dữ liệu. Lưu ý rằng điều này không tự động gọi commit (). Nếu bạn chỉ đóng kết nối cơ sở dữ liệu của mình mà không gọi commit () trước, các thay đổi của bạn sẽ bị mất!
13	cursor.fetchone() Phương thức này tìm nạp hàng tiếp theo của tập hợp kết quả truy vấn, trả về một chuỗi duy nhất hoặc Không có khi không có thêm dữ liệu.
14	cursor.fetchmany([size = cursor.arraysize]) Quy trình này tìm nạp tập hợp các hàng tiếp theo của kết quả truy vấn, trả về một danh sách. Một danh sách trống được trả về khi không còn hàng nào nữa. Phương thức cố gắng tìm nạp nhiều hàng như được chỉ ra bởi tham số kích thước.
15	cursor.fetchall() Quy trình này tìm nạp tất cả (còn lại) các hàng của kết quả truy vấn, trả về một danh sách. Một danh sách trống được trả về khi không có hàng nào.

Kết nối với cơ sở dữ liệu

Sau mã Python cho thấy cách kết nối với cơ sở dữ liệu hiện có. Nếu cơ sở dữ liệu không tồn tại, thì nó sẽ được tạo và cuối cùng một đối tượng cơ sở dữ liệu sẽ được trả về.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')

print "Opened database successfully";

Tại đây, bạn cũng có thể cung cấp tên cơ sở dữ liệu làm tên đặc biệt :memory:để tạo cơ sở dữ liệu trong RAM. Bây giờ, hãy chạy chương trình trên để tạo cơ sở dữ liệu của chúng tôitest.dbtrong thư mục hiện tại. Bạn có thể thay đổi đường dẫn của mình theo yêu cầu của bạn. Giữ đoạn mã trên trong tệp sqlite.py và thực thi nó như hình bên dưới. Nếu cơ sở dữ liệu được tạo thành công, thì nó sẽ hiển thị thông báo sau.

$chmod +x sqlite.py $./sqlite.py
Open database successfully

Tạo bảng

Chương trình Python sau sẽ được sử dụng để tạo một bảng trong cơ sở dữ liệu đã tạo trước đó.

#!/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()

Khi chương trình trên được thực thi, nó sẽ tạo ra bảng COMPANY trong test.db và nó sẽ hiển thị các thông báo sau:

Opened database successfully
Table created successfully

INSERT hoạt động

Chương trình Python sau đây trình bày cách tạo bản ghi trong bảng COMPANY được tạo trong ví dụ trên.

#!/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()

Khi chương trình trên được thực thi, nó sẽ tạo các bản ghi đã cho trong bảng COMPANY và nó sẽ hiển thị hai dòng sau:

Opened database successfully
Records created successfully

CHỌN hoạt động

Chương trình Python sau đây cho thấy cách tìm nạp và hiển thị các bản ghi từ bảng COMPANY được tạo trong ví dụ trên.

#!/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()

Khi chương trình trên được thực thi, nó sẽ cho ra kết quả như sau.

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

CẬP NHẬT Hoạt động

Mã Python sau đây cho thấy cách sử dụng câu lệnh UPDATE để cập nhật bất kỳ bản ghi nào, sau đó tìm nạp và hiển thị các bản ghi đã cập nhật từ bảng 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()

Khi chương trình trên được thực thi, nó sẽ cho ra kết quả như sau.

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

Thao tác DELETE

Mã Python sau đây cho thấy cách sử dụng câu lệnh DELETE để xóa bất kỳ bản ghi nào, sau đó tìm nạp và hiển thị các bản ghi còn lại từ bảng 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()

Khi chương trình trên được thực thi, nó sẽ cho ra kết quả như sau.

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