Relational Algebra and Relational Calculusجەبری پەیوەندیدار و ژمێرکاریی پەیوەندیدار

A query language is a language for asking a database for data and for changing it. SQL is the one you use every day. A query language is not a general programming language. It rests on formal logic, which lets the DBMS rewrite a query into a faster one that gives the same answer. It is made for reaching large amounts of data easily and quickly, not for heavy calculations. The two formal languages of this lesson are deliberately not 'Turing complete': they cannot express every possible program. (Modern SQL has extra features, such as recursive queries written with WITH RECURSIVE, that go beyond them.)

زمانی پرس زمانێکە بۆ داواکردنی دراوە (Data) لە بنکەدراوە (Database) و گۆڕینی. SQL ئەو زمانەیە کە هەموو ڕۆژێک بەکاری دەهێنیت. زمانی پرس زمانێکی بەرنامەسازیی (Programming language) گشتی نییە. لەسەر لۆجیکی فەرمی دامەزراوە، بۆیە سیستەمی بەڕێوەبردنی بنکەدراوە (DBMS) دەتوانێت پرسێک بگۆڕێت بۆ یەکێکی خێراتر کە هەمان وەڵام دەدات. بۆ گەیشتن بە بڕێکی زۆری دراوە بە ئاسانی و خێرایی دروست کراوە، نەک بۆ ژمێرکاریی قورس. دوو زمانە فەرمییەکەی ئەم وانەیە بە ئەنقەست Turing complete نین: ناتوانن هەموو بەرنامەیەکی شیاو دەرببڕن. (SQLـی ئەمڕۆ تایبەتمەندیی زیاتری هەیە، وەک WITH RECURSIVE، کە لەو دوو زمانە تێدەپەڕن.)

Under SQL lie two formal languages. Relational algebra is procedural (operational): a query is a list of steps that says how to get the answer, and the DBMS uses it to describe its execution plans. Relational calculus is declarative: a query describes what the answer must look like and leaves the 'how' to the system. History reflects both: SEQUEL (IBM, 1974), the first version of SQL, borrowed many ideas from the algebra, while QUEL, the language of the Ingres system, was built on tuple relational calculus. Today's SQL mixes both styles.

لە ژێر SQLـەوە دوو زمانی فەرمی هەن. جەبری پەیوەندیدار ڕێکارییە (زمانی ڕێکاری (Procedural language)): پرسێک لیستێکی هەنگاوەکانە کە دەڵێت چۆن وەڵامەکە وەربگرین و سیستەمی بەڕێوەبردنی بنکەدراوە بۆ وەسفکردنی پلانەکانی جێبەجێکردنی بەکاری دەهێنێت. ژمێرکاریی پەیوەندیدار ڕوونکەرەوەیە (زمانی ڕوونکردنەوە (Declarative language)): پرسێک وەسفی دەکات وەڵامەکە دەبێت چی بێت و «چۆن»ـەکە بۆ سیستەمەکە جێ دەهێڵێت. مێژوو هەردووکیانی تێدایە: ⁦SEQUEL (IBM⁩، ⁦1974⁩)، یەکەم وەشانی SQL، زۆر بیرۆکەی لە جەبرەکەوە وەرگرت، بەڵام QUEL، زمانی سیستەمی Ingres، لەسەر ژمێرکاریی پەیوەندیداری تۆمار دروست کرا. SQLـی ئەمڕۆ هەردوو شێوازەکە تێکەڵ دەکات.

The Cartesian product of two sets is the set of all ordered pairs that take one element from each set. A tea house sells drinks D = {tea, coffee} and sweets K = {kleicha, baklava}. Then D × K = {(tea, kleicha), (tea, baklava), (coffee, kleicha), (coffee, baklava)}: every drink with every sweet. The order counts: K × D = {(kleicha, tea), (kleicha, coffee), (baklava, tea), (baklava, coffee)} has the same items in each pair, but the other way round.

لێکدانی دیکارتیـی دوو کۆمەڵە (Set)، کۆمەڵەی هەموو ئەو جووتە ڕیزکراوانەیە کە لە هەر کۆمەڵەیەک یەک توخم وەردەگرن. چایخانەیەک خواردنەوەی D = {tea, coffee} و شیرینیی K = {kleicha, baklava} دەفرۆشێت. ئەوکات D × K = {(tea, kleicha), (tea, baklava), (coffee, kleicha), (coffee, baklava)}: هەموو خواردنەوەیەک لەگەڵ هەموو شیرینییەک. ڕیزبەندی گرنگە: K × D = {(kleicha, tea), (kleicha, coffee), (baklava, tea), (baklava, coffee)} لە هەر جووتێکدا هەمان شتەکانی تێدایە، بەڵام بە پێچەوانەوە.

