Introduction SQL DRL. Parts of SQL. SQL: Structured Query Language Previous name was SEQUEL Standardized query language for relational DBMS:

Transcription

1 Introduction SQL: Structured Query Language Previous name was SEQUEL Standardized query language for relational DBMS: SQL The standard is evolving over time SQL-89 SQL-9 SQL-99 SQL-0 SQL is a declarative query language Parts of SQL DRL Four main parts: The DRL is used to formulate queries DRL: Data Retrieval Language DML: Data Manipulation Language DDL: Data Definition Language DCL: Data Control Language A simple query consists of three clauses select, from und where select list of attributes from list of relations where condition

2 A simple Example Result Student MatrNr SName Birthday Student 4 Becker, Hans Graf, Anne Schulze, Iris Petersen, Bernd Query: List all information of all students: MatrNr 4 SName Becker, Hans Graf, Anne Schulze, Iris Petersen, Bernd Birthday Extraction of Attributes Duplicates Query: List the MatrNr and Name of all students: select MatrNr, SName In contrast to relational algebra and calculus, SQL is not eliminating duplicates when performing a projection If the elimination of duplicates is required, we have to use the keyworddistinct MatrNr 4 Student SName Becker, Hans Graf, Anne Schulze, Iris Petersen, Bernd

3 Example Where Clause select Birthday Birthday select distinct Birthday Birthday Query: List all information about students that have a MatrNr less than : where MatrNr < MatrNr Student SName Becker, Hans Graf, Anne Birthday Predicates Example for between Predicates in the where-clause can be combined using the logical operators Query: List the names of all students that were born between and AND, OR, NOT For comparisons we can use: =, <>, <, <=, >, >=, between, like select SName where Birthday between '99-0-0' and ' ' is equivalent to select SName where Birthday >= '99-0-0' and Birthday <= ' '

4 String Comparisons Comparisons using Wildcards String constants and date values have to be enclosed in single quotation marks Query: List all information about students that have a name that starts with P Query: List all information about students that have the name Schulze where SName = 'Schulze' where SName like 'P%' Wildcard Symbols Null Values _ means arbitrary character (exactly one) % means arbitrary sequence of characters (can have the length 0) NULL is a special value in SQL This values exists for all data types and represents an unknown or not existing value To use test for NULL in a query we can not use a normal comparison operator but have to use is [not] NULL select SName where Birthday is NULL

5 Null Values () More than one Relation Null values in arithmetical expressions: if at least one operand is NULL, the result is also NULL Evaluation of logical expressions: a logic with three values is used: true (t), false (f) and unknown (u) not t u f f u t and t u f t u f t u f u u f f f f or t u f t u f t t t t u u t u f If we write more than one relation in the from-clause, they will be combined by means of a cross product Query: List all information about all possible combinations of tuples from the relations Student and Professor, Professor In the result of an SQL-query we get only tupel for which the where-clause evaluates to true Joins Joins () Performing just a cross product is normally not very helpful More interesting are joins We can put the join condition in the where-clause:, Professor where SName = PName We can put an arbitrary number of relations in the fromclause Unless we really want to perform just a cross product, we have to provide appropriate join conditions in the whereclause We can alternatively use the keyword join in the fromclause This also allows us to formulate outer joins

6 Joins () Qualified Attribute Names Additional problem: name collisions (attributes with the same name in different relations) have to be resolved Example: Join of Student (MatrNr, SName, Birthday, Semester) attends(matrnr, LectNr) Lecture(LectNr, Titel, Credits) In such a query we have to specify from which relation the attribute names MatrNr und LectNr originate For this purpose we can write the name of the relation before the name of the attribute, attends, Lecture where Student.MatrNr = attends.matrnr and attends.lectnr = Lecture.LectNr Short Form Set Operations We can introduce (usually short) alias names s, attends a, Lecture l where s.matrnr = a.matrnr and a.lectnr = l.lectnr The common set operations union intersection set difference known from relational algebra also exist in SQL Like in relational algebra a prerequisite is that both relations have a compatible schema

7 Union PersNr Prof Name Schmitt Maier PersNr Prof Name Schmitt Stein Elimination of Duplicates In contrast to select, the default behavior of union is to eliminate duplicates If we want to have duplicates in the result, we have to use the operator union all Query: Union of both professor relations: from Prof union from Prof PersNr Name Schmitt Maier Stein Intersection Set Difference PersNr Prof Name Schmitt Maier Query: which professors are in both professor relations: from Prof intersect from Prof PersNr PersNr Name Schmitt Prof Name Schmitt Stein PersNr Prof Name Schmitt Maier Query: which professors are in the first but not the second relation: from Prof except from Prof PersNr PersNr Prof Name Schmitt Stein Name Maier

