Xây dựng mô đun sinh tự động mã nguồn trigger trên ngôn ngữ c phục vụ cập nhật gia tăng, đồng bộ các khung nhìn thực
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (5.38 MB, 92 trang )
ĐẠI HỌC ĐÀ NẴNG
TRƯỜNG ĐẠI HỌC SƯ PHẠM
---------------------------------------
LÊ THỊ THẢO NGUYÊN
XÂY DỰNG MÔ-ĐUN SINH TỰ ĐỘNG MÃ NGUỒN
TRIGGER TRÊN NGÔN NGỮ C PHỤC VỤ CẬP NHẬT GIA
TĂNG, ĐỒNG BỘ CÁC KHUNG NHÌN THỰC VỚI TRUY
VẤN LỒNG CHO POSTGRESQL
LUẬN VĂN THẠC SĨ
NGÀNH HỆ THỐNG THÔNG TIN
Đà Nẵng - Năm 2018
ĐẠI HỌC ĐÀ NẴNG
TRƯỜNG ĐẠI HỌC SƯ PHẠM
---------------------------------------
LÊ THỊ THẢO NGUYÊN
XÂY DỰNG MÔ-ĐUN SINH TỰ ĐỘNG MÃ NGUỒN
TRIGGER TRÊN NGÔN NGỮ C PHỤC VỤ CẬP NHẬT GIA
TĂNG, ĐỒNG BỘ CÁC KHUNG NHÌN THỰC VỚI TRUY
VẤN LỒNG CHO POSTGRESQL
Chuyên ngành
Mã số
: Hệ thống thông tin
: 8480104
LUẬN VĂN THẠC SĨ
NGƯỜI HƯỚNG DẪN KHOA HỌC:
TS. Nguyễn Trần Quốc Vinh
Đà Nẵng - Năm 2018
i
LỜI CAM ĐOAN
Tơi xin cam đoan cơng trình nghiên cứu khoa học này là của riêng tôi.
Các số liệu, kết quả nêu trong luận văn là trung thực và chưa từng được ai
cơng bố trong bất kỳ cơng trình nào. Mọi sự giúp đỡ cho việc thực hiện luận văn
này đã được cảm ơn và các thơng tin trích dẫn trong luận văn đã được chỉ rõ
nguồn gốc rõ ràng và được phép công bố.
Tac gia lu�n van
�
Le Thj Thao Nguyen
iv
MỤC LỤC
LỜI CAM ĐOAN .......................................................................................................... i
TRANG THÔNG TIN LUẬN VĂN THẠC SĨ .......................................................... ii
DANH MỤC CÁC TỪ VIẾT TẮT ............................................................................ vi
DANH MỤC HÌNH VẼ.............................................................................................. vii
DANH MỤC CÁC BẢNG......................................................................................... viii
LỜI MỞ ĐẦU ................................................................................................................1
1. Lý do chọn đề tài .........................................................................................................1
2. Mục tiêu và nhiệm vụ đề tài ........................................................................................2
3. Đối tượng và phạm vi nghiên cứu ...............................................................................3
4. Phương pháp nghiên cứu .............................................................................................3
5. Ý nghĩa khoa học và thực tiễn của đề tài.....................................................................4
6. Cấu trúc của luận văn ..................................................................................................4
CHƯƠNG 1. NGHIÊN CỨU TỔNG QUAN ..............................................................5
1.1. Tổng quan về ngơn ngữ lập trình C ......................................................................5
1.1.1. Ngơn ngữ lập trình C .....................................................................................5
1.1.2. Đặc điểm của ngơn ngữ C ..............................................................................5
1.2. Tổng quan về truy vấn lồng ..................................................................................6
1.2.1. Đặc điểm của truy vấn lồng ...........................................................................6
1.2.2. Phân loại ........................................................................................................8
1.3. Tổng quan về khung nhìn thực .............................................................................9
1.3.1. Giới thiệu chung .............................................................................................9
1.3.2. Phân loại khung nhìn thực ...........................................................................14
1.4. Tổng quan về cập nhật gia tăng, đồng bộ khung nhìn thực ................................15
1.4.1. Tổng quan về cập nhật gia tăng ...................................................................15
1.4.2. Cập nhật đồng bộ khung nhìn thực ..............................................................16
1.5. Cập nhật khung nhìn thực bằng trigger trên C trong PostgreSQL .....................16
1.5.1. Khái niệm về trigger ....................................................................................16
1.5.2. Trigger trên các HQT CSDL ........................................................................17
1.5.3. Trigger trong PostgreSQL ...........................................................................17
1.5.4. Hàm trong C .................................................................................................18
1.5.5. Hàm trigger trong C ....................................................................................19
1.5.6. Ví dụ tạo trigger trên C trong PostgreSQL..................................................19
1.6. Kết chương 1 .......................................................................................................19
v
CHƯƠNG 2: KHUNG NHÌN THỰC TRONG POSTGRESQL VÀ THUẬT
TỐN CẬP NHẬT GIA TĂNG KHUNG NHÌN THỰC VỚI TRUY VẤN LỒNG
.......................................................................................................................................20
2.1. PostgreSQL và khung nhìn thực trong PostgreSQL ...........................................20
2.2. Các phương pháp cập nhật KNT ........................................................................21
2.2.1. Phương pháp làm mới KNT .........................................................................21
2.2.2. Phương pháp cập nhật gia tăng đồng bộ .....................................................21
2.2.3. Một số vấn đề cần quan tâm khi CNGT KNT với truy vấn lồng ..................22
2.3. Thuật toán cập nhật gia tăng KNT với truy vấn lồng .........................................23
2.3.1. Thuật toán chuyển từ truy vấn lồng sang truy vấn nối trong .......................23
2.3.2. Điều kiện triển khai thuật toán ....................................................................25
2.3.3. Thuật toán cập nhật gia tăng khung nhìn thực với truy vấn nối trong ........26
2.4. Kết chương 2 .......................................................................................................35
CHƯƠNG 3: XÂY DỰNG CHƯƠNG TRÌNH SINH TỰ ĐỘNG MÃ NGUỒN
CÁC TRIGGER THỰC HIỆN CẬP NHẬT GIA TĂNG KHUNG NHÌN THỰC
VỚI TRUY VẤN LỒNG .............................................................................................36
3.1. Cài đặt mơi trường CSDL và ngơn ngữ lập trình ...............................................36
3.2. Xây dựng mô-đun sinh mã tự động trigger.........................................................36
3.2.1. Tạo cơ sở dữ liệu thực nghiệm .....................................................................36
3.2.2. Chương trình sinh tự động mã trigger .........................................................36
3.2.3. Sử dụng kết quả của chương trình sinh mã..................................................40
3.2.4. Đánh giá kết quả thực nghiệm .....................................................................41
3.3. Kết chương 3 .......................................................................................................47
KẾT LUẬN VÀ KIẾN NGHỊ .....................................................................................48
1. THẢO LUẬN MỘT SỐ KẾT QUẢ ĐẠT ĐƯỢC....................................................48
2. GIỚI HẠN CỦA LUẬN VĂN NÀY ........................................................................48
TÀI LIỆU THAM KHẢO...........................................................................................49
PHỤ LỤC 1 ...................................................................................................................51
PHỤ LỤC 2 ...................................................................................................................55
PHỤ LỤC 3 ...................................................................................................................74
vi
DANH MỤC CÁC TỪ VIẾT TẮT
Chữ cái viết tắt/
ký hiệu
BG
Cụm từ đầy đủ
Bảng gốc
CNGT
Cập nhật gia tăng
CSDL
Cơ sở dữ liệu
HQTCSDL
Hệ quản trị cơ sở dữ liệu
KNT
Khung nhìn thực
SPJ
Select – Project – Join; Kết nối trong bao gồm phép
chọn, chiếu
TVG
Truy vấn gốc
DSSV
Danh sách sinh viên
Col
QLSV
Columns (cột)
Quản lý sinh viên
vii
DANH MỤC HÌNH VẼ
Số
hiệu
hình
vẽ
1.1.
Tên hình vẽ
Cơ sở dữ liệu quản lý đặt và giao hàng hóa.
Trang
12
Mơ tả hoạt động của HQT CSDL khi xuất hiện truy vấn yêu
1.2.
cầu sử dụng dữ liệu khi không sử dụng KNT
13
1.3.
Cơ sở dữ liệu quản lý đặt và giao hàng hóa sử dụng khung
nhìn thực.
13
2.1.
Mơ tả q trình CNGT KNT bằng trigger
22
2.2.
CSDL quản lý sinh viên đơn giản với 3 bảng
24
3.1.
Ví dụ về dữ liệu đầu vào
40
3.2.
Giao diện chương trình sinh mã
41
3.3.
Tốc độ thực thi lệnh Select 1000 row không dùng KNT
42
3.4.
Tốc độ thực thi lệnh Select 1000 row có dùng KNT
43
3.5.
Tốc độ thực thi lệnh insert 1 row không dùng câu lệnh
trigger
43
3.6.
Tốc độ thực thi lệnh insert 1 row có dùng câu lệnh trigger
44
3.7.
Tốc độ thực thi lệnh update 1 row không dùng câu lệnh
trigger
44
3.8.
Tốc độ thực thi lệnh update 1 row có dùng câu lệnh trigger
45
3.9.
Tốc độ thực thi lệnh update 1000 row không dùng câu lệnh
trigger
45
3.10.
Tốc độ thực thi lệnh update 1000 row có dùng câu lệnh
trigger
46
viii
DANH MỤC CÁC BẢNG
Số hiệu
bảng
1.1
1.2
Tên bảng
Trang
Mô tả thông tin chi tiết dữ liệu bảng SINHVIEN và
bảng LOP
10
Khung nhìn thực DSSV với dữ liệu lấy từ bảng
SINHVIEN và LOP
10
1
LỜI MỞ ĐẦU
1. Lý do chọn đề tài
Khung nhìn thực (KNT) là một kỹ thuật giúp cải thiện và nâng cao tốc độ
thực thi đối với các truy vấn phức tạp, có tần suất sử dụng cao trên một lượng dữ
liệu lớn. Ý tưởng của KNT là dựa trên các bảng kết quả sẵn có để trả lời truy
vấn một cách nhanh chóng mà khơng cần thực thi lại truy vấn. Đối với những
truy vấn phức tạp bao gồm nhiều phép nối và các hàm thống kê, hiệu quả sử
dụng KNT càng rõ rệt, đặc biệt khi áp dụng trên một lượng dữ liệu đủ lớn, do đã
bỏ qua các bước thực thi phép nối và các hàm thống kê vốn là những thành phần
chiếm nhiều chi phí trong quá trình thực thi truy vấn. Đến nay, kỹ thuật KNT đã
được triển khai trên các hệ quản trị cơ sở dữ liệu (HTQCSDL) thương mại lớn
như Oracle, Microsoft SQL Server, IBM DB2,… và ngày càng được ứng dụng
rộng rãi.
PostgreSQL là một HQTCSDL mã nguồn mở hàng đầu trên thế giới, tuy
nhiên KNT mới được triển khai trên PostgreSQL ở phiên bản 9.3.4 và chưa hỗ
trợ vấn đề cập nhật đồng bộ gia tăng. Thay vào đó, PostgreSQL cập nhật KNT
theo cơ chế toàn phần bất đồng bộ, tức là thực thi lại toàn bộ truy vấn dùng để
tạo KNT mỗi khi cần cập nhật. Điều này tốn chi phí xấp xỉ chi phí thực hiện truy
vấn, và khơng đảm bảo được dữ liệu trên KNT luôn luôn là mới nhất. Đến phiên
bản 10 có bổ sung tính năng cập nhật đồng thời, tuy nhiên tính năng này chỉ hỗ
trợ việc truy cập đồng thời đến KNT, nghĩa là cung cấp khả năng truy cập bảng
KNT để trả lời truy vấn ngay cả khi nó đang được cập nhật bằng lệnh refresh
materialized view, chứ chưa đề cập đến vấn đề CNGT.
Cập nhật gia tăng (CNGT) là kỹ thuật cập nhật dữ liệu trên KNT một cách
đồng bộ, được thực hiện mỗi khi dữ liệu tại các bảng gốc (BG) tham gia vào
KNT có sự thay đổi, nhờ đó giúp cho KNT luôn trong trạng thái được cập nhật.
Do vậy, việc nghiên cứu các kỹ thuật CNGT cho KNT trên PostgesSQL đang rất
được quan tâm.
Việc CNGT KNT có thể được thực hiện thông qua việc xây dựng các
trigger bắt các sự kiện làm thay đổi dữ liệu trên các bảng gốc, từ đó tiến hành
xác định các thay đổi có thể làm ảnh hưởng đến tính đúng đắn của kết quả được
lưu trong KNT, sau đó tiến hành việc cập nhật dữ liệu trong KNT. PostgreSQL
hỗ trợ 2 loại trigger là trigger viết bằng ngôn ngữ PL/pgSQL và trigger viết bằng
2
ngơn ngữ C. Đã có nghiên cứu về việc sử dụng trigger mã nguồn PL/pgSQL để
CNGT đồng bộ cho KNT trong PostgreSQL [2, 3, 5], nhưng trigger mã nguồn
PL/pgSQL được đánh giá là có hiệu năng chưa cao ở hầu hết các xử lý so với
trigger trong ngôn ngữ C, trigger trên ngôn ngữ C thực thi nhanh hơn so với
trigger trên ngơn ngữ PL/pgSQL (khoảng 13%). Vì vậy, nghiên cứu này đề xuất
sử dụng ngôn ngữ C làm mã nguồn cho trigger và xây dựng mô-đun để sinh tự
động các trigger cho tất cả các BG tham gia vào truy vấn, phục vụ thực hiện
CNGT KNT trong cơ chế đồng bộ, như một phần của giao tác thực hiện thao tác
dữ liệu trong các BG.
Đã có các nghiên cứu [1, 2, 3] xây dựng được chương trình sinh mã nguồn
trigger tự động bằng ngôn ngữ C, triển khai các thuật toán CNGT KNT trên
HQTCSDL PostgreSQL. Tuy nhiên nghiên cứu này vẫn chưa quan tâm đến các
KNT được tạo bởi truy vấn lồng, truy vấn đệ quy, truy vấn bao gồm phép nối
ngồi. Có thể thấy truy vấn lồng (SubQuery) là một dạng truy vấn phổ biến, tần
suất xuất hiện cao, tuy nhiên các nghiên cứu về CNGT KNT cho PostgreSQL
đến nay vẫn chưa hỗ trợ dạng truy vấn này.
Vì vậy, tôi chọn đề tài “Xây dựng mô-đun sinh tự động mã nguồn trigger
trên ngôn ngữ C phục vụ cập nhật gia tăng, đồng bộ các khung nhìn thực với
truy vấn lồng cho PostgreSQL” làm khóa luận tốt nghiệp cao học.
2. Mục tiêu và nhiệm vụ đề tài
2.1. Mục tiêu
- Xây dựng chương trình sinh tự động mã nguồn trigger trên ngôn ngữ C
phục vụ cập nhật gia tăng, đồng bộ các khung nhìn thực với truy vấn lồng
trong PostgreSQL.
- Chương trình có khả năng sinh mã SQL cài đặt khung nhìn thực, trigger
trên các bảng gốc để cập nhật gia tăng, đồng bộ các khung nhìn thực.
Để đạt được mục tiêu chung đó, tác giả nghiên cứu các mục tiêu cụ thể như
sau:
- Nghiên cứu tổng quan về KNT, truy vấn lồng.
- Nghiên cứu cơ sở lý thuyết về cập nhật gia tăng, đồng bộ KNT với truy
vấn lồng.
- Nghiên cứu tổng quan về trigger trên C trong PostgreSQL.
- Xây dựng thuật toán cập nhật gia tăng KNT với truy vấn lồng.
3
- Xây dựng mô-đun sinh tự động mã nguồn trigger.
2.2. Nhiệm vụ
- Tìm hiểu các biên dịch và sử dụng trigger viết bằng ngơn ngữ C trên
PostgreSQL.
- Tìm hiểu và nghiên cứu cơ sở lý thuyết về cập nhật gia tăng, đồng bộ
KNT với truy vấn lồng.
- Khai thác các thuật tốn CNGT KNT đã có để ứng dụng vào đề tài, đặc
biệt là thuật toán CNGT KNT với truy vấn lồng.
3. Đối tượng và phạm vi nghiên cứu
3.1. Đối tượng nghiên cứu
- CSDL quan hệ, HQT CSDL quan hệ
- Ngơn ngữ lập trình C
- Trigger trên các HQT CSDL quan hệ
- Truy vấn lồng
- Khung nhìn thực
- Thuật tốn CNGT KNT với truy vấn lồng
3.2. Phạm vi nghiên cứu
- HQT CSDL PostgreSQL
- Kỹ thuật viết trigger cho PostgreSQL bằng ngôn ngữ C
- Cách sử dụng trigger được viết bằng ngơn ngữ C trên PostgreSQL
- Các thuật tốn CNGT cho KNT trên PostgreSQL
- Thuật toán CNGT KNT hỗ trợ truy vấn lồng
4. Phương pháp nghiên cứu
Về phương pháp nghiên cứu, tơi sử dụng hai phương pháp chính là nghiên
cứu lý thuyết và nghiên cứu thực nghiệm.
4.1. Phương pháp lý thuyết
Thu thập, chọn lọc, phân loại, ghi chú và nghiên cứu các tài liệu (sách, bài
báo, luận văn, trang web) có liên quan đến khung nhìn thực, HQTCSDL
PostgreSQL, cập nhật gia tăng KNT, đồng bộ KNT, sinh mã trigger trong
ngôn ngữ C.
4.2. Phương pháp thực nghiệm
Dựa trên lý thuyết đã nghiên cứu, tiến hành xây dựng chương trình sinh tự
động mã các trigger thực hiện cập nhật gia tăng khung nhìn thực với truy vấn
4
lồng trong hệ cơ sở dữ liệu PostgreSQL; thử nghiệm trên máy đơn và đánh
giá tốc độ cập nhật dữ liệu trên các bảng gốc (BG) có trigger cập nhật KNT.
5. Ý nghĩa khoa học và thực tiễn của đề tài
5.1. Ý nghĩa khoa học
- Đề xuất thuật toán cập nhật gia tăng KNT truy vấn lồng.
- Đề xuất thuật tốn sinh tự động mã nguồn các trigger trong ngơn ngữ C
phục vụ cập nhật gia tăng các bảng khung nhìn thực truy vấn lồng trong hệ
quản trị cơ sở dữ liệu PostgreSQL.
5.2. Ý nghĩa thực tiễn
Áp dụng chương trình vào cơ sở dữ liệu PostgreSQL nhằm làm tăng tốc
độ thực thi các truy vấn dữ liệu mà vẫn đảm bảo ràng buộc tồn vẹn dữ liệu.
Chương trình sinh tự động mã trigger C thực hiện CNGT KNT có tính ứng
dụng cao, giúp tiết kiệm thời gian và công sức của người quản trị CSDL khi
làm việc với HQTCSDL PostgreSQL cũng như các HQTCSDL mã nguồn mở
có hỗ trợ trigger trong ngơn ngữ C. Chương trình sinh tự động mã nguồn các
trigger có thể hỗ trợ các lập trình viên sinh mã trigger. Lập trình viên chỉ cần
điều chỉnh trigger được sinh ra theo ý muốn thay vì phải lập trình từ đầu.
6. Cấu trúc của luận văn
Ngồi phần mở đầu và kết luận, cấu trúc nội dung của luận văn bao gồm 3
chương:
Chương 1: Nghiên cứu tổng quan, chương này giới thiệu tổng quan về
ngơn ngữ lập trình C, truy vấn lồng và KNT, cập nhật gia tăng, đồng bộ KNT.
Trình bày các vấn đề liên quan đến trigger trên C trong PostgreSQL.
Chương 2: Khung nhìn thực trong PostgreSQL và thuật tốn cập nhật gia
tăng khung nhìn thực với truy vấn lồng, chương này trình bày các phương pháp
cập nhật KNT; phân tích thuật tốn cập nhật gia tăng KNT với truy vấn lồng.
Chương 3: Xây dựng chương trình sinh tự động mã nguồn các trigger
thực hiện cập nhật gia tăng khung nhìn thực với truy vấn lồng, chương này trình
bày cách cài đặt mơi trường CSDL và ngơn ngữ lập trình; xây dựng mơ-đun sinh
mã tự động trigger.
5
CHƯƠNG 1. NGHIÊN CỨU TỔNG QUAN
1.1. Tổng quan về ngôn ngữ lập trình C
1.1.1. Ngơn ngữ lập trình C
Ngơn ngữ lập trình C là một ngơn ngữ mệnh lệnh được phát triển từ đầu
thập niên 1970 bởi Dennis Ritchie, là một trong những ngôn ngữ phổ dụng
nhất. C là ngôn ngữ rất có hiệu quả và được ưa chuộng để viết các phần mềm
hệ thống, mặc dù nó cũng được dùng cho việc viết các ứng dụng. C là ngôn
ngữ lập trình tương đối nhỏ gọn vận hành gần với phần cứng, được tạo ra với
một mục tiêu là làm cho nó thuận tiện để viết các chương trình lớn.
Ngơn ngữ lập trình C là một ngơn ngữ lập trình hệ thống rất mạnh và rất
“mềm dẻo”, có một thư viện gồm rất nhiều các hàm (function) đã được tạo
sẵn. Người lập trình có thể tận dụng các hàm này để giải quyết các bài tốn
mà khơng cần phải tạo mới. Hơn thế nữa, ngôn ngữ C hỗ trợ rất nhiều phép
toán nên phù hợp cho việc giải quyết các bài tốn kỹ thuật có nhiều cơng thức
phức tạp. Ngồi ra, C cũng cho phép người lập trình tự định nghĩa thêm các
kiểu dữ liệu trừu tượng khác.
1.1.2. Đặc điểm của ngơn ngữ C
Ngơn ngữ C có các đặc điểm sau:
C là một ngôn ngữ đơn giản theo nghĩa là nó giúp ta cách tiếp cận có cấu
trúc (chia bài toán thành các phần khác nhau), tập hợp các hàm thư viện
phong phú, các kiểu dữ liệu, ...
Không giống như hợp ngữ, các chương trình C có thể thực thi trên nhiều
loại máy khác nhau mà khơng có sự thay đổi nào. Nhưng nó khơng phải là
độc lập về nền tảng như Java.
C cũng được sử dụng để lập trình bậc thấp. Nó được dùng để phát triển
các ứng dụng hệ thống như các nhân Hệ điều hành, trình điều khiển thiết bị,
... Nó cũng hỗ trợ những tính năng của ngơn ngữ bậc cao. Đó là tại sao được
gọi là ngơn ngữ bậc trung.
C là ngơn ngữ lập trình theo nghĩa chúng ta chia chương trình thành các
phần bằng cách sử dụng hàm. Vì thế, nó dễ hiểu và dễ chỉnh sửa.
C cung cấp nhiều hàm có sẵn giúp việc phát triển các ứng dụng trở nên
nhanh chóng hơn.
6
Nó hỗ trợ nhiều tính năng của Cấp phát bộ nhớ động. Trong ngơn ngữ C,
chúng ta có thể giải phóng một bộ nhớ được cấp phát tại thời điểm bất kỳ
bằng cách gọi hàm free().
Quá trình biên dịch và thực thi của ngôn ngữ C rất nhanh trong thời gian
rất ngắn.
C cung cấp tính năng con trỏ, chúng ta có thể tương tác trực tiếp với bộ
nhớ bằng việc sử dụng con trỏ. Chúng ta có thể sử dụng con trỏ cho bộ nhớ,
cấu trúc, hàm, mảng, ...
Trong C, chúng ta có thể gọi hàm ngay bên trong bản thân hàm đó. Nó
cung cấp những mã có khả năng sử dụng lại cho mỗi hàm.
Ngơn ngữ C có khả năng mở rộng vì nó dễ dàng nhận một tính năng mới.
1.2. Tổng quan về truy vấn lồng
1.2.1. Đặc điểm của truy vấn lồng
Là dạng truy vấn mà câu lệnh Select lồng trong câu lệnh Select.
Câu lệnh Select bên ngoài gọi là truy vấn ngoài
Câu lệnh Select bên trong gọi là truy vấn trong hay truy vấn con
Có 2 loại:
- Loại 1: Truy vấn con nằm trong mệnh đề WHERE
SELECT <danh sách cột>
FROM <table_1> INNER JOIN <table_2> ON <điều kiện nối>
INNER JOIN <table_3> ON <điều kiện nối>…
WHERE <so sánh tập hợp> (
SELECT <danh sách cột>
FROM < danh sách các bảng>
WHERE<điều kiện>)
- Loại 2: Truy vấn con nằm trong mệnh đề FROM
SELECT <danh sách cột>
FROM <bảng1>, <bảng 2>, (<truy vấn con>) AS<tên bảng>
WHERE <điều kiện>
7
Các câu lệnh Select có thể lồng nhau ở nhiều mức
Câu truy vấn con thường trả về một tập các giá trị
Mệnh đề Where của câu truy vấn ngoài
<biểu thức> <so sánh tập hợp> <truy vấn con>
So sánh tập hợp thường đi cùng với một số toán tử
-
-
-
-
IN
SELECT ma_sv, ten_sv
FROM sinh_vien
WHERE ma_lop IN (
SELECT ma_lop
FROM lop
WHERE ten_lop = ‘CNTT – 1’)
NOT IN
SELECT ma_sv, ten_sv
FROM sinh_vien
WHERE ma_lop NOT IN (
SELECT ma_lop
FROM lop
WHERE ten_lop = ‘CNTT – 1’)
ALL
SELECT ma_sv, ten_sv
FROM sinh_vien
WHERE ma_lop = ‘ML1’ AND ngay_sinh < ALL (
SELECT ngay_sinh
FROM sinh_vien
WHERE ma_lop = ‘ML1’
ANY hoặc SOME
SELECT ma_sv, ten_sv
FROM sinh_vien
WHERE ma_lop = ‘ML1’ AND ngay_sinh < ANY (
8
SELECT ngay_sinh
FROM sinh_vien
WHERE ma_lop = ‘ML1’
-
-
EXISTS
SELECT *
FROM sinh_vien
WHERE EXISTS (
SELECT *
FROM lop
WHERE ma_lop= sinh_vien.ma AND ma_lop = ‘ML1’)
NOT EXISTS
SELECT *
FROM sinh_vien
WHERE NOT EXISTS (
SELECT *
FROM lop
WHERE ma_lop= sinh_vien.ma AND ma_lop = ‘ML1’)
1.2.2. Phân loại
Dựa vào đặc điểm của câu truy vấn con người ta phân truy vấn lồng thành
2 loại chính:
- Truy vấn lồng phân cấp: Khi nội dung của câu truy vấn con độc lập với
câu truy vấn cha.
Cú pháp:
SELECT A
FROM X
WHERE … (SELECT B, C FROM Y) …
Ví dụ: Đưa ra mã, tên của những sinh viên thuộc lớp CNTT 1
SELECT ma_sv, ten_sv
FROM sinhvien
WHERE ma_lop IN (
SELECT ma_lop
FROM lop
WHERE ten_lop = ‘CNTT – 1’)
9
Ở ví dụ trên, câu truy vấn con SELECT ma_lop FROM lop WHERE
ten_lop = ‘CNTT – 1’ không sử dụng bất kỳ thành phần nào của câu truy vấn
cha. Do đó đây là một câu truy vấn lồng phân cấp.
- Truy vấn lồng tương quan: Khi nội dung của câu truy vấn con phụ thuộc
vào câu truy vấn cha.
Cú pháp:
SELECT A
FROM X
WHERE … (SELECT B, C FROM Y WHERE B = X.A) …
Ví dụ: Đưa ra mã, tên của những sinh viên thuộc lớp CNTT – 1
SELECT ma_sv, ten_sv
FROM sinhvien
WHERE EXISTS (
SELECT*
FROM Lop
WHERE ma_lop = sinhvien.ma_lop AND ten_lop = ‘CNTT – 1’)
Ở ví dụ này, câu truy vấn con SELECT*. FROM Lop. WHERE ma_lop =
sinhvien.ma_lop and ten_lop = ‘CNTT – 1’.
WHERE ma_lop = sinhvien.ma_lop có sử dụng thành phần của câu truy
vấn cha qua biểu thức so sánh ma_lop = sinhvien.ma_lop. Do đó, đây là một
câu truy vấn lồng tương quan.
1.3. Tổng quan về khung nhìn thực
1.3.1. Giới thiệu chung
Một khung nhìn (view) có thể được xem như là một bảng “ảo” trong cơ sở
dữ liệu có nội dung được định nghĩa thông qua một truy vấn (câu lệnh
SELECT). Điểm khác biệt giữa khung nhìn và bảng là khung nhìn không
được xem là một cấu trúc lưu trữ dữ liệu tồn tại trong cơ sở dữ liệu. Thực chất
dữ liệu quan sát được trong khung nhìn được lấy từ các bảng thông qua câu
lệnh truy vấn dữ liệu.
Bảng 1.2 dưới đây minh hoạ cho ta thấy khung nhìn có tên DSSV được
định nghĩa thông qua câu lệnh SELECT truy vấn dữ liệu trên hai bảng
SINHVIEN và LOP:
10
Bảng 1.1 – Mô tả thông tin chi tiết dữ liệu bảng SINHVIEN và bảng LOP
Từ hai bảng này, ta tạo được khung nhìn sau đây
Bảng 1.2 – Khung nhìn thực DSSV với dữ liệu lấy từ bảng SINHVIEN và LOP
11
Khung nhìn thực DSSV được mơ tả như sau:
CREATE VIEW DSSV(masv,hodem,ten,tuoi,tenlop) AS
SELECT masv, hodem, ten,DATEDIFF(YY, ngaysinh, GETDATE()),
tenlop
FROM sinhvien, lop
WHERE sinhvien.malop = lop.malop
Khi khung nhìn đã được định nghĩa, ta có thể sử dụng câu lệnh SELECT
để truy vấn dữ liệu từ khung nhìn như đối với các bảng. Khi trong câu truy
vấn xuất hiện khung nhìn, hệ quản trị CSDL sẽ dựa vào định nghĩa của khung
nhìn để chuyển yêu cầu truy vấn dữ liệu liên quan đến khung nhìn và việc
truy vấn dữ liệu được thực hiện bởi yêu cầu tương đương trên các bảng.
Việc sử dụng khung nhìn trong cơ sở dữ liệu đem lại các lợi ích sau đây:
bảo mật dữ liệu, đơn giản hoá các thao tác truy vấn dữ liệu, tập trung và đơn
giản hoà dữ liệu, độc lập dữ liệu.
Tuy nhiên, việc sử dụng khung nhìn cũng tồn tại một số nhược điểm:
- Do hệ quản trị cơ sở dữ liệu thực hiện việc chuyển đổi các truy vấn
trên khung nhìn thành những truy vấn trên các bảng cơ sở nên nếu một khung
nhìn được định nghĩa bởi một truy vấn phức tạp thì sẽ dẫn đến chi phí về mặt
thời gian khi thực hiện truy vấn liên quan đến khung nhìn sẽ lớn.
- Mặc dù thơng qua khung nhìn có thể thực hiện được thao tác bổ sung
và cập nhật dữ liệu cho bảng cơ sở nhưng chỉ hạn chế đối với những khung
nhìn đơn giản. Đối với những khung nhìn phức tạp thì thường khơng thực
hiện được; hay nói cách khác là dữ liệu trong khung nhìn là chỉ đọc.
Một khung nhìn có thể được cụ thể hóa bằng cách lưu trữ các bộ dữ liệu
của các khung nhìn trong cơ sở dữ liệu, được gọi là khung nhìn thực.
Khung nhìn thực (KNT - Materialized view) là một đối tượng trong cơ sở
dữ liệu (CSDL) dùng để lưu trữ kết quả thực thi của một truy vấn, giúp cải
thiện và nâng cao tốc độ thực thi đối với các truy vấn phức tạp, có tần suất sử
dụng cao trên một lượng dữ liệu lớn. Ý tưởng của KNT là dựa trên các bảng
kết quả sẵn có để trả lời truy vấn một cách nhanh chóng mà khơng cần thực
thi lại truy vấn. Đối với những truy vấn phức tạp bao gồm nhiều phép nối và
các hàm thống kê, hiệu quả sử dụng KNT càng rõ rệt đặc biệt khi áp dụng
12
trên một lượng dữ liệu đủ lớn, do đã bỏ qua các bước thực thi phép nối và các
hàm thống kê vốn là những thành phần chiếm nhiều chi phí trong q trình
thực thi truy vấn.
Giả sử ta có CSDL quản lý việc mua bán hàng hóa, với các bảng Order,
OrderItem và Customer được mơ tả như hình 1.1
Hình 1.1 Cơ sở dữ liệu quản lý đặt và giao hàng hóa. (Nguồn:
docs.microsoft.com)
Truy vấn tính tổng số tiền bán được của mỗi sản phẩm cũng như tổng số
lượng khách hàng đặt mua từng sản phẩm thuộc từng danh mục (category)
thuộc dạng phức tạp. Lúc này cần thực hiện phép nối giữa 3 bảng liên quan
đồng thời phải thực thi các hàm thống khê SUM (trường hợp tính tổng tiền)
và COUNT (trường hợp đếm số lượng khách hàng). Thời gian thực thi truy
vấn tỉ lệ thuận với độ lớn của dữ liệu từ mỗi bảng. Dữ liệu từ các BG càng
tăng theo thời gian, tốc độ thực hiện của truy vấn càng chậm.
13
Hình 1.2. Mơ tả hoạt động của HQT CSDL khi xuất hiện truy vấn yêu cầu
sử dụng dữ liệu khi không sử dụng KNT
Tuy nhiên, thông qua việc triển khai lưu trữ bằng KNT, người dùng có thể
dễ dàng có được kết quả và sử dụng nó một cách trực tiếp hoặc kết hợp nó với
các truy vấn khác. Lúc này, hiệu quả truy vấn xem như đạt mức tối đa, vì
HQT CSDL chỉ cần đọc từ bảng KNT kết quả của truy vấn thay vì phải thực
hiện phép nối và tính tốn các biểu thức thống kê, vốn là các thao tác chiếm
nhiều chi phí.
Hình 1.3 Cơ sở dữ liệu quản lý đặt và giao hàng hóa sử dụng khung nhìn
thực. (Nguồn: docs.microsoft.com)
14
Tuy nhiên, việc sử dụng KNT cũng có những nhược điểm, đó là: KNT
làm tiêu tốn khơng gian lưu trữ và phải được cập nhật khi các bảng chi tiết cơ
bản được sửa đổi.
1.3.2. Phân loại khung nhìn thực
Phân loại khung nhìn thực theo một số loại [15] như sau:
1.3.2.1. KNT bản sao (snapshot materialized view)
Mô tả KNT bản sao:
- Chiến lược cập nhật: kiểu KNT được cập nhật theo yêu cầu
- Cài đặt: KNT bản sao được cài đặt khá dễ dàng bằng cách gọi hàm
sau: refresh_matview(). Khi gọi hàm refresh_matview(), HQT CSDL sẽ
tự động xóa nội dung của KNT trước đó, rồi thực hiện truy vấn khung
nhìn và điền kết quả vào lại KNT với nội dung hiện tại của khung nhìn
đó.
1.3.2.2. KNT hăm hở (eager materialized view)
Mơ tả KNT hăm hở:
- Chiến lược cập nhật: Chúng được cập nhật ngay sau khi có bất kỳ
thay đổi nào được thực hiện với cơ sở dữ liệu đó mà sẽ ảnh hưởng đến
nó. Điều này được thực hiện với một hệ thống kích hoạt trên tất cả các
bảng cơ sở. Phụ thuộc vào hàm thay đổi được (như now()) sẽ gây ra
cho KNT trở nên sai lệch, nhưng có thể được sửa chữa với những làm
mới nhỏ, mà chỉ ảnh hưởng đến các hàng.
- Cài đặt: Việc thực thi KNT hăm hở được thực hiện qua hai hàm
sau:
o mv_refresh_row(PK): cập nhật bộ giá trị với khóa chính PK
o mv_refresh(): sử dụng nếu khung nhìn dựa vào hàm thay đổi được
như “now()”
Khi đó, các trigger với các bẫy sự kiện trong các HQT CSDL tương
ứng với các truy vấn INSERT, UPDATE và DELETE sẽ được gọi
thông qua hàm mv_refresh_row() một cách thích hợp.
1.3.2.3. KNT rất lười (very lazy materialized view):
Mơ tả khung nhìn thực rất lười như sau:
- Chiến lược cập nhật: Chúng sẽ ghi lại các hàng trong KNT cần
phải được cập nhật, nhưng sẽ không cập nhật cho đến khi hướng đến.
15
Điều này sẽ rất hữu ích nếu bạn đang cam kết nhiều giao dịch mà ảnh
hưởng đến KNT đó, nhưng không muốn thực sự cập nhật KNT cho đến
sau này. Chúng có chức năng tương đương với các KNT bản sao.
- Cài đặt: Việc cài đặt KNT kiểu rất lười qua các bước sau:
o Ghi tất cả những thay đổi trên các bảng cơ sở trong một bản ghi (sử
dụng một số trigger và hàm)
o Cài đặt một hàm "matview_refresh()" mà đọc bản ghi đó và cập
nhật KNT theo danh sách các thay đổi trong bản ghi
1.3.2.4. KNT lười (lazy materialized view):
Mơ tả khung nhìn thực lười như sau:
- Chiến lược cập nhật: Chúng sẽ ghi lại các hàng trong KNT cần
phải được cập nhật, và cập nhật chúng khi giao dịch được thực hiện.
Điều này hữu ích nếu nhiều sự thay đổi sẽ ảnh hưởng đến các hàng
giống nhau và cũng sẽ cho phép những thay đổi được thực hiện nhanh
hơn nhiều.
- Cài đặt: Tương tự như KNT rất lười, việc gọi và thực thi khung
nhìn thực thơng qua hàm “matview_refresh()”, trong đó cơ chế gọi sẽ
được gọi theo cam kết và không theo yêu cầu.
1.4. Tổng quan về cập nhật gia tăng, đồng bộ khung nhìn thực
1.4.1. Tổng quan về cập nhật gia tăng
Các quá trình cập nhật một KNT để đáp ứng với những thay đổi trong dữ
liệu cơ bản được gọi là cập nhật khung nhìn.
Có ba phương pháp cập nhật KNT, đó là hồn tồn (COMPLETE), gia
tăng (FAST hay còn gọi là INCREMENTAL) và ép buộc (FORCE):
- Cập nhật hoàn toàn thực tế là tạo lại KNT.
- Cập nhật gia tăng chỉ sửa đổi nội dung KNT tương ứng với các thay
đổi trong các bảng gốc. Thơng thường, cập nhật gia tăng địi hỏi chi phí tài
ngun rất nhỏ so với cập nhật hồn tồn.
- Cập nhật ép buộc nghĩa là khi có khả năng thì thực hiện cập nhật gia
tăng, cịn nếu khơng thì sử dụng cập nhật hồn tồn.
Để duy trì các bảng KNT trong trạng thái thực tiễn, cần phải cập nhật
chúng mỗi khi có sự thay đổi dữ liệu trong các bảng gốc. Phụ thuộc vào thời
hạn đưa các thay đổi vào các bảng KNT, các cơ chế cập nhật được phân ra