The domain of an attribute is the set of values it may hold: for credits, the whole numbers 1 to 6; for city, the city names. A relation is a subset of the Cartesian product of its attributes' domains: out of all possible combinations, the table keeps the ones that are true. That is why a table is called a relation, and why algebra can work on it.

بوار (Domain)ی خەسڵەتێک (Attribute) کۆمەڵەی ئەو نرخانەیە کە دەتوانێت هەڵیانبگرێت: بۆ credits، ژمارە تەواوەکانی 1 تا 6؛ بۆ city، ناوی شارەکان. relation ژێرکۆمەڵەیەکە لە لێکدانی دیکارتیی بوارەکانی خەسڵەتەکانی: لە نێوان هەموو تێکەڵە شیاوەکاندا، خشتەکە ئەوانە دەهێڵێتەوە کە ڕاستن. بۆیە بە خشتە دەوترێت relation و بۆیە جەبر دەتوانێت کاری لەسەر بکات.

Every algebra has two ingredients: the things it works on, called operands, and the ways of combining them, called operators. In school algebra the operands are numbers and + is an operator: 3 + 4 combines 3 and 4 into a new number, 7. In relational algebra the operands are relations (tables), and every operator gives back a relation. Because every result is again a table, operators can be nested and chained into bigger queries. This is called the closure property.

هەموو جەبرێک دوو پێکهاتەی هەیە: کارپێکراوەکان (Operand)، واتە ئەو شتانەی کاریان لەسەر دەکرێت، لەگەڵ کارپێکەرەکان، واتە ڕێگاکانی تێکەڵکردنیان. لە جەبری قوتابخانەدا کارپێکراوەکان ژمارەن و + کارپێکەرێکە: 3 + 4 ژمارەکانی 3 و 4 دەکاتە ژمارەیەکی نوێ، کە 7ـە. لە جەبری پەیوەندیداردا کارپێکراوەکان relationـن (خشتەکان) و هەموو کارپێکەرێک relationێک دەگەڕێنێتەوە. چونکە هەموو ئەنجامێک دیسان خشتەیە، کارپێکەرەکان دەتوانرێن یەک لەناو یەک دابنرێن و پێکەوە ببەسترێن بۆ پرسی گەورەتر. ئەمە پێی دەوترێت تایبەتمەندیی داخراوی (Closure property).

Codd took the set operators of mathematics (product, union, intersection, difference) and added select, project, join and divide. Later authors extended the algebra with the outer join and the outer union (a union of two tables with different columns, the gaps filled with NULL).

کۆد کارەکانی کۆمەڵەی (Set operation) بیرکاری (لێکدانی دیکارتی، یەکگرتن، یەکتربڕین، جیاوازیی کۆمەڵە) وەرگرت و هەڵبژاردن، دەرهێنانی ستوون، لێکبەستن و دابەشکردنی بۆ زیاد کرد. نووسەرانی دواتر جەبرەکەیان بە لێکبەستنی دەرەکی و یەکگرتنی دەرەکی (outer union) فراوان کرد (یەکگرتنی دوو خشتە بە ستوونی جیاوازەوە، کە بۆشاییەکان بە NULL پڕ دەکرێنەوە).

All the examples use this small copy of the university database. Hana (105) has not enrolled in anything yet, and nobody takes NW201 — you will see why that matters for outer joins.

هەموو نموونەکان ئەم کۆپییە بچووکەی بنکەدراوەی زانکۆ بەکار دەهێنن. هانا ⁦(105)⁩ هێشتا لە هیچ وانەیەکدا تۆمار نەکراوە و کەس ⁦NW201⁩ ناخوێنێت — دەبینیت بۆچی ئەمە بۆ لێکبەستنە دەرەکییەکان گرنگە.

Selection σ condition (R) keeps only the rows of R for which the condition is true. The condition is built from comparisons (=, ≠, <, >, ≤, ≥) joined with AND (∧), OR (∨) and NOT (¬). The result has the same columns as R.

هەڵبژاردن σ condition (R) تەنها ئەو ڕیزانەی R دەهێڵێتەوە کە مەرجەکە بۆیان ڕاستە. مەرجەکە لە بەراوردەکان (=، ≠، <، >، ≤، ≥) دروست دەبێت کە بە AND (∧)، OR (∨) و NOT (¬) پێکەوە دەبەسترێن. ئەنجامەکە هەمان ستوونەکانی Rـی هەیە.