8 Sorting Example Tuples in a relation do not have an order If we want the result of a query to be displayed in a particular order, we can use the clause order by We can sort in ascending order (ascending / asc) or descending order (descending / desc) The default behavior is ascending order The order is depending on the values of an attribute We can specify a sequence of attributes if tuples have the same value in the first attribute, we take the next attribute to make a decision about the order order by Birthday desc, SName MatrNr 4 SName Graf, Anne Petersen, Bernd Schulze, Iris Becker, Hans Birthday Nested Queries Categories of Sub-Queries Queries can be nested within other queries, i.e., we can have more that one select-clause We can distinguish two different types of sub-queries: correlated und uncorrelated ones The nested query is usually appearing the where-clause but can also be part of the from-clause or even the selectclause The idea is to generate within the inner query a relation that is used in the outer query You can have more than one level of nesting in one single query uncorrelated: the sub-query is only using attributes that are belong to relations from its own from-clause correlated: the sub-query is also referencing attributes that belong to the outer query

9 Example: Uncorrelated Sub-Query Example: Correlated Sub-Query Query: Names of all students that attend the lecture number 5 Query: Names of all students that attend the lecture number 5 select S.SName S where S.MatrNr in (select A.MatrNr from attends A where A.LectNr = 5) The suq-query is calculated just once For each tuple in the outer query we then check whether its MatrNr is an element of the result of the sub-query select S.SName S where exists ( from attends A where A.LectNr = 5 and A.MatrNr = S.MatrNr) For each tuple in the outer query the sub-query has a different result The exists predicate is true iff the sub-query contains at least one tuple Aggregate Functions Example () A set of attribute values (or complete tuples) can be aggregated to a single value Student Most important aggregate functions: Number of tuples or values: count() Sum of values: sum() Average of values: avg() Maximum of values: max() Minimum of values: min() MatrNr 4 SName Becker, Hans Graf, Anne Schulze, Iris Petersen, Bernd Birthday NULL select count(*)

10 Example () Example () Student Student MatrNr SName Birthday MatrNr SName Birthday 4 Becker, Hans Graf, Anne Schulze, Iris Petersen, Bernd NULL Becker, Hans Graf, Anne Schulze, Iris Petersen, Bernd NULL select count(birthday) select count(distinct Birthday) Min/Max Min/Max () Query: Show the name and MatrNr of the student that has the highest MatrNr Aggregate functions reduce all values in a column to a single value For the attribute MatrNr we tell the DBMS to take the maximum value select SName, max(matrnr) from Student For the attribute Name the DBMS has no information how to reduce all names to a single one Does NOT work!!!

11 Min/Max () Grouping How can we formulate this query correctly? We use a nested query: For some queries we want to form different groups of tuples and perform an aggregation for each group separately select SName, MatrNr where MatrNr = (select max(matrnr) ) Query: Show for each lecture its number together with the number of students that attend this lecture select LectrNr, count(*) as NumParticipants from attends group by LectNr; Result Grouping () attends MatrNr LectNr LectNr NumParticipants Attributes that are not listed in the group by-clause can only be used in an aggregated form in the select-clause Therefore, the following query is wrong (due to the same reason as the first query using max): select Semester, Birthday, count(*) as Number group by Semester;

12 Having Example The where-clause is evaluated before the grouping in the where-clause we select tuples When we want to filter the groups, we have to use the having-clause Query: Show the ProfNr of all professors that give more than three lectures (together with the corresponding count of lectures) in the having-clause we decide which groups should be part of the result select ProfNr, count(*) as NumLect from gives group by ProfNr having count(*) > ; Nested Queries (Part ) Nested Queries with Single Values Nested queries are used in most cases to formulate conditions in the where-clause In the outer query we can perform a simple comparison with the result of the inner query We can classify the conditions depending on what the subquery is producing similar to a comparison with a constant value the usual comparison operators can be used a single value a relation a relation with more than one column that is used for comparison Which examinations got a grade above the average? from Examination where Grade < ( select avg (Grade) from Examination)

