5.23 Views in SQLViews are virtual

5.23 Views in SQL
Views are virtual tabular variables. This means that in SQL a view is referenced
for retrieval purposes in exactly the same way a tabular variable is referenced.
The only difference is that a view does not have a physical existence. It exists
only as a definition in the database catalog. We refer to “real” tabular variables
(that is, the tabular variables that have a physical existence in the database) as
base tabular variables.
Views are supported in both SQLPlus and in Transact SQL but not in the
current version (4.1) of MySQL.
To illustrate the notion of view, let us consider the following example.
Example 5.23.1 Suppose that we write:
create view STC as
select STUDENTS.name, GRADES.cno
from STUDENTS, GRADES
where STUDENTS.stno = GRADES.stno;
The select construct contained by this create view retrieves all pairs of
student names and course numbers such that the student whose name is s has
registered for the course c.
When this directive is executed by SQL, no data retrieval takes place. The
database system simply stores this definition in its catalog. The definition of the
view STC becomes a persistent object, that is, an object that exists after our
interaction with the DBMS has ceased. From a conceptual point of view, the
user treats STC exactly like any other tabular variable. Suppose, for instance
that we wish to retrieve the names of students who took cs110. In this case it
is sufficient to write the query:
5.23 Views in SQL 155
select name from STC where cno =’cs110’;
In reality, SQL combines this select phrase with the query just shown and
executes the modified query:
select STUDENTS.name from STUDENTS, GRADES
where STUDENTS.stno = GRADES.stno
and GRADES.cno =’cs110’;
The previous example shows that views in SQL play a role similar to the role
played by macros in programming languages.
Views are important for data security. A user who needs to have access only
to list of names of students and the courses they are taking needs to be aware
only of the existence of STC. If the user is authorized to use only select con-
structs, then the user can ignore whether STC is a table or a view. Confidential
data (such as grades obtained in specific courses) can be completely protected
in this manner. Also, the queries that this limited-access user may write are
simpler and easier to understand. No space is wasted with the view STC, and
the view remains current always, reflecting the contents of the tabular variables
STUDENTS and GRADES.
SQL treats views exactly as it treats the tabular variables as far as retrieval
is concerned. We can also delegate the select privilege to a view in exactly
the same way as we did for a tabular variable. For instance, if the user george
created the view STC, then he can give the select right to vanda by writing:
grant select on STC to vanda;
Consider now another example of view:
Example 5.23.2 The view SNA that contains the student number and the
names of students can be created by:
create view SNA as
select stno, name from STUDENTS
The purpose of this view is to insure privacy to students. Any user who has
access only to this view can retrieve the student number and name of a student,
but not the address of the student.
There is a fundamental difference between the views introduced in Exam-
ples 5.23.1 and 5.23.2, and this refers to the ways in which these two views
behave with respect to updates.
Suppose that the user wishes to insert the pair (7799, ’Jane Jones’) in the
view SNA. The user may ignore entirely the fact that SNA is not a base tabular
variable. On the other hand, the effect on the base tabular variable of this
insertion is unequivocally determined: the system inserts in the tabular variable
STUDENTS the tuple (7799, ’Jane Jones’, null, null, null). On the other hand,
we cannot insert a tuple in a meaningful way in the view STC introduced in
Example 5.23.1. Indeed if we attempt to insert a pair (s, c) in STC, then we have
to define the effect of this insertion on the base tabular variable. This is clearly
156 SQL — The Relational Language
impossible: we do not know what the student number is, what the identification
of the instructor is, etc. SQL forbids users to update views based on more than
one table (as STC is). Even if such updates would have an unambiguous effect
on the base tabular variable, this rule rejects any such update. Only some views
based on exactly one tabular variable can be updated. It is the responsibility
of the database administrator to grant to the user the right to update a view
only if that view can be updated.
If a view can be updated, then its behavior is somewhat different from the
base tabular variable on which the view is built. An update made to a view
may cause one or several tuples to vanish from the view, whenever we retrieve
the tuples of the view.
Example 5.23.3 Consider the view uppergr defined by:
create view UPPERGR as
select * from GRADES where grade > 75;
If we wish to examine the tuples that satisfy the definition of the view we use
the construction:
select * from UPPERGR;
that returns the result:
STNO EMPNO CNO SEM YEAR GRADE
---------- ----------- ----- ------ ---------- ----------
2661 019 cs110 FALL 1999 80
3566 019 cs110 FALL 1999 95
5544 019 cs110 FALL 1999 100
3566 019 cs240 SPRING 2000 100
2415 019 cs240 SPRING 2000 100
5571 234 cs410 SPRING 2000 80
1011 019 cs210 FALL 2000 90
3566 019 cs210 FALL 2000 90
5571 019 cs210 SPRING 2001 85
1011 056 cs240 SPRING 2001 90
4022 056 cs240 SPRING 2001 80
2661 234 cs310 SPRING 2001 100
The update construction:
update UPPERGR
set grade = 70
where stno = ’2661’ and empno = ’019’ and cno = ’cs110’
and sem = ’FALL’ and year = 1999;
makes the first row disappear, since it no longer satisfies the definition of the
view. Indeed, if we use again the same query on UPPERGR, we obtain:
STNO EMPNO CNO SEM YEAR GRADE