With ∧ both parts must be true: σ dept = 'CS' ∧ city = 'Duhok' (Student) gives only Karwan (103). With ∨ one part is enough: σ dept = 'IT' ∨ city = 'Duhok' (Student) gives Shilan, Karwan and Hana.

بە ∧ دەبێت هەردوو بەشەکە ڕاست بن: σ dept = 'CS' ∧ city = 'Duhok' (Student) تەنها کاروان ⁦(103)⁩ دەدات. بە ∨ یەک بەش بەسە: σ dept = 'IT' ∨ city = 'Duhok' (Student) شیلان، کاروان و هانا دەدات.

Projection π column-list (R) keeps only the listed columns, in that order. The schema of the result is exactly that list. Because relational algebra works with sets, duplicate rows are removed: π dept (Student) gives three rows — CS, IT, SE — although five students have a department.

دەرهێنانی ستوون π column-list (R) تەنها ستوونە دیاریکراوەکان بەو ڕیزبەندییە دەهێڵێتەوە. سکیمای ئەنجامەکە ڕێک ئەو لیستەیە. چونکە جەبری پەیوەندیدار لەگەڵ کۆمەڵەدا کار دەکات، ڕیزە دووبارەکان لادەبرێن: π dept (Student) سێ ڕیز دەدات — CS، IT، SE — هەرچەندە پێنج قوتابی بەشیان هەیە.

Because every result is a table, operators can be put inside each other. 'The names of the students from Sulaimani' is a selection followed by a projection: first choose the rows, then the columns. Read the expression from the inside out:

چونکە هەموو ئەنجامێک خشتەیە، کارپێکەرەکان دەتوانرێن یەک لەناو یەک دابنرێن. «ناوی ئەو قوتابیانەی خەڵکی سلێمانین» هەڵبژاردنە و پاشان دەرهێنانی ستوون: سەرەتا ڕیزەکان هەڵبژێرە، پاشان ستوونەکان. دەربڕینەکە لە ناوەوە بۆ دەرەوە بخوێنەوە:

Two student clubs keep member lists with the same columns: Robotics(student_no, name) = {101 Aram, 103 Karwan, 104 Dilan} and Debate(student_no, name) = {102 Shilan, 103 Karwan}. Because the tables are relations (sets), the three set operations of mathematics (union, intersection and difference) work on them:

دوو یانەی قوتابیان لیستی ئەندامەکانیان بە هەمان ستوونەکان هەڵدەگرن: Robotics(student_no, name) = {⁦101 Aram, 103 Karwan, 104 Dilan⁩} و Debate(student_no, name) = {⁦102 Shilan, 103 Karwan⁩}. چونکە خشتەکان relationن (کۆمەڵەن)، سێ کارەکانی کۆمەڵەی بیرکاری (یەکگرتن، یەکتربڕین و جیاوازیی کۆمەڵە) لەسەریان کار دەکەن:

These operations need union-compatible tables: the same number of columns, and matching columns with compatible domains (types). Robotics ∪ Course makes no sense — a student number cannot be compared with a course code. And difference is not symmetric: R − S is usually not S − R.

ئەم کردانە پێویستیان بە گونجان بۆ یەکگرتن (Union compatibility) هەیە: هەمان ژمارەی ستوون و ستوونی بەرامبەر بە بوارەکانی (جۆری) گونجاو. Robotics ∪ Course هیچ واتایەکی نییە — ژمارەی قوتابی بە کۆدی وانە بەراورد ناکرێت. هەروەها جیاوازیی کۆمەڵە هاوسەنگ نییە: R − S زۆرجار وەک S − R نییە.

The Cartesian (cross) product R × S pairs every row of R with every row of S. The result has all the columns of both tables, and its number of rows is rows(R) × rows(S). Debate × Course has 2 × 4 = 8 rows:

لێکدانی دیکارتی R × S هەموو ڕیزێکی R لەگەڵ هەموو ڕیزێکی S جووت دەکات. ئەنجامەکە هەموو ستوونەکانی هەردوو خشتەکەی هەیە و ژمارەی ڕیزەکانی دەکاتە ژمارەی ڕیزەکانی R × ژمارەی ڕیزەکانی S. Debate × Course ⁦2 × 4 = 8⁩ ڕیزی هەیە:

On its own the product is rarely useful: most of these pairs mean nothing. Its value is as a building block for joins. It also causes name clashes: Student × Enrolled (5 × 7 = 35 rows) has two columns called student_no. The result keeps the attribute names where it can and needs a way to tell the two apart — the rename operator, next.

لێکدانی دیکارتی بە تەنها کەم بەسوودە: زۆربەی ئەم جووتانە هیچ واتایەکیان نییە. بەهاکەی وەک بەردی بناغەیە بۆ لێکبەستنەکان. هەروەها دەبێتە هۆی لێکچوونی ناو: Student × Enrolled (⁦5 × 7 = 35⁩ ڕیز) دوو ستوونی بە ناوی student_no هەیە. ئەنجامەکە تا بتوانێت ناوی خەسڵەتەکان دەهێڵێتەوە و پێویستی بە ڕێگایەک هەیە بۆ جیاکردنەوەی ئەو دووانە — ناونانەوە، لە پەڕەی داهاتوودا.

Rename gives a result, or its columns, new names. ρ S1 (Student) is the Student table called S1. ρ Club(no, member) (Robotics) renames both the table and its columns. Rename is needed when a table is combined with itself. Which pairs of students come from the same city?

ناونانەوە ناوی نوێ دەداتە ئەنجامێک یان ستوونەکانی. ρ S1 (Student) خشتەی Studentـە بە ناوی ⁦S1⁩. ρ Club(no, member) (Robotics) ناوی خشتەکە و ستوونەکانیشی دەگۆڕێت. ناونانەوە کاتێک پێویستە کە خشتەیەک لەگەڵ خۆیدا تێکەڵ بکرێت. کام جووتە قوتابی خەڵکی هەمان شارن؟

A join combines rows of two tables that belong together. Every join is a Cartesian product followed by a selection, written as one operation: the product makes all the pairs, the selection keeps the meaningful ones. There are three kinds, from the most general to the most automatic: the condition (theta) join, the equijoin and the natural join. Outer joins add the rows that found no partner.

لێکبەستن ڕیزەکانی دوو خشتە کە پێکەوە پەیوەندییان هەیە تێکەڵ دەکات. هەموو لێکبەستنێک لێکدانی دیکارتییە و پاشان هەڵبژاردن، کە وەک یەک کار دەنووسرێت: لێکدانی دیکارتی هەموو جووتەکان دروست دەکات، هەڵبژاردن ئەوانە دەهێڵێتەوە کە واتایان هەیە. سێ جۆر هەن، لە گشتیترینەوە بۆ خۆکارترین: لێکبەستنی مەرجدار (Conditional join) ⁦(theta)⁩، لێکبەستنی یەکسانی و لێکبەستنی سروشتی. لێکبەستنە دەرەکییەکان ئەو ڕیزانەش زیاد دەکەن کە هاوتایان نەدۆزیوەتەوە.

R ⋈θ S = σθ (R × S), where θ (theta) is any condition. The condition need not be an equality. Which course has more credits than another? ρ C1 (Course) ⋈ C1.credits < C2.credits ρ C2 (Course):

R ⋈θ S = σθ (R × S)، کە θ ⁦(theta)⁩ هەر مەرجێکە. پێویست ناکات مەرجەکە یەکسانی بێت. کام وانە یەکەی زیاترە لە وانەیەکی تر؟ ρ C1 (Course) ⋈ C1.credits < C2.credits ρ C2 (Course):

An equijoin is a condition join whose condition only compares columns with =. Student ⋈ Student.student_no = Enrolled.student_no Enrolled gives 7 rows: each enrolment with its student. The result keeps both columns Student.student_no and Enrolled.student_no — they simply hold equal values.

لێکبەستنی یەکسانی لێکبەستنی مەرجدارە کە مەرجەکەی تەنها بە = ستوونەکان بەراورد دەکات. Student ⋈ Student.student_no = Enrolled.student_no Enrolled 7 ڕیز دەدات: هەر تۆمارکردنێک لەگەڵ قوتابییەکەی. ئەنجامەکە هەردوو ستوونی Student.student_no و Enrolled.student_no دەهێڵێتەوە — تەنها نرخی یەکسانیان تێدایە.

The natural join Student ⋈ Enrolled (no condition written) compares all columns that have the same name — here only student_no — and keeps one copy of each shared column. It equals a product, then a selection, then a projection: π student_no, name, dept, city, course_code, grade (σ Student.student_no = Enrolled.student_no (Student × Enrolled)).