13 Nested Queries with Relations () Nested Queries with Relations () We can use four different kinds of operators All can be negated using not ) s in R: Is true exactly if the tuple s has the same values as a tuple in the relation R ) exists R: Is true exactly if the relation R is not empty, i.e., contains at least one tuple Example: Example: S where exists ( from Professor P where P.Birthday > S.Birthday) select S.SName S where S.MatrNr in (select A.MatrNr from attends a where a.lectnr = 5) Nested Queries with Relations () Nested Queries with Tuples ) s <comparison> any R: Is true exactly if the comparison between s and at least one tuple of R is true. We can form a tuple as a list of values. This can used for a comparison with the result of a subquery 4) s <comparison> all R: Is true exactly if the comparison between s and all tuples of R is true. This is not a universal quantifyer! Example: select SName where Semester >= all ( select Semester Example: select SName where (SName, Birthday) in ( select PName, Birthday from Professor ); );

14 in vs exists Nested Queries beyond where () Conditions using in can be handy but do not extend the expressive power of the SQL language We can replace each condition that is using in with an equivalent condition using exists The query t in (select t from R X,..., Rn Xn where <condition>) is (if some prerequisites are fulfilled) equivalent to exists ( from R X,..., Rn Xn where <condition> and t = t ) The prerequisites are related to name collisions and can be easily fulfilled Example with a subquery in the select-clause select ProfNr, PName,(select sum (Credits) as teach_load from lecture l, gives g where g.profnr = p.profnr and g.lectnr = l.lectnr ) from Professor p For each tuple in the result-relation we have to execute the subquery individually (correlated subquery) Nested Queries beyond where () Self-Join / Recursion () As the result of an SQL-query is a relation, we can place a subquery also in the from-clause Nevertheless, early SQL-standards (up to and including SQL-86) did not allow this, but nowadays we can do this However, subqueries in the from-clause are rarely used Consider the following schema: Lecture (LectNr, Title, Credits) prerequisite (predecessor, successor) Query: What are the prerequisites for the lecture Programming

15 Self-Join / Recursion () Self-Join / Recursion () Direct prerequisites: Direct prerequisites of the direct prerequisites: select predecessor select predecessor from prerequisite, Lecture from prerequisite where successor = LectNr and Title = Programming where successor in (select predecessor from prerequisite, Lecture where successor = LectNr and Title = Programming ) Self-Join / Recursion (4) Queries using Quantifier in SQL: Alternative: Existential quantifier in SQL: exists select v.predecessor Example: from prerequisite v, prerequisite v, Lecture v where v.successor = v.predecessor and v.successor = v.lectnr and v.title = Programming Note: prerequisite is joined with itself to find the prerequisite in the level n we have to formulate n- such self-joins the transitive closure is not supported by the SQL standard there exist vendor-specific extensions select PName from Professor where exists ( from gives where gives.profnr = Professor.ProfNr )

16 Queries using Quantifier in SQL: () Queries using Quantifier in SQL: () SQL has no universal quantifier A query using a universal quantifier can be expressed by an equivalent query using an existential quantifier We start by formulating a query in tuple calculus Example query: Who is attending all lectures with 4 credits? {s s Student l Lecture (l.credits=4 a attends (a.lectnr=l.lectnr a.matrnr=s.matrnr))} Goal: Eliminating and We can use the following rules: t R(P(t)) = ( t R( P(t))) R T = R T Eliminating {s s Student ( l Lecture (l.credits=4 a attends (a.lectnr=l.lectnr a.matrnr=s.matrnr)))} Eliminating {s s Student ( l Lecture ( (l.credits=4) a attends (a.lectnr=l.vorlnr a.matrnr=s.matrnr)))} Applying the rule of DeMorgan results in: {s s Student ( l Lecture (l.credits=4 ( a attends (a.lectnr=l.lectnr a.matrnr=s.matrnr))))} Queries using Quantifier in SQL: () Transformation into SQL: select s.* s where not exists (select l.* from Lecture l where l.credits = 4 and not exists (select a.* from attends a where a.lectnr = l.lectnr and a.matrnr=s.matrnr)) Universal Quantification by using count-aggregation () Alternatively, we can express a universal quantification by using a count-aggregation we count how many tuple fulfill a property and compare this value with the total number of tuples We first consider a simplified example: Query: What are the (MatrNr of) students that attend all lectures? select a.matrnr from attends a group by a.matrnr having count (*) = (select count (*) from Lecture)

