Introduction to Database Systems
Lecture 2: Data Models & SQL
(Ch. 2.1-2.3)
1
Data Models
• language / notation for talking about data
• models we will use:
– relational: data is a collection of tables
– semi-structured: data is a tree
• other models:
– key-value pairs: used by NoSQL systems
– graph data model: used by RDF (semi-structured can also do)
– object oriented: often layered on relational, J2EE
2
Relational Model columns /
attributes /
fields
• Data is a collection of relations / tables:
Name Country Employees For_Profit
GizmoWorks USA 20000 True
rows / Canon Japan 50000 True
tuples / Hitachi Japan 30000 True
HappyCam Canada 500 False
records
• mathematically, relation is a set of tuples
– each tuple appears 0 or 1 times in the table
– order of the rows is unspecified
3
Relational Schema
• Each column has a “domain” (or type)
– SQL has Java-like types for numbers, strings, etc.
– domain is a constraint on the data allowed in the table
• Names and types part of the “schema” of the table:
Company(Name: string, Country: string,
Employees: int, For_Profit: boolean)
• Particular data is an “instance” of that relation
– data changes over time
– DBMS usually just stores the current instance
4
Keys
• Key = subset of columns that uniquely identifies tuple
• Another constraint on the table
– no two tuples can have the same values for those columns
• Examples:
– Movie(title, year, length, genre): key is (title, year)
– what is a good key for Company?
• Part of the schema (book notation is underline):
Company(Name: string, Country: string,
Employees: int, For_Profit: boolean)
5
Keys (cont.)
• Can have multiple keys for a table
• Only one of those keys may be “primary”
– DBMS often makes searches by primary key fastest
– other keys are called “secondary”
• “Foreign key” is a column (or columns) whose value
is a key of another table
– i.e., a reference to another row in another table
6
SQL (“sequel”)
• Standard query language for relational data
– used for databases in many different contexts
– inspires query languages for non-relational (e.g. SQL++)
• Everything not in quotes (‘…’) is case insensitive
• Provides standard types. Examples:
– numbers: INT, FLOAT, DECIMAL(p,s)
• DECIMAL(p,s): Exact numerical, precision p, scale s. Example:
decimal(5,2) is a number that has 3 digits before the decimal
and 2 digits after the decimal
– strings: CHAR(n), VARCHAR(n)
• CHAR(n): Fixed-length n
• VARCHAR(n): Variable length. Maximum length n
7
SQL (“sequel”) – Cont.
• Provides standard types. Examples:
– BOOLEAN
– DATE, TIME, TIMESTAMP
• DATE: Stores year, month, and day values
• TIME: Stores hour, minute, and second values
• TIMESTAMP: Stores year, month, day, hour, minute, and
second values
• Additional types differ by vendor:
– SQLite: http://www.sqlite.org/datatype3.html
8
SQL statements
• create table …
• drop table ...
• alter table ... add/remove ...
• insert into ... values ...
• delete from ... where ...
• update ... set ... where ...
• select … from … where
9
create table …
CREATE TABLE Company(
name VARCHAR(20) PRIMARY KEY,
country VARCHAR(20),
employees INT,
for_profit CHAR(1));
10
Multi-column Keys
• This makes name a key:
CREATE TABLE Company(
name VARCHAR(20) PRIMARY KEY,
country VARCHAR(20),
employees INT,
for_profit BOOLEAN);
• How can we make a key on
name & country?
11
Multi-column Keys
• Syntax change if a primary key has multiple columns:
goes away
CREATE TABLE Company(
name VARCHAR(20) PRIMARY KEY,
country VARCHAR(20),
employees INT,
added
for_profit BOOLEAN,
PRIMARY KEY (name,
country));
12
Multi-column Keys (2)
• Likewise for secondary keys:
goes away
CREATE TABLE Company( name
VARCHAR(20) UNIQUE,
country VARCHAR(20),
employees INT,
added
for_profit BOOLEAN,
UNIQUE (name, country));
13
Multi-column Keys (3)
• This makes manufacturer a foreign key:
CREATE TABLE Product(
name VARCHAR(20),
good idea to include
price DECIMAL(10,2),
target column name
manufacturer
VARCHAR(20)
REFERENCES Company(name));
14
Multi-column Keys (3)
• Similar syntax for foreign keys:
CREATE TABLE Product(
name VARCHAR(20),
now need both
price DECIMAL(10,2),
name & country
manu_name VARCHAR(20),
manu_co VARCHAR(20), added
FOREIGN KEY (manu_name, manu_co)
REFERENCES Company(name, country));
15
UNIQUE
• PRIMARY KEY adds implicit “NOT NULL” constraint
while UNIQUE does not
– you would have to add this explicitly for UNIQUE:
CREATE TABLE Company(
name VARCHAR(20) NOT NULL, …
UNIQUE (name));
• You almost always want to do this (in real
schemas)
– SQL Server behaves strangely with NULL &
UNIQUE
– otherwise, think through NULL for every query
– you can remove the NOT NULL constraint 16
later
drop table ...
DROP TABLE Company;
17
alter table ... add/remove ...
ALTER TABLE Company
ADD CEO VARCHAR(20);
18
insert into ... values ...
INSERT INTO Company VALUES
('GizmoWorks', 'USA', 20000, 'y');
19
One Way to Input Data
• Write a program that outputs SQL statements:
for (int a = 1; a <= 50; a++)
for (int b = 1; b <= 50; b++)
System.out.format(
“INSERT INTO T VALUES (%d,
%d);\n“,
a, b);
• Feed those into SQLite:
sqlite3 foo.db < inputs.sql
20
Demo: MakeTriples.java
21
Warning
• Be very careful when doing this with strings:
System.out.format(
”INSERT INTO T2 VALUES (%d, ‘%s’);”,
3, ”O’Shaughnessy”);
Becomes:
INSERT INTO T2 VALUES (3, ‘O’Shaughnessy’);
which is a syntax error in this case
22
https://xkcd.com/327/
23
Warning (cont)
• Be very careful when doing this with strings:
System.out.format(
”INSERT INTO T VALUES (%d, ‘%s’);”,
3, ”O’Shaughnessy”);
• This allows a SQL injection attack!
– Must check for quotes and escape (or disallow) them.
– We’ll see safer ways to do this using JDBC
• DBMSs usually have faster ways to input data
– SQLite has .import (try with .mode csv)
24
delete from ... where ...
DELETE FROM Company
where name = 'GizmoWorks';
25
update ... set ... where ...
UPDATE Company
SET employees = employees + 120
where name = 'GizmoWorks';
26
select ... from ... where ...
SELECT * FROM Company
where name = 'GizmoWorks';
27
DISTINCT and ORDER BY
• Query results do not have to be relations
– i.e., they can have duplicate rows
– remove them using DISTINCT
• Result order is normally unspecified
– choose an order using ORDER BY
– e.g., ORDER BY country, cname
– e.g., ORDER BY price ASC, pname DESC
• Examples in lec03-sql-basics.sql
28
Demo on Sqlite
• E.g., type sqlite3 in Cygwin
• .exit - exit from sqlite3
29
SQLite Uses
• SQLite is just a library
• Can be used as part of any C/C++/Java program
– ex: could be used in an iPhone app
• Can be used in Chrome & Safari
– no support in Firefox or IE
30
Physical Data Independence
• SQL doesn’t specify how data is stored on disk
• No need to think about encodings of data types
– ex: DECIMAL(10,2)
– ex: VARCHAR(255)
• does this need to use 255 bytes to store ‘hello’?
• No need to think about how tuples are arranged
– ex: could be row- or column-major ordered
– (Most DBMSs are row-ordered, but Google’s BigQuery is
column-oriented.)
31
SQLite Gotchas
• Allows NULL keys
– At most one tuple can have NULL in the key
– According to the SQL standard, PRIMARY KEY should
always imply NOT NULL, but this is not the case in SQLite
• Does not support boolean or date/time columns
• Doesn’t always enforce domain constraints!
– will let you insert a string where an INT is expected
• Doesn’t enforce foreign key constraints by default
• Etc…
32