لێکبەستنی سروشتی Student ⋈ Enrolled (بەبێ نووسینی مەرج) هەموو ئەو ستوونانە بەراورد دەکات کە هەمان ناویان هەیە — لێرەدا تەنها student_no — و یەک کۆپی لە هەر ستوونێکی هاوبەش دەهێڵێتەوە. یەکسانە بە لێکدانی دیکارتی، پاشان هەڵبژاردن، پاشان دەرهێنانی ستوون: π student_no, name, dept, city, course_code, grade (σ Student.student_no = Enrolled.student_no (Student × Enrolled)).

An ordinary (inner) join drops the rows that find no partner: Hana is missing from Student ⋈ Enrolled. An outer join keeps them and fills the missing columns with NULL. A left outer join ⟕ keeps every row of the left table, a right outer join ⟖ every row of the right table, and a full outer join ⟗ both.

لێکبەستنێکی ئاسایی (ناوەکی) ئەو ڕیزانە لادەبات کە هاوتایان نادۆزنەوە: هانا لە Student ⋈ Enrolledدا نییە. لێکبەستنی دەرەکی دەیانهێڵێتەوە و ستوونە نەبووەکان بە NULL پڕ دەکاتەوە. لێکبەستنێکی دەرەکیی چەپ ⟕ هەموو ڕیزێکی خشتەی چەپ دەهێڵێتەوە، لێکبەستنێکی دەرەکیی ڕاست ⟖ هەموو ڕیزێکی خشتەی ڕاست و لێکبەستنێکی دەرەکیی تەواو ⟗ هەردووکیان.

In the same way, Enrolled ⟖ Course keeps NW201 (Computer Networks), which nobody takes, with NULL in student_no and grade. In our data every enrolment has a course, so the full outer join Enrolled ⟗ Course gives the same rows as the right outer join.

بە هەمان شێوە، Enrolled ⟖ Course وانەی ⁦NW201 (Computer Networks)⁩ دەهێڵێتەوە کە کەس نایخوێنێت، بە NULL لە student_no و gradeدا. لە دراوەکانی ئێمەدا هەموو تۆمارکردنێک وانەیەکی هەیە، بۆیە لێکبەستنی دەرەکیی تەواو Enrolled ⟗ Course هەمان ڕیزەکانی لێکبەستنی دەرەکیی ڕاست دەدات.

Keep only the rows that found no partner and you answer questions such as 'which students have no course?': in SQL a LEFT JOIN followed by WHERE … IS NULL (the SQL examples). In Microsoft Access the Find Unmatched Query Wizard writes exactly this query for you (two wizards that find problems).

ئەگەر تەنها ئەو ڕیزانە بهێڵیتەوە کە هیچ هاوتایەکیان نەدۆزیوەتەوە، وەڵامی پرسیاری وەک «کام قوتابی هیچ وانەیەکی نییە؟» دەدەیتەوە: لە SQLدا LEFT JOIN و پاشان WHERE … IS NULL (نموونەکانی SQL). لە ⁦Microsoft Access⁩دا ⁦Find Unmatched Query Wizard⁩ ڕێک ئەم پرسە بۆ تۆ دەنووسێت (دوو یاریدەدەر کە کێشە دەدۆزنەوە).

The web track requires two courses: Required(course_code) = {DB101, WP101}. Which students have taken every required course? Division answers exactly this kind of 'for all' question. Let A(student_no, course_code) be π student_no, course_code (Enrolled) and B(course_code) be Required. Then A ÷ B is the set of student_no values that appear in A together with every course_code of B.

ڕێڕەوی وێب دوو وانەی پێویستە: Required(course_code) = {⁦DB101, WP101⁩}. کام قوتابییانە هەموو وانە پێویستەکانیان خوێندووە؟ دابەشکردن ڕێک وەڵامی ئەم جۆرە پرسیارەی «بۆ هەموو» دەداتەوە. با A(student_no, course_code) بێت بە π student_no, course_code (Enrolled) و B(course_code) بێت بە Required. ئەوکات ⁦A ÷ B⁩ کۆمەڵەی ئەو نرخانەی student_noـە کە لە Aدا لەگەڵ هەموو course_codeێکی Bدا دەردەکەون.

Division is not a basic operation: it can be built from π, × and −. The idea is to find the students who are missing something, and subtract them:

دابەشکردن کارێکی بنەڕەتی نییە: دەتوانرێت بە π، × و − دروست بکرێت. بیرۆکەکە ئەوەیە ئەو قوتابیانە بدۆزینەوە کە شتێکیان کەمە، پاشان لایان ببەین:

When an expression has no brackets, operators are applied in this order (like × before + in school maths): first the unary operators σ, π, ρ; then × and ⋈; then ∩; and last ∪ and −. So R ∪ S ∩ T means R ∪ (S ∩ T). Brackets make your meaning clear — use them.

کاتێک دەربڕینێک کەوانەی نییە، کارپێکەرەکان بەم ڕیزبەندییە جێبەجێ دەکرێن (وەک × پێش + لە بیرکاریی قوتابخانەدا): سەرەتا کارپێکەرە تاکلایەنەکان σ، π، ρ؛ پاشان × و ⋈؛ پاشان ∩؛ و لە کۆتاییدا ∪ و −. بۆیە R ∪ S ∩ T واتە R ∪ (S ∩ T). کەوانەکان مەبەستەکەت ڕوون دەکەنەوە — بەکاریان بهێنە.

Relational algebra is operational: it says which steps to run. That is why a DBMS uses it inside, to represent a query's evaluation plan. One question can usually be written as several equivalent expressions, and the query optimizer picks the one that is cheapest to run. Thanks to the algebra's exact rules, the optimizer can rewrite a query safely. For example, these two give the same rows:

جەبری پەیوەندیدار ڕێکارییە: دەڵێت کام هەنگاوەکان جێبەجێ بکرێن. بۆیە سیستەمی بەڕێوەبردنی بنکەدراوە لە ناوەوە بەکاری دەهێنێت بۆ نیشاندانی پلانی جێبەجێکردنی پرسێک. یەک پرسیار زۆرجار دەتوانرێت بە چەند دەربڕینێکی هاوتا بنووسرێت و لە باشترکردنی پرسدا (Query optimization) سیستەمی بەڕێوەبردنی بنکەدراوە ئەوەیان هەڵدەبژێرێت کە هەرزانترین جێبەجێکردنی هەیە. بە هۆی یاسا وردەکانی جەبرەکەوە، دەتوانێت پرسێک بە سەلامەتی دووبارە بنووسێتەوە. بۆ نموونە، ئەم دووانە هەمان ڕیزەکان دەدەن:

How does the optimizer choose? It lists several plans, estimates what each costs from statistics it keeps about the tables (how many rows, how many different values in a column) and runs the cheapest. One operator can also be run in several ways: a join can compare every pair of rows (nested loops), look the partner up in an index, sort both tables and merge them, or build a hash table. You can ask a DBMS which plan it chose: EXPLAIN in MySQL, EXPLAIN QUERY PLAN in SQLite.

باشترکەری پرسەکە (Query optimizer (planner)) چۆن هەڵدەبژێرێت؟ چەند پلانێک ڕیز دەکات، تێچووی هەر یەکێکیان لە ئامارەکانەوە مەزەندە دەکات کە دەربارەی خشتەکان هەڵیان دەگرێت (چەند ڕیزێک، چەند نرخی جیاواز لە ستوونێکدا) و هەرزانترینیان جێبەجێ دەکات. یەک کارپێکەریش دەکرێت بە چەند ڕێگایەک جێبەجێ بکرێت: لێکبەستنێک دەتوانێت هەموو جووتە ڕیزێک بەراورد بکات (خولە ناوەکییەکان (Nested loop))، هاوتاکەی لە پێڕستێکدا (Database index) بدۆزێتەوە، هەردوو خشتەکە ڕیز بکات و تێکەڵیان بکات، یان خشتەیەکی هاش (Hash table) دروست بکات. دەتوانیت لە سیستەمێکی بەڕێوەبردنی بنکەدراوە بپرسیت کام پلانی هەڵبژاردووە: EXPLAIN لە MySQL، EXPLAIN QUERY PLAN لە SQLite.

Relational calculus is the declarative partner of the algebra. A query is a logical formula (from first-order predicate logic) that describes the rows we want; it says nothing about the steps. The answer is every assignment of values that makes the formula true. One calculus query can be carried out by many different algebra expressions, and an SQL query without aggregation (no COUNT, SUM, GROUP BY) corresponds to a calculus expression.