17 Universal Quantification by using count- Aggregation () Universal Quantification by using count- Aggregation () Next step select afour.matrnr, afour.sname Provide a solution to the complexer query: Who is attending all lectures with 4 credits? Basic Idea: we first restrict the tuples and count only the remaining ones from (select s.matrnr, s.sname, l.lectnr from attends a, Lecture l, Student s where a.matrnr = s.matrnr and a.lectnr = l.vorlnr and l.credits = 4) afour group by afour.matrnr, afour.sname having count (*) = (select count (*) from Lecture where Credits = 4) Modification of Data Inserting Data in SQL The DML (Data Manipulation Language) contains commands to insert data delete data change data Inserting a single tuple: Example: insert into <relation> values ( <list of values> ) insert into Professor values (456, Schmidt, 0)

18 Providing Attributes When Inserting Inserting Generated Tuples In addition to the relation we can provide the names of attributes Typically this is done for two reasons: We can insert the result of a query into a relation: insert into <relation> <query> we do not want to care for the order of the attributes we do not want to provide values for all attributes and want the DBMS to use NULL-values or default-values for missing attributes Example: insert into Professor(ProfNr, PName) values (456, Schmidt ); Example: insert into attends select MatrNr, LectNr, Lecture where Title= Logic Deleting Tuples Two Steps to Implement Modifications We use the command delete:. The tuples to be modified are determined delete from <relation> Example: where <condition> delete from Professor where ProfNr = 456 Note: Omitting the where-clause is possible but will delete all tuples of the relation!. The modifications are applied to the tuples determined in step These separate steps ensure that modifications do not depend on the order we process the tuples Example: delete from prerequisite where predecessor in (select successor from prerequisite) delete from Professor

19 Two Steps to Implement Modifications Modification of Values predecessor prerequisite successor To modify the values of an attribute in a tuple, we use the command update: Example: update <relation> set <list of assignments> where <condition> update Professor set RoomNr = where RoomNr = 456 If we would process the tuples in this example in the order given above and immediately apply the delete operation, we get the wrong result! Schema definition Schema definition: Types By means of the so called DDL (Data Definition Language) we can define the schema of a database The DDL is also used to define integrity constraints The create table-statement is used to define relations: create table <name of the relation> ( <column name> <data type> [<constraints>]... ) Example: create table Professor ( PersNr integer, Name varchar(80), RoomNr integer ) Common data types character(n) / char(n): fixed number of characters specified character varying(n) / varchar(n): maximum number of characters specified numeric(p, s), real, double precision, integer/int p: total number of digits s: number of positions after decimal point s has a default values of 0, for s = 0 we can omit this parameter blob or raw for large binary data clob for a large sequence of characters date for calendar dates (e.g ) We will later look more closely at integrity constrains e.g. not null, to specify that an attribute always has to have a value

20 Type Casts Views create table a ( id integer, number integer ); create table b ( id integer, number integer ) View are virtual relations They show a specific part of the database tailored for a particular application Can be used to to structure queries for data privacy a user can see only the part of the database he is allowed to see to ensure data independence simplified access for particular user groups Disadvantage select cast(a.number as real) / cast(b.number as real) from a, b where a.id = b.id; Modifications are often not possible Definition of a View Views for Data Privacy create view <name of view> [(<optional list of attribute names>)] as <query> create view ExamView as select MatrNr, LectNr, ProfNr from Examination What is the benefit? We can have user groups that are only allowed to access the view but not the base relation Examination A user can see which examinations took place but not the grades

21 Views to Simplify Queries A Complex Query create view StudProf (SName, Semester, Title, PName) as select s.sname, s.semester, l.title, p.pname s, attends a, Lecture l, Professor p, gives g where s.matrnr=a.matrnr and a.lectnr=l.lectnr and g.lectnr=l.lectnr and g.profnr = p.profnr Usage: Query: Find the names of all professors that give a lecture with a number of credit points above average and have more that three assistants We structure this query by realizing different parts in form of views select distinct Semester from StudProf where PName= Meier A Complex Query () A Complex Query () Query: Find the lectures with a number of credit points above average and the professors that give these lectures Query: Find all professors (their ProfNr) that have more that three assistants create view AboveAverageCredit as select LectNr, ProfNr from Lecture, gives where Lecture.LectNr = gives.lectnr and Credits > (select avg (Credits) from Lecture) create view ManyAssistants as select Boss from Assistant group by Boss having count(*) >

22 A Complex Query (4) Now we can combine both results We can use the views like normal relations Views to Ensure Data Independence user select PName from Professor where ProfNr in (select ProfNr from AboveAverageCredit) and ProfNr in (select Boss from ManyAssistants) logical data independence physical data independence view view view relation relation relation Views to Model Generalization: Variant create table Employee (EmpNr integer not null, Name varchar(0) not null) create table ProfData (EmpNr integer not null, RoomNr integer) create table AssiData (EmpNr Area Boss integer not null, varchar(0), integer) Views to Model Generalization: Variant create view Professor (ProfNr, PName, RoomNr) as select e.empnr, e.name, p.roomnr from Employee e, ProfData p where e.empnr=p.empnr create view Assistant as from Employee e, AssiData a where e.empnr=aempnr Result: subtypes (Professor, Assistant) of Employee exists as views