ผลลัพธ์ (ไทย) 1:

5.23 มุมมองใน SQLมุมมองเป็นเสมือนตัวแปรตาราง หมายความ ว่า ใน SQL มุมอ้างอิงประสงค์เรียกว่าแบบเดียวกับ ตัวแปรตารางอ้างอิงข้อแตกต่างอยู่ที่มุมมองไม่มีอยู่จริง มันมีอยู่เป็นข้อกำหนดในแค็ตตาล็อกฐานข้อมูลเท่านั้น เราหมายถึงตัวแปรตาราง "จริง"(นั่นคือ ตารางตัวแปรที่มีอยู่จริงในฐานข้อมูล) เป็นตัวแปรตารางพื้นฐานสนับสนุนมุมมอง ใน SQLPlus ทั้งสอง และ ใน Transact SQL แต่ไม่ในการรุ่นปัจจุบัน (4.1) ของ MySQLเพื่อแสดงแนวคิดของมุมมอง ให้เราพิจารณาตัวอย่างต่อไปนี้ตัวอย่าง 5.23.1 สมมติว่า เราเขียน:สร้างมุมมอง STC เป็นเลือก STUDENTS.name, GRADES.cnoจากนักเรียน เกรดที่ STUDENTS.stno = GRADES.stnoสร้างเลือกมุมมองนี้สร้างอยู่ดึงคู่ทั้งหมดชื่อนักเรียนและหลักสูตรตัวเลขดังกล่าวที่มีนักเรียนที่มีชื่อคือ sลงทะเบียนสำหรับหลักสูตร cคำสั่งนี้จะใช้ โดย SQL เรียกข้อมูลไม่เกิดขึ้น ที่ระบบฐานข้อมูลจัดเก็บคำนิยามนี้ในแค็ตตาล็อกของแค่ คำจำกัดความของการดู STC กลายเป็น วัตถุแบบถาวร คือ วัตถุที่อยู่หลังเราติดต่อกับ DBMS มีเพิ่ม จากแนวคิดจุดของมุมมอง การผู้ปฏิบัติ STC เหมือนแปรตารางอื่น ๆ สมมติว่า เช่นที่เราต้องการเรียกชื่อของนักเรียนที่ cs110 ในกรณีนั้นเพียงพอที่จะเขียนแบบสอบถาม:5.23 มุมมองใน SQL 155เลือกชื่อจาก STC ที่ซีเอ็นโอ = 'cs110'ในความเป็นจริง SQL รวมวลีนี้เลือกแบบสอบถามเพียงแสดง และดำเนินการปรับเปลี่ยนแบบสอบถาม:เลือก STUDENTS.name จากนักเรียน เกรดที่ STUDENTS.stno = GRADES.stnoและ GRADES.cno = 'cs110'ตัวอย่างก่อนหน้านี้แสดงว่า มุมมองใน SQL มีบทบาทคล้ายกับบทบาทเล่นจากแมโครในภาษาการเขียนโปรแกรมมุมมองที่มีความสำคัญสำหรับความปลอดภัยของข้อมูล ผู้ที่ต้องการเข้าถึงเท่านั้นรายชื่อนักเรียนและหลักสูตรพวกเขาจะมีต้องระวังเท่าของการดำรงอยู่ของ STC ถ้าผู้ได้รับอนุญาตให้ใช้ เฉพาะเลือกคอน-structs แล้วผู้ใช้สามารถละเว้นว่า STC ตารางหรือมุมมอง เป็นความลับข้อมูล (เช่นเกรดได้รับในหลักสูตรเฉพาะ) สามารถได้รับอย่างสมบูรณ์ในลักษณะนี้ ยัง แบบสอบถามที่ผู้ใช้จำกัดการเข้าถึงนี้อาจเขียนเป็นเรียบง่าย และเข้าใจได้ง่ายขึ้น สิ้นเปลืองพื้นที่ไม่วิว STC และมุมมองยังคงปัจจุบันเสมอ สะท้อนให้เห็นถึงเนื้อหาของตัวแปรตารางนักเรียนและเกรดSQL จะมองเหมือนปฏิบัติต่อตัวแปรตารางเท่าที่เรียกนั้น เรายังสามารถมอบสิทธิ์เลือกมุมมองในทุกประการเหมือนกับทางเราได้ตัวแปรตาราง ตัวอย่าง ถ้าผู้ใช้จอร์จสร้างมุมมอง STC แล้วเขาจะให้สิทธิเลือกแวนด้า โดยเขียน:ให้เลือกใน STC กับแวนด้าพิจารณาตอนนี้อีกตัวอย่างหนึ่งของมุมมอง:ตัวอย่าง 5.23.2 ดู SNA ที่ประกอบด้วยจำนวนนักเรียนและชื่อของนักเรียนสามารถสร้างได้โดย:สร้างมุมมอง SNA เป็นเลือก stno ชื่อจากนักเรียนวัตถุประสงค์ของมุมมองนี้จะประกันความเป็นส่วนตัวนักศึกษา ผู้ใช้ใด ๆ ที่มีเข้าถึงเฉพาะในมุมมองนี้สามารถดึงข้อมูลจำนวนนักเรียนและชื่อนักเรียนแต่ไม่อยู่ของนักเรียนมีความแตกต่างพื้นฐานระหว่างมุมมองที่นำมาใช้ในการสอบples 5.23.1 และ 5.23.2 และนี้หมายถึงวิธีการเหล่านี้ที่สองมุมมองทำงานกับโปรแกรมปรับปรุงสมมติว่า ผู้ใช้ต้องการแทรกคู่ (7799, 'เจนโจนส์') ในการดู SNA ผู้ใช้อาจละเว้นทั้งข้อเท็จจริงว่า SNA ไม่ฐานตารางตัวแปร ในทางกลับกัน ผลตัวแปรตารางพื้นฐานนี้แทรกจะขึ้น unequivocally: ระบบจะใส่ในตัวแปรตารางนักเรียนทูเพิล (7799, 'Jane Jones', null นิพจน์ เป็น null ในทางตรงข้ามเราไม่สามารถแทรกทูเพิลในวิธีมีความหมายในมุมมอง STC แนะนำในตัวอย่าง 5.23.1 แน่นอนถ้าเราพยายามแทรกคู่ (s, c) ใน STC แล้วเรามีการกำหนดผลของการนี้แทรกตัวแปรตารางพื้นฐาน นี้ได้อย่างชัดเจน156 SQL คือภาษาสัมพันธ์กันเป็นไปไม่ได้: เราไม่ทราบจำนวนนักเรียนคืออะไร รหัสอะไรผู้สอนเป็น ฯลฯ SQL ห้ามปรามผู้ใช้สามารถปรับปรุงขึ้นอยู่กับมุมมองมากกว่าหนึ่งตาราง (เป็น STC) แม้ว่าการปรับปรุงดังกล่าวจะมีผลกระทบชัดเจนบนตัวแปรตารางพื้นฐาน กฎนี้ปฏิเสธการปรับปรุงดังกล่าว เฉพาะบางมุมมองขึ้นอยู่กับว่าหนึ่งสามารถปรับปรุงตัวแปรตาราง มันเป็นความรับผิดชอบของผู้ดูแลฐานข้อมูลให้แก่ผู้ใช้สิทธิในการปรับปรุงมุมมองถ้าสามารถปรับปรุงมุมมองนั้นถ้าสามารถปรับปรุงมุมมอง แล้วพฤติกรรมค่อนข้างแตกต่างจากการฐานตารางตัวแปรที่สร้างมุมมอง การปรับปรุงที่ทำกับมุมมองอาจทำให้หนึ่ง หรือหลาย tuples สูญจากมุมมอง เมื่อใดก็ ตามที่เราเรียกtuples ของมุมมองUppergr มุมมองที่กำหนดโดยพิจารณาตัวอย่าง 5.23.3:สร้างมุมมอง UPPERGR เป็นเลือก * จากเกรดซึ่งเกรด > 75ถ้าเราต้องการตรวจสอบ tuples ที่ตรงตามข้อกำหนดของมุมมองที่เราใช้การก่อสร้าง:เลือก * จาก UPPERGRที่ส่งกลับผลลัพธ์:STNO EMPNO ซีเอ็นโอ SEM ปีเกรด---------- ----------- ----- ------ ---------- ----------2661 019 cs110 ตกราคา 80 ปี 19993566 019 cs110 ตกราคา 95 ปี 19995544 019 cs110 ตกราคา 100 ปี 19993566 019 cs240 สปริง 2000 1002415 019 cs240 สปริง 2000 1005571 234 สปริง cs410 2000 801011 019 cs210 ตกราคา 2000 903566 019 cs210 ตกราคา 2000 905571 019 cs210 ฤดูใบไม้ผลิ 2001 851011 056 cs240 ฤดูใบไม้ผลิ 2001 904022 056 cs240 ฤดูใบไม้ผลิ 2001 802661 234 cs310 สปริง 100 ปี 2001ก่อสร้างปรับปรุง:อัพเด UPPERGRตั้งค่าระดับ = 70ที่ stno = '2661' และ empno = '019' และซีเอ็นโอ = 'cs110'และ sem = 'ตก' และปี 1999 =ทำให้แถวแรกที่หายไป เนื่องจากมันไม่เป็นไปตามข้อกำหนดของการดู แน่นอน ถ้าเราใช้อีกแบบสอบถาม UPPERGR เราขอรับ:STNO EMPNO ซีเอ็นโอ SEM ปีเกรด

ผลลัพธ์ (ไทย) 2:

5.23 ครั้งใน SQL
ครั้งเป็นตัวแปรตารางเสมือน ซึ่งหมายความว่าใน SQL มุมมองที่มีการอ้างอิง
เพื่อวัตถุประสงค์ในการดึงตรงเช่นเดียวกับตัวแปรตารางมีการอ้างอิง.
ความแตกต่างเพียงอย่างเดียวคือมุมมองที่ไม่ได้มีการดำรงอยู่ทางกายภาพ มันมีอยู่
เพียง แต่เป็นความหมายในแคตตาล็อกฐานข้อมูล เราหมายถึง "ของจริง" ตัวแปรตาราง
(นั่นคือตัวแปรตารางที่มีการดำรงอยู่ทางกายภาพในฐานข้อมูล) เป็น
ตัวแปรตารางฐาน.
ผู้เข้าชมได้รับการสนับสนุนทั้งใน SQLPlus และในการทำธุรกรรมของ SQL แต่ไม่ได้อยู่ใน
รุ่นปัจจุบัน (4.1) ของ MySQL .
เพื่อแสดงให้เห็นความคิดของมุมมองให้เราพิจารณาตัวอย่างต่อไปนี้.
5.23.1 ตัวอย่างสมมติว่าเราเขียน:
สร้างมุมมองที่เป็นเอสทีซี
เลือก STUDENTS.name, GRADES.cno
จากนักเรียน, การเรียน
ที่ STUDENTS.stno = GRADES.stno;
เลือกสร้างที่มีอยู่โดยสร้างมุมมองนี้จะเรียกคู่ของ
ชื่อนักเรียนและตัวเลขดังกล่าวแน่นอนว่านักเรียนที่มีชื่อ S ได้
ลงทะเบียนสำหรับการเรียนการสอนค.
เมื่อสั่งนี้จะถูกดำเนินการโดย SQL, การดึงข้อมูลไม่เกิดขึ้น
ระบบฐานข้อมูลเพียงเก็บความหมายในแคตตาล็อกนี้ ความหมายของ
เอสทีซีวิวจะกลายเป็นวัตถุถาวรที่เป็นวัตถุที่มีอยู่หลังจากที่เรา
มีปฏิสัมพันธ์กับ DBMS ได้หยุด จากจุดแนวความคิดในมุมมองของ
ผู้ใช้เอสทีซีถือว่าเหมือนกับตัวแปรตารางอื่น ๆ สมมติเช่น
ที่เราต้องการที่จะดึงชื่อของนักเรียนที่เข้ามา cs110 ในกรณีนี้มัน
จะเพียงพอที่จะเขียนแบบสอบถาม:
5.23 ครั้งใน SQL 155
เลือกชื่อจากเอสทีซีที่ CNO = 'cs110';
ในความเป็นจริงนี้ SQL รวมวลีเลือกด้วยแบบสอบถามแสดงเพียงและ
ดำเนินการแก้ไขแบบสอบถาม:
เลือก STUDENTS.name จากนักเรียน, การเรียน
ที่ STUDENTS.stno = GRADES.stno
และ GRADES.cno = 'cs110';
ตัวอย่างก่อนหน้านี้แสดงให้เห็นว่ามุมมองใน SQL มีบทบาทคล้ายกับบทบาท
. เล่นโดยแมโครในการเขียนโปรแกรมภาษา
อ่านมีความสำคัญต่อความปลอดภัยของข้อมูล ผู้ใช้ที่ต้องการให้มีการเข้าถึงเท่านั้น
ที่จะมีรายชื่อของนักเรียนและหลักสูตรที่พวกเขามีการตอบสนองความต้องการที่จะทราบ
เพียงอย่างเดียวของการดำรงอยู่ของเอสทีซี หากผู้มีอำนาจที่จะใช้เพียงเลือกทำา
structs แล้วผู้ใช้สามารถละเว้นไม่ว่าจะเป็นเอสทีซีเป็นตารางหรือมุมมอง ความลับของ
ข้อมูล (เช่นเกรดที่ได้รับในหลักสูตรเฉพาะ) สามารถป้องกันได้อย่างสมบูรณ์
ในลักษณะนี้ นอกจากนี้คำสั่งที่ว่านี้ผู้ใช้ จำกัด การเข้าถึงอาจเขียนเป็น
ง่ายและง่ายต่อการเข้าใจ ไม่มีพื้นที่จะสูญเสียกับเอสทีซีมุมมองและ
มุมมองที่ยังคงอยู่ในปัจจุบันมักจะสะท้อนให้เห็นถึงเนื้อหาของตัวแปรตาราง
นักเรียนและการเรียน.
SQL มุมมองถือว่าตรงตามที่ให้การปฏิบัติต่อตัวแปรตารางเท่าที่ดึง
เป็นห่วง นอกจากนี้เรายังสามารถมอบหมายสิทธิ์เลือกไปยังมุมมองในตรง
เช่นเดียวกับที่เราทำสำหรับตัวแปรตาราง ตัวอย่างเช่นหากผู้ใช้ george
สร้างมุมมอง STC แล้วเขาสามารถให้สิทธิเลือกเพื่อแวนด้าโดยการเขียน:
ทุนเลือกใน STC เพื่อแวนด้า;
พิจารณาในขณะนี้ตัวอย่างของมุมมองอื่น:
ตัวอย่าง 5.23.2 SNA มุมมองที่มีจำนวนนักเรียน และ
ชื่อของนักเรียนที่สามารถสร้างขึ้นโดย:
สร้างมุมมอง SNA เป็น
stno เลือกชื่อจากนักเรียน
วัตถุประสงค์ของมุมมองนี้คือการประกันความเป็นส่วนตัวให้กับนักเรียน ผู้ใช้ที่มี
การเข้าถึงเฉพาะมุมมองนี้สามารถดึงข้อมูลจำนวนนักเรียนและชื่อของนักเรียน
แต่ไม่อยู่ของนักเรียน.
มีความแตกต่างพื้นฐานระหว่างมุมมองที่นำมาใช้ใน Exam- เป็น
Ples 5.23.1 และ 5.23.2 และ นี้หมายถึงวิธีการที่ทั้งสองมุมมองที่
มีลักษณะการทำงานที่เกี่ยวกับการปรับปรุง.
สมมติว่าผู้ใช้มีความประสงค์จะใส่คู่ (7799, 'เจนโจนส์) ใน
มุมมอง SNA ผู้ใช้อาจไม่สนใจทั้งหมดความจริงที่ว่า SNA ไม่ตารางฐาน
ตัวแปร ในทางตรงกันข้าม, ผลกระทบต่อตัวแปรตารางฐานนี้
แทรกจะถูกกำหนดอย่างแจ่มแจ้ง: แทรกระบบในตัวแปรตาราง
นักเรียน tuple (7799, 'เจนโจนส์', null, null, null) ในทางตรงกันข้าม,
เราไม่สามารถแทรก tuple ในทางที่มีความหมายในมุมมอง STC นำมาใช้ใน
ตัวอย่าง 5.23.1 อันที่จริงถ้าเราพยายามที่จะแทรกคู่ (s ค) ในเอสทีซีแล้วเรามี
การกำหนดผลของการแทรกนี้บนตัวแปรตารางฐาน นี้จะชัดเจน
156 SQL - ภาษาเชิงสัมพันธ์
เป็นไปไม่ได้เราไม่ทราบว่าจำนวนนักเรียนเป็นสิ่งที่บัตรประจำตัว
ของผู้สอนคือ ฯลฯ SQL ห้ามผู้ใช้สามารถอัปเดตขึ้นอยู่กับมุมมองมากกว่า
หนึ่งตาราง (เช่นเอสทีซีเป็น) แม้ว่าการปรับปรุงดังกล่าวจะมีผลกระทบที่ชัดเจน
เกี่ยวกับตัวแปรตารางฐานกฎนี้ปฏิเสธใด ๆ การปรับปรุงดังกล่าว เพียงมุมมองบางอย่าง
ขึ้นอยู่กับว่าหนึ่งตัวแปรตารางสามารถปรับปรุงได้ มันเป็นความรับผิดชอบ
ของผู้ดูแลระบบฐานข้อมูลเพื่อให้กับผู้ใช้สิทธิในการปรับปรุงมุมมอง
เฉพาะในกรณีที่เห็นว่าสามารถปรับปรุง.
ถ้ามีมุมมองที่สามารถปรับปรุงได้แล้วพฤติกรรมของมันจะค่อนข้างแตกต่างจาก
ตัวแปรตารางฐานที่ดูเป็น สร้าง การปรับปรุงที่เกิดขึ้นกับมุมมองที่
อาจก่อให้เกิดสิ่งอันดับหนึ่งหรือหลายที่จะหายไปจากมุมมองเมื่อใดก็ตามที่เราเรียก
tuples ของมุมมอง.
ตัวอย่าง 5.23.3 พิจารณามุมมอง uppergr กำหนดโดย:
UPPERGR สร้างมุมมองที่เป็น
* เลือกจากการเรียนที่คะแนน> 75 ;
ถ้าเราต้องการที่จะตรวจสอบ tuples ที่ตอบสนองความหมายของมุมมองที่เราใช้ใน
การก่อสร้าง:
* เลือกจาก UPPERGR;
ที่ส่งกลับผล:
STNO EMPNO CNO SEM ชั้นปี
---------- ---- ------- ----- ------ ---------- ----------
2661 019 cs110 FALL 1999 80
3566 019 cs110 FALL 1999 95
5544 019 cs110 FALL 1999 100
3566 019 cs240 SPRING 2,000 100
2,415 019 cs240 SPRING 2000 100
5571 234 cs410 SPRING 2000 80
1011 019 cs210 ฤดูใบไม้ร่วง 2000 90
3566 019 cs210 ฤดูใบไม้ร่วง 2000 90
5571 019 cs210 SPRING 2001 85
1011 056 cs240 SPRING 2001 90
056 4022 cs240 SPRING 2001 80
2661 234 CS310 SPRING 2001 100
ก่อสร้างปรับปรุง:
ปรับปรุง UPPERGR
ชุดชั้นประถมศึกษาปี 70 =
ที่ stno = '2661' และ empno = '019' และ CNO = 'cs110'
และ SEM = 'FALL' และในปี = 1999;
ทำให้ แถวแรกหายไปเพราะมันไม่ตรงกับความหมายของ
มุมมอง อันที่จริงถ้าเราใช้อีกครั้งแบบสอบถามเดียวกันใน UPPERGR เราได้รับ:
STNO EMPNO CNO SEM ปีระดับการศึกษา

ผลลัพธ์ (ไทย) 3:

มุมมองในมุมมอง SQL

5.23 ตัวแปรตารางเสมือน ซึ่งหมายความว่าใน SQL มุมมองเป็นอ้างอิง
เพื่อสืบค้นในตรงทางเดียวกันคือตัวแปรตารางอ้างอิง .
ความแตกต่างเพียงอย่างเดียวคือว่า ดูไม่มีการดำรงอยู่ทางกายภาพ มันมีอยู่จริง
เป็นเพียงนิยามในฐานข้อมูลแคตตาล็อก เราดู " จริง " ตารางตัวแปร
( นั่นคือตัวแปรตารางที่มีอยู่ในฐานข้อมูลทางกายภาพ )

ฐานตัวแปรตาราง มุมมองที่ได้รับการสนับสนุนทั้งในประเทศและ sqlplus ใน SQL แต่ไม่ใช่ใน
รุ่นปัจจุบัน ( 4.1 ) ของ MySQL .
แสดงให้เห็นถึงความคิด มุมมอง ให้เราพิจารณาตัวอย่างต่อไปนี้ สมมติว่าเราเขียน 5.23.1
ตัวอย่างเช่น :

เลือกสร้างวิว STC เป็น students.name เกรด เกรด

CNO จากนักเรียนที่ students.stno = เกรด stno ;
ที่มีอยู่โดยเลือกสร้างนี้สร้างวิวเรียกคู่ทั้งหมดของ
ชื่อนักเรียนและตัวเลขแน่นอน เช่น นักเรียนที่ชื่อ S มี
ลงทะเบียนเรียน C .
เมื่อคำสั่งนี้ดำเนินการโดย SQL , ไม่มีข้อมูลการใช้สถานที่
ฐานข้อมูลเพียงแค่ร้านค้าคำนิยามนี้ในแคตตาล็อก นิยามของ
ดูที่ STC กลายเป็นวัตถุถาวรที่เป็นวัตถุที่มีอยู่หลังจากการโต้ตอบของเรา
กับ DBMS ได้หยุด . แนวคิดจากจุดของมุมมอง ,
ผู้ใช้ถือว่า STC เหมือนตัวแปรตารางใด ๆอื่น ๆ สมมติว่าตัวอย่างเช่น
ที่เราต้องการดึงชื่อของนักเรียนที่ได้รับ cs110 . ในกรณีนี้มัน
เพียงพอที่จะเขียนแบบสอบถาม : 5.23 ในมุมมอง SQL 155

เลือกชื่อจาก stc ที่ CNO = 'cs110 ' ;
ในความเป็นจริง , SQL รวมนี้เลือกวลีที่มีแบบสอบถามจะแสดง และสามารถดัดแปลงแบบสอบถาม :

เลือก students.name จากนักเรียน เกรดที่ students.stno =

= grades.cno เกรด stno และ 'cs110 ' ;
ตัวอย่างก่อนหน้านี้แสดงให้เห็นว่าในมุมมอง SQL บทบาทคล้ายกับบทบาทที่เล่นโดยแมโครใน

โปรแกรมภาษามุมมองที่สำคัญสำหรับการรักษาความปลอดภัยข้อมูล ผู้ใช้ที่ต้องมีการเข้าถึงเฉพาะ
เพื่อรายชื่อของนักเรียนและหลักสูตรที่พวกเขาจะต้องการที่จะตระหนักถึง
ของการดำรงอยู่ของ STC . หากผู้ใช้จะได้รับอนุญาตให้ใช้เพียงเลือกคอน -
structs จากนั้นผู้ใช้สามารถละเว้นไม่ว่า STC เป็นตารางหรือมุมมอง ข้อมูลที่เป็นความลับ
( เช่น เกรดที่ได้ในแต่ละคอร์ส ) สามารถได้รับการป้องกันอย่างสมบูรณ์
ในลักษณะนี้ นอกจากนี้ ข้อมูลที่ จำกัด การเข้าถึงของผู้ใช้นี้อาจเขียนเป็น
ที่เรียบง่ายและง่ายต่อการเข้าใจ ไม่มีพื้นที่สูญเปล่ากับมุมมอง STC และ
มุมมองยังคงอยู่ในปัจจุบันมักจะสะท้อนให้เห็นถึงเนื้อหาของตัวแปรและตารางนักเรียน

เกรด ถือว่ามุมมอง SQL ตามที่มันถือว่าตัวแปรตาราง เท่าที่สืบค้น
เป็นกังวลนอกจากนี้เรายังสามารถมอบสิทธิพิเศษ เลือกดูตรง
แบบเดียวกับที่เราทำสำหรับตัวแปรของตาราง ตัวอย่างเช่นหากผู้ใช้จอร์จ
สร้างมุมมองที่ STC แล้วเขาจะให้เลือกใช่ แวนด้า โดยเขียน :
ให้เลือกที่ STC กับแวนด้า ;
พิจารณาอีกตัวอย่างของมุมมอง :
ตัวอย่าง 5.23.2 วิว SNA ที่มีจำนวนนักเรียนและรายชื่อนักเรียนที่สามารถสร้าง

โดย :