ژمێرکاریی پەیوەندیدار هاوبەشە ڕوونکەرەوەکەی جەبرەکەیە. پرسێک فۆرمولەیەکی لۆجیکییە (لە لۆجیکی پێشبینیی پلەی یەکەمەوە) کە ئەو ڕیزانە وەسف دەکات کە دەمانەوێت؛ هیچ دەربارەی هەنگاوەکان ناڵێت. وەڵامەکە هەموو ئەو نرخانەیە کە فۆرمولەکە دەکەنە ڕاست. یەک پرسی ژمێرکاری دەتوانرێت بە چەندین دەربڕینی جیاوازی جەبر جێبەجێ بکرێت و پرسێکی SQL بەبێ کۆکردنەوە (بێ COUNT، SUM، GROUP BY) هاوتای دەربڕینێکی ژمێرکارییە.

Implication A ⇒ B ('if A then B') is false only when A is true and B is false. So A ⇒ B means the same as ¬A ∨ B. It is how 'for all' conditions are written: ∀ r ∈ Course (r.credits = 4 ⇒ …) says something only about the 4-credit courses and is automatically true for the others. The same truth table is taught in Propositional logic in the AI course.

گوزارەی مەرجی (Implication) A ⇒ B («ئەگەر A ئەوا B») تەنها کاتێک هەڵەیە کە A ڕاست بێت و B هەڵە بێت. بۆیە A ⇒ B هەمان واتای ¬A ∨ Bـی هەیە. بەم شێوەیە مەرجەکانی «بۆ هەموو» دەنووسرێن: ∀ r ∈ Course (r.credits = 4 ⇒ …) تەنها دەربارەی وانە 4 یەکەییەکان شتێک دەڵێت و بۆ ئەوانی تر خۆبەخۆ ڕاستە. هەمان خشتەی ڕاستی (Truth table) لە لۆجیکی گوزارەییی کۆرسی ژیریی دەستکرد (Artificial intelligence) فێر دەکرێت.

A TRC query has the form { t | P(t) }: 'the rows t for which P(t) is true'. Here are four questions on our tables, each with its answer:

پرسێکی TRC ئەم شێوەیەی هەیە: { t | P(t) }: «ئەو ڕیزانەی t کە ⁦P(t)⁩یان بۆ ڕاستە». ئەمە چوار پرسیارە لەسەر خشتەکانمان، هەریەکە لەگەڵ وەڵامەکەی:

A DRC query has the form { ⟨x1, x2, …, xn⟩ | P(x1, …, xn) }. Each variable stands for one column value, written in the column order of the table: for Student, ⟨i, n, d, c⟩ = (student_no, name, dept, city).

پرسێکی DRC ئەم شێوەیەی هەیە: { ⟨x1, x2, …, xn⟩ | P(x1, …, xn) }. هەر گۆڕاوێک جێگەی نرخی یەک ستوون دەگرێتەوە و بە ڕیزبەندیی ستوونەکانی خشتەکە دەنووسرێت: بۆ Student، ⟨i, n, d, c⟩ = ⁦(student_no, name, dept, city)⁩.

Some formulas have infinitely many answers. { t | ¬ (t ∈ Student) } asks for every row that is not a student — every possible name, number and city in the world. Such a query is unsafe. A safe query only returns values that appear in its tables or in its constants. With this restriction three languages have exactly the same power: relational algebra, safe tuple calculus and safe domain calculus. A language that can express every query of the algebra is called relationally complete; SQL is.

هەندێک فۆرمولە وەڵامی بێکۆتاییان هەیە. { t | ¬ (t ∈ Student) } داوای هەموو ئەو ڕیزانە دەکات کە قوتابی نین — هەموو ناو، ژمارە و شارێکی شیاو لە جیهاندا. پرسێک لەم جۆرە ناسەلامەتە. پرسێکی سەلامەت تەنها ئەو نرخانە دەگەڕێنێتەوە کە لە خشتەکانی یان لە نەگۆڕەکانیدا هەن. بەم سنوورە سێ زمان ڕێک هەمان هێزیان هەیە: جەبری پەیوەندیدار، ژمێرکاریی پەیوەندیداری تۆماری سەلامەت و ژمێرکاریی پەیوەندیداری بواری سەلامەت. زمانێک کە بتوانێت هەموو پرسێکی جەبر دەرببڕێت پێی دەوترێت خاوەنی تەواوێتیی پەیوەندیدار (Relational completeness)؛ SQL وایە.

Every operator of the algebra has an SQL form. You already know SELECT … FROM … WHERE from The four basic statements; joins and the set operations are new here. One difference matters everywhere: the algebra works with sets, but SQL tables and results are bags — they may hold the same row twice — unless you write DISTINCT (or use UNION, INTERSECT, EXCEPT, which remove duplicates by default).