23 Views to Model Generalization: Variant create table Professor (ProfNr PName RoomNr create table Assistant (EmpNr Name Area Boss create table OtherEmp (EmpNr Name integer not null, varchar(0) not null, integer) integer not null, varchar(0) not null, varchar(0), integer) integer not null, varchar(0) not null) Views to Model Generalization: Variant create view Employee as (select ProfNr as EmpNr, PName as Name from Professor) union (select EmpNr, Name from Assistant) union ( from OtherEmp) Result: Supertype (Employee) as view Modification of Data in Views Modification of Data in Views () Examples for views that can not be used for modifications create view ProfGrades (ProfNr, AvgGrade) as select ProfNr, avg(grade) from Examination group by ProfNr create view LectureProf as select Title, Credits, PName from Lecture l, Professor p, gives g where l.lectnr = g.lectnr and g.profnr = p.profnr What about the following command? insert into LectureProf values ( Algebra,, Mr. X ) Is allowed in SQL only if the following conditions hold: just one relation used for defining the view the key of this relation has to be part of the view no aggregate functions, grouping, or elimination of duplicates all views views that would theoretically allow modifications views that allow modifications in SQL

24 Select-Clause Lists the attributes of the resulting relation Acts like a projection in relational algebra Summary SQL DRL Attributes can be calculated, e.g., by using aggregate functions Remind: do not combine aggregated attributes with attributes that are not aggregated! Projection can result in duplicates If tuples are not equal, nevertheless individual attributes can be equal Elimination of duplicates: distinct Whether duplicates occur depends on the structure of the query A join is often producing duplicates Duplicates Order by-clause Can produce duplicates: Is used to sort the output select s.sname s, attends a where s.matrnr=a.matrnr No duplicates (if SName in the relation Student is unique): select SName where MatrNr in (select MatrNr from attends) Default order is ascending (asc) Alternative: descending (desc) We can specify several attributes that are used in the given order to sort the tuples

25 From-Clause Where-Clausel Lists the used relations Acts like a cross product in relational algebra Usually turned into a join by means of a combination with a selection if we join n relations we usually need (n-) join-conditions Special constructs for joins in the from-clause Alias names can be used to abbreviate and distinguish relations A relation can appear more than once in a from-clause: select distinct s.sname s, Student s where s.matrnr<>s.matrnr and s.sname = s.sname Formulates Conditions that have to fulfilled by the tuples Acts like a selection in relational algebra Usually comparisons of attribute values with each other or with constant values Logical operators can be applied: and, or, not Subqueries Set Operations Produce intermediate results that are used in the outer query Set operations are used if the result can be produced by combining different sets Can be used to simplify the structure of a query The default behavior is to eliminate duplicates Formulation of conditions that use the result of the subquery: if the subquery produces a single value: comparison operator (=, >,...) if the subquery can produce a set: in, exists, <comparison>any, <comparison>all The prerequisite for applying set operations is that the involved relations have the same schema Available operations Union Intersect Except (set difference)

26 Group by-clause Having-Clause Forms groups of tuples that have the same value in one or more columns Often used in combination with aggregate functions Only attributes, that are used for forming the groups, and aggregated values can be used in the corresponding selectclause select SName, count(*) as Frequency group by SName Formulates conditions that have to fulfilled by groups Can only occur, if we have a group by -clause before select SName, count(*) as Frequency group by SName having count(*) > Steps to Formulate a DRL Query () Steps to Formulate a DRL Query () What attributes we need in the result relation? (select) Which relations do we need to get the attributes for the result and the conditions? (from) If we use group by : Does a condition refer to individual tuples (where) or to whole groups (having)? Is it advisable to use a subquery? Can we get duplicates and do we want them eliminated? (distinct) What conditions have to be fulfilled by the tuples in the result relation? (where) Do we need values that are calculated from several tuples? (aggregate functions) correlated / uncorrelated Do we have queries that use a universal quantifier? (Transform the query that we just need an existential quantifier or use count-aggregation) Do we have to sort the result? (order by) Do we have to consider several tuples with the same value in one or more attributes as a group? (group by) Often used in combination with aggregate functions