هەموو کارپێکەرێکی جەبرەکە شێوەیەکی SQLـی هەیە. SELECT … FROM … WHERE پێشتر لە چوار ڕستە بنەڕەتییەکە دەزانیت؛ لێکبەستنەکان و کارەکانی کۆمەڵە لێرەدا نوێن. یەک جیاوازی لە هەموو شوێنێکدا گرنگە: جەبرەکە لەگەڵ کۆمەڵەدا کار دەکات، بەڵام خشتە و ئەنجامەکانی SQL کیسەن (بە ئینگلیزی bags) — دەکرێت هەمان ڕیز دوو جار هەڵبگرن — مەگەر DISTINCT بنووسیت (یان UNION، INTERSECT، EXCEPT بەکار بهێنیت، کە بە شێوەی بنەڕەتی دووبارەکان لادەبەن).

Here are some of the lesson's examples written in SQL. All of them were run on the example tables; you can try them in phpMyAdmin or SQLite (SQLite basics).

ئەمانە هەندێک لە نموونەکانی وانەکەن بە SQL نووسراون. هەموویان لەسەر خشتە نموونەییەکان جێبەجێ کراون؛ دەتوانیت لە phpMyAdmin یان SQLite تاقییان بکەیتەوە (بنەماکانی SQLite).

Older books, exam answers and many web pages write a join without the word JOIN. The tables are listed with commas – that is the Cartesian product – and the join condition goes into WHERE – that is the selection. It is the algebra's σθ(R × S) written directly, and it gives the same rows as JOIN … ON:

کتێبە کۆنەکان، وەڵامی تاقیکردنەوەکان و زۆر لاپەڕەتۆڕ (Web page) لێکبەستن بەبێ وشەی JOIN دەنووسن. خشتەکان بە فاریزە ڕیز دەکرێن – ئەمە لێکدانی دیکارتییە – و مەرجی لێکبەستنەکە دەچێتە ناو WHERE – ئەمە هەڵبژاردنە. ئەمە σθ(R × S)ـی جەبرەکەیە کە ڕاستەوخۆ نووسراوە و هەمان ڕیزەکان وەک JOIN … ON دەدات:

A join of N tables needs $N-1$ join conditions: one for each link in the chain. A many-to-many relationship is a chain of three tables, with the junction table in the middle – enrolled links student and course, so two conditions are needed:

لێکبەستنی N خشتە پێویستی بە $N-1$ مەرجی لێکبەستن هەیە: بۆ هەر ئەڵقەیەکی زنجیرەکە یەکێک. پەیوەندییەکی زۆر بۆ زۆر (Many-to-many relationship) زنجیرەیەکی سێ خشتەییە و خشتەی بەستنەوە (Junction table) لە ناوەڕاستدایە – enrolled student و course دەبەستێتەوە، بۆیە دوو مەرج پێویستن:

Sometimes both sides of a join are the same table. A family table stores parent_child(parent, child). A grandparent is the parent of a parent, so the table must be read twice, once for each generation. Rename (ρ in the algebra, AS in SQL) gives the two copies different names: this is a self-join.

هەندێک جار هەردوو لای لێکبەستنێک هەمان خشتەیە. خشتەیەکی خێزان parent_child(parent, child) هەڵدەگرێت. باپیر دایک یان باوکی دایک یان باوکە، بۆیە دەبێت خشتەکە دوو جار بخوێنرێتەوە، بۆ هەر نەوەیەک جارێک. ناونانەوە (ρ لە جەبرەکەدا، AS لە SQLدا) دوو ناوی جیاواز دەداتە دوو کۆپییەکە: ئەمە لێکبەستنی خۆییە (Self-join).

A self-join meets every pair twice: (101, 102) and (102, 101). Write < instead of <> to keep each pair once, and DISTINCT when two students share several courses – 101 and 103 share both DB101 and WP101:

لێکبەستنی خۆیی هەموو جووتێک دوو جار دەبینێت: ⁦(101, 102)⁩ و ⁦(102, 101)⁩. لە جیاتی <>، < بنووسە بۆ ئەوەی هەر جووتێک یەک جار بمێنێتەوە و DISTINCT کاتێک دوو قوتابی چەند وانەیەکی هاوبەشیان هەیە – ⁦101⁩ و ⁦103⁩ هەم ⁦DB101⁩ و هەم ⁦WP101⁩یان هاوبەشە: