ell
Notes for Professionals
100+ pages
of professional hints and tricks
, Prerincs
GoalKicker.com ae ae te cen et
Free Programming Books alPircdlemarksandresisered wademarkears
ree gia earsContents
About
hapter 1: Getting started with SQL
Section 11: Overview
Chapter 2: Identifier
Section 21: Unguoted identifiers
Chapter 3: Data Types
31: DECIMAL and NUMERIC
‘Section 32 FLOAT and REAL
Section 33: Integers
Section 3.4 MONEY and SMALLMONEY.
‘Section 351 BINARY and VARBINARY
Section 3.6: CHAR and VARCHAR
Section 37: NCHAR ond NVARCHAR
t JOU! iE
Chapter 4: NULL 7
tion 41 Filtering for NULL in quer
Sect ble:
Section 4: Updating fields to NULL
‘Section 4.4: Inserting rows with NULL fields ..
Chapter 5: Example Databases and Tables ..
Section 5.1 Auto Shop Datobase
Section 5.2: Librory Database
Section 53: Countries Table
Chapter 6: SELECT
jection 61 Using the wildcard character to select all columns in ¢ quer
42: Nullgble columns
SNADMAAUHHEARDRARRWYNN
Section 62: SFLECT Using Column Aliases 15
Section 63: Select Individuel COIUMNS nmin 18
lon 64: Select fled number of recor 19
Section 65: Selecting with Conaition .... 20
Section 66: Selecting with CAS: a se o a se 20
0 ned after reser fa o snsnnn 21
tion 6.8: Selecting with table alas 2
Section 6 Selecting with more than 1 condition 22
on 61 ting without Locking sininnnninnninnininininonninnnnnnnnnnnnne 23
Section 61%: Selecting with Aggregate fUNCHIONS -rinnnmminmnininenimenininnnnnannnnenmnenesennies 2B
Section 612: Select with condition of multiple values from column 24
Section 613: Get agareqated resull for row groups 24
Section 614: Selection with sorted Results .
Section 6.15: Selecting with null
Section 616: Select distinct (unique values onl 28
Section 617: Select rows from multiple tables snc sn 26
Chapter 7: GROUP BY ....sonnnninmniinninnninnininininnninininennnnsnnn seonsnnnsnnnnine OT
Section 71: Basic GROUP BY example 7
Section 7.2 Filter GROUP BY results using 6 HAVING clause 28
Section 75: USE GROUP BY to COUNT the number of rows for each ynique entry in a given columa
28
Section 7.4: ROLAP agaregotion (Data Mining) 29Chapter 8: ORDER BY
Section 81: Sorting bu column number (instead of name)
with TOP to retur rows based
Section 83 Customized sorting order
Section 84: Order by Alios
Chapter 9: AND & OR Operators
‘Section 9:1 AND OR Example
Chapter 10: CASE ..
Section 101
n 103: CASE
sion 10.4: Shorthan¢
tlon 107: CASE in
Chapter 11: LIKE operator
IRDER BY cla ort
tion 111 Motch open.
Section 112: Single character match
Section 113: ESCAPE statement in the LIKE-qven
Section 114: Search for @ range of characters
Section 115: Match by range or set
Section 116: Wildcard characters
Chapter 12: IN clause
on 121: Simpl
.¢ CASE to COUNT the num
Section 102: Seorched CASE in SELECT (Matches o boolean expression)
in clause ORDER BY
AS
Ein SELECT.
lowest valu
tern
Section 12.2: Using IN clause with @ SUBQUEEY warn
Chapter 13: Filter results using WHERE and HAVING
Sect
ti WHERE ch
Section 13.4: Equal
1 Use BETWEEN to Filter Results
Section 15.2: Use HAVING with Aggregate Functions
with NOT NULL ve
ch a cor
Section 135: The WHERE clause only returns rows that mateh its erterig
‘Section 136: AND and OR
Section 157: Use IN to rei
‘ows with @ value contained in ¢ list
Section 138 Use LIKE to find matching strings and substrings
0 Zh
Section 1510: Use HAVING
o check for multiple conditions in a
Chapter 14: SKIP TAKE (Pagination)
Section 14. Limiting amount of results
Section 142: Skipping then toking some results (Pagination)
section 143: Skipping some rows {rom result
Chapter 15: EXCEPT
Section 151i Select dataset exce
where values ore
Chapter 16: EXPLAIN and DESCRIBE ..
Section 16. EXPLAIN Select quer
Section 162: DESCRIBE toblenaMe ran
Chapter 17: EXISTS CLAUSE
on 171.6
Chapter 18: JOIN
3
a
31
32
32
33
3
35,
38
36
36
36
37
37
38
39
39
40
40
41
a
a
43
44
45,
45,
46
ss 6
46
a7
a7
AB.
43.
50
50
vs 50
51
52
52
on 53
53
53
54
55.Section 18.1: Self JOIN nmin stninnnininnnnninineniinininnnnnnnenninnenns 5S
Section 182: Differences between inner/outer joins 56
Section 183: JOIN Terminologur Inner, Outer. Semi, Anti 59
Section 18.4: Left Outer Join see 69
‘Section 185: Implicit Join . vn 70
Section 186: CROSS JOIN n
Section 187: CROSS APPLY & LATERAL JOIN. eon T2
on 18.8: ft son ' oe 7B
Section 189: Recursive JOINS a . sen se sens TA
Section 18,10; Basic explicit Inner IOI neu se sa scninnnnninnnnenne TA
lon 18.1" Joining on a 75,
Chapter 19: UPDATE se 76
ction 195% UPDATE with data from another tab! 76
Section 19,2: Modifying existing valves, 7
Section 193: Undating Specified Rows ..
‘Section 19.4: Updating All Rows .. . sen so 7 7
Section 19.5: Copturing Undated record's 7
Chapter 20: CREATE Database ........ ss se se se 78
Section 20.1 CREATE Database 78
Chapter 21: CREATE TABLE 79
Section 211: Create Table From Select suo 79
on 212: Cr we sn sen ee 7 79
Section 215: CREATE TABLE With FOREIGN KEY. .sironnnnnnn seni 73
lon 215: Create o Temporary or In-Memory TabIE snes smninsnsnninnninennsnennsnsnne 80
Chapter 22: CREATE FUNCTION ... se o ss 82
‘Saction 22:1 Create a new Function 82
Chapter 23: TRY/CATCH .csininninnnnnininininmininininnnnninnnnnininmninnnnnnnnnnnnnen 8B
Section 231: Transaction in a TRY/CATC 83
ster 24: UNION / UNION ALL
Section 241: Bosic UNION ALL quer 84
85
Chapter 25: ALTER TABLE
Section 251: Add Column(s)
Section 25.2: Drop Column
Section 25.3: Add Primary Ke
Section 254: Alter Colun
Chapter 26: INSERT .. sn vo
Section 261: INSERT data from another table using SELECT
Section 262 Insert New Row ..
Section 264: Insert multiple cows at once
Chapter 27: MERGE ....... o
Section 27.1 MERGE to make Target match Sour
Section 272: MySQL: counting users by name ...
jection 27°3 PostgreSOl: counting users by nam
Chapter 28: cross apply, outer apply
Section 28.1 CROSS APPLY and QUTER APPLY basics...Chapter 29: DELETE 22
291: DELETE all rows 92
9. iain rows with W sn 92
293 TRUNCATE clause 92
Section 294: DELETE certain rows bosed upon comparisons with other tables 92
Chapter 30: TRUNCATE 94
Section 30.1: Removing all rows from th: nnn vanes 94
Chapter 31: DROP Table 95,
section 311: Check for existence before dronpin: sen son smnennnnnne 95
‘Section 312 Simple drop 95,
Chapter 32: DROP or DELETE Database .......c0n o a o 96
Sect 96
hapter 33: a — a 7
Section 351: ON DELETE CASCADE 7
Chapter 34: GRANT and REVOKE 9
Section 341 Grant/revoke privileges 99
Chapter 35: XML 100
Section 35.1 Query from XML Dota Type -uinmnnnninmininininuiinninnnnnninnnmniennnnnnnnn 100
Chapter 36: Primary Keys 101
action 36%: Creating @ PAMAPY KEY nnsnnninmninmininenimnnnninminnninennnnnmnnnnnnnnnnns 101
Section 362: Using Auto Increment 101
Chapter 37: Indexes 102
Section 371 Sorted index 102
Section 3, 1102
jection 375. Creating dA INGEX nimmnmnmnmninmenininnnsnnannnanineninennmnnnnnnnanineneninenrnennne 102
Section 37.4: Dropping on Index or Disabling and Rebuilding it 103
Section 375: Clustered, Unique, and Sorted Indexes 103
‘Saction 32.6 Rebulld index smn ve se 104
Section 377: Inserting with 0 Unique Index 104
Chapter 38: Row number seven 105
Section 38.1 Delete All But Lost Record (1 to Many Table) 105
Section 382: Row numbers without partitions ssiinminminininineninimninnninnnnmnninennennnnsnnnnn 105
Section 38.3: Row numbers with partitions snes smn 105
Chapter 39: SOL Group By vs Distinct 106
Section 39.1 Difference between Gi 106
Chapter 40: Finding Duplicates on a Column Subset with Detail 107
Section 40 St with some name and dote of birth 107
Chapter 41: String Functions 108
Section 411: Concatenat 108
Section 412: Lenat! sinnnnninniinniiiinnninninnnnnininninnnnnnnnnennnnnns 108
Section 413: Trim empty spaces. svar . 109
Section 414: Upper & lower case 109
Section 415: Split rnin o oe sannnnnnenenenrneesee 109
Section 416 Replace 110
417. REGEXP 110
Section 418: Substri 110
SOCIO 419: SUE sasnmninmenninnninininmninnnenennsenn st — senninesnnen VIO
Section 410: LEFT - RIGHT 110REVERSE
REPLICATE
Section 4115: PARSENAME sso
Chapter 42: Functions (Aggregate)
422: Uist Concatenation
423. SUM
Section 42.4 AVGO
Section 425: Cour
Se
sclion 42.6 Min
Section 427: Max.
Chapter 43: Functions (Scalar/Single Row) ..
4511 Date And Time
43.2: Character
Section 433: Configuration and Conversion Function ..
Section 43.4: Logical and Mathmetical Funct
Chapter 44: Functions (Analutic)
Section 441: LAG and LEAD
Section 442: PERCENTILE DISC ond PERCENTILE CONT
Section 443: FIRST VALUE
Section 444 LAST VALUE
445: PERCENT RANK and CUME DIST
Sect
Chapter 45: Window Functions
fications
her rows have a commen py
vence" records using the LAGO function
Section 45.3: Getting o running total
Section 45.4: Adding the total rows selected to every row os
Section 4555: Getting the N most recent rows over multiple grouping
Chapter 46: Common Table Expressions
Section 46.1 generating values
Section 46.2 recursively enumerating a subtree
Section 463: Temporary quer
Section 46.4: recursively going up IN BOE . . vo
Section 46.5: Recursively generate dates. extended to include team rostering as example
Section 46.6: Oracle CONNECT BY functionality with recursive CTES
Chapter 47: Views
Section 4711 Simple views ..
Section 47.2: Complex views
hapter 48: Materialized View:
Section 48.1: PostoreSOL example
Chapter 49: Comments
Section 4911 Single-line comments
Chapter 50: Foreign Keys ..
Section 50.1 Foreign Keys explainec
Section 50,2: Creating a table with a foreign ke
Chapter 51: Sequence
m1
m1
1
2
2
114
114
14
116
116
116
M7
8
119
19
120
120
121
123
123
123,
vo 124
125
125
127
127
127
128
128
129
130
130
130
131
131
132
132
134
134
134
135
135
136
136
136
137
137
137
139Section 511: Create Sequence
Section 512: Using Sequences
Chapter 52: Subaveries . .
Section 521: Subquery in FROM clause
Section 52.2: Subquery in SELECT clause
section 5; very in WH
Section 52.6: Subqueries in FROM clause ..
Section 52.7: Subqueries in WHERE clause
hapter 53: Execution block:
Section 531: Using BEGIN. END
Chapter 54: Stored Procedures
in" for
Chapter 56: Transactions ....
jection 5611 Simple Transaction
Sectio
Chapter 57: Table Design
Section 57.1 Properties of a well designed table
Chapter 58: Synonyms
Section 58.1 Creote Synonym .
Chapter 59: Information Schema
Section 59.1 Basic Information Schema Seore!
Chapter 60: Order of Execution
section 601 Logical Order of Query Processing in SOL
Chapter 61: Clean Code in SQL sn
Section 61: Formatting and Spelling of Keywords and Names
Section 612: indenting
n 613: SELECT"
562: Rollback Transaction
Section 61,4: Join se
Chapter 62: SOL Injection ...
Section 621: SO injection sample
Section 62.2: simple injection somph
Credits
You may also like
139
139
140
140
140
140
140
140
141
1a
142
142
143
143
144
144
14a
145
145
145
146
146
147
147
148
148
149
149)
150
150
150
151
152
153
153
154
155
159About
Please feel free to share this PDF with anyone for free,
latest version of this book can be downloaded from:
https://goalkicker.com/SQLBook
This SQL Notes for Professionals book is compiled from Stack Overflow
Documentation, the content is written by the beautiful people at Stack Overflow.
Text content is released under Creative Commons BY-SA, see credits at the end
of this book whom contributed to the various chapters. Images may be copyright
of their respective owners unless otherwise specified
This is an unofficial free book created for educational purposes and is not
affiliated with official SQL group(s) or company(s) nor Stack Overflow. All
trademarks and registered trademarks are the property of their respective
company owners
‘The information presented in this book is not guaranteed to be correct nor
accurate, use at your own risk
Please send feedback and corrections to
[email protected]
Goolkicker-com - SQL Notes for Professionals,Chapter 1: Getting started with SQL
Version Short Name Standard Release Date
1986 — SQL-86 ANSI X3.135-1986, ISO 9075:1987, 1986-01-01
1989 SQL-89 ANSI X3,135-1989, ISO/IEC 9075:1989 1989-01-01
1992 SQL-92 ISOMEC 9075:1992 1992-01-01
1999 $QL:1999— ISOMEC 9075:1999 1999-12-16
2003 $QL:2003_ISOMEC 9075:2003 2003-12-15
2005 SQL2006 ISO/IEC 9075:2006, 2006-06-01
(2008 = $QL:2008 ~— ISOMEC 9075:2008 2008-07-15,
2011 sQu2011_IsONEC 9075:2011 2011-12415
2016 SQL2016 ISO/EC 9075:2015, 2016«12-01
Section 1.1: Overview
Structured Query Language (SQL) is a special-purpose programming language designed for managing data held in a
Relational Database Management System (RDBMS). SQL-like languages can also be used in Relational Data Stream
Management Systems (RDSMS), or in "not-only SQL” (NoSQL) databases.
‘SQL comprises of 3 major sub-languages
1. Data Definition Language (DDL): to create and modify the structure of the database;
2. Data Manipulation Language (DML): to perform Read, Insert, Update and Delete operations on the data of
the database;
3. Data Control Language (DCL): to control the access of the data stored in the database.
SOL article on Wikipedia
‘The core DML operations are Create, Read, Update and Delete (CRUD for short) which are performed by the
statenents INSERT, SELECT, UPDATE and DELETE.
There is also a (recently added) MERGE statement which can perform all 3 write operations (INSERT, UPDATE,
DELETE),
CRUD article on Wikipedia
Many SQL databases are implemented as client/server systems; the term "SQL server" describes such a database.
‘At the same time, Microsoft makes a database that is named "SQL Server". While that database speaks a dialect of
SQL. information specific to that database is not on topic in this tag but belongs into the SQL Server documentation,
Goolkicker-com - SQL Notes for Professionals, 2Chapter 2: Identifier
‘This topic is about identifiers, ie. syntax rules for names of tables, columns, and other database objects.
Where appropriate, the examples should cover variations used by different SQL implementations, or identify the
‘SQL implementation of the example.
Section 2.1: Unquoted identifiers
Unquoted identifiers can use leters (a2), digits (28), and underscore (.), and must start with a letter
Depending on SQL implementation, and/or database settings, other characters may be allowed, some even as the
first character, e.g.
MS SQL: 8 §, #, and other Unicode letters (source
MySQL: $ (source)
Oracle: §, #, and other letters from database character set (source
PostgreSQL. §, and other Unicode letters (source)
Unquoted identifiers are case-insensitive. How this is handled depends greatly on SQL implementation:
+ MS SQL: Case-preserving, sensitivity defined by database character set, so can be case-sensitive
MySQL: Case-preserving, sensitivity depends on database setting and underlying file system.
Oracle: Converted to uppercase, then handled like quoted identifier.
PostgreSQL: Converted to lowercase, then handled like quoted identifier
SQLite: Case-preserving; case insensitivity only for ASCII characters.
Goolkicker-com - SQL Notes for Professionals,Chapter 3: Data Types
Section 3.1: DECIMAL and NUMERIC
Fixed precision and scale decimal numbers. DECIMAL. and NUNERIC are functionally equivalent.
Syntax:
DECIMAL ( precision | , scale
NUMERIC ( precision | | scale
Examples:
SELECT CAST(123. AS DECIMAL(S,2)) --returns 123.00
SELECT CAST(12345.12 AS NUMERIC(1®, 5)) --returns 12345.12000
Section 3.2: FLOAT and REAL
Approximate-number data types for use with floating point numeric data,
SELECT CAST( PI() AS FLOAT) --returns 3.14159265358079
SELECT CAST( PI() AS REAL) ~-returns 9.141893,
Section 3.3: Integers
Exact-number data types that use integer data.
Data type Range Storage
bigint —-2%63 (-9,223,372,036,854,775,808) to 2%63-1 (9,223,372,036,854,775,807) 8 Bytes
int 2931 (2,147 483,648) to 2931-1 (2,147,483,647) 4 Bytes
smallint -215 (-32,768) to 2415-1 (32,767) 2 Bytes
tinyint 0 t0 255, 1 Byte
Section 3.4: MONEY and SMALLMONEY
Data types that represent monetary or currency values,
Data type Range Storage
money _-922,337,203,685,477.5808 to 922,337,203,685,477.5807 & bytes
smallmoney -214,748,3648 to 214,748.3647 bytes
Section 3.5: BINARY and VARBINARY
Binary data types of either fixed length or variable length,
syntax:
BINARY [ ( nbytes )
VARBINARY [ ( nbytes | max ) ]
n_hytes can be any number from 1 to 8000 bytes, max indicates that the maximum storage space Is 2431-1
Goolkicker-com - SQL Notes for Professionals,Examples:
SELECT CAST(12345 AS BINARY(1@)) -- exoeaaee0e000008003039
SELECT CAST(12345 AS VARBINARY(16)) -- @x00803039
Section 3.6: CHAR and VARCHAR
String data types of either fixed length or variable length.
syntax:
CHAR [ ( nchars ) |
VARCHAR [ ( nchars ) |
Examples:
SELECT CAST(*ABC' AS CHAR(10)) -- ‘ABC (padded with spaces on the right)
SELECT CAST("ABC' AS VARCHAR(1@)) ~~ ‘ABC’ (no padding due to variable character)
SELECT CAST(*ABCOEFGHIJKLNNOPORSTUVWKYZ' AS CHAR(1)) -- ‘ABCDEFGHIJ' (truncated to 1@ characters)
Section 3.7: NCHAR and NVARCHAR
UNICODE string data types of either fixed length or variable length,
syntax:
NCHAR [ ( nchars )
NVARCHAR [ ( nchars | MAX )
Use WX for very long strings that may exceed 8000 characters.
Section 3.8: UNIQUEIDENTIFIER
A 16-byte GUID / UID.
DECLARE @GUID UNTQUEIDENTIFIER = NEWID()
SELECT @GUID -- "E28B3BD9-9174~41A9-B508-B99A78A39540"
DECLARE @bad_GUTD_string VARCHAR(100) = ‘£2889BD9-9174-41A9-8508-899A78A33540_foobarbaz
SELECT
@bad_GUID_string, ~~ '£2863BD9-9174-41A9-8508-899A78A33540_foobarbaz
CONVERT (UNIQUEIDENTIFIER, @bad_GUID_string) -~ 'E28B3BD9-9174-41A9-8508-899A7EAI9540
Goolkicker-com - SQL Notes for Professionals, 5Chapter 4: NULL
NULL in SQL, as well as programming in general, means literally "nothing". In SQL, itis easier to understand as “the
absence of any value"
Itis important to distinguish it from seemingly empty values, such as the empty string ** or the number 8, neither
‘of which are actually NULL.
Itis also important to be careful not to enclose NULL in quotes, like "NULL’, which is allowed in columns that accept
text, but is not NULL and can cause errors and incorrect data sets
Section 4.1: Filtering for NULL in queries
The syntax for filtering for NULL (ie. the absence of a value) in WHERE blocks is slightly different than filtering for
specific values.
SELECT * FROM Employees WHERE ManagerTd IS NULL
SELECT * FROM Employees WHERE ManagerId IS NOT NULL
Note that because NULL is not equal to anything, not even to itself, using equality operators = NULL or <> NULL (or
= NULL) will always yield the truth value of UNKNOWN which will be rejected by WHERE.
WHERE fters all rows that the condition is FALSE or UKNOWN and keeps only rows that the condition is TRUE.
Section 4.2: Nullable columns in tables
When creating tables itis possible to declare a column as nullable or non-nullable.
CREATE TABLE MyTable
- non=nullable
nullable
MyCol1 INT NOT NULL,
MyCol2 INT NULL
By default every column (except those in primary key constraint) is nullable unless we explicitly set NOT NULL
constraint,
Atternpting to assign NUL to a non-nullable column will result in an error.
INSERT INTO MyTable (MyCol1, MyCol2) VALUES (1, NULL) ; ~~ works fine
INSERT INTO MyTable (MyCol1, MyCol2) VALUES (NULL, 2)
cannot inse
the value NULL into column ‘MyCol1', table ‘MyTable
column does not allow nulls. INSERT fails.
Section 4.3: Updating fields to NULL
Setting afield to NULL works exactly lke with any other value:
UPDATE Employees
SET ManagerId = NULL
WHERE Td = 4
Goolkicker-com - SQL Notes for Professionals,Section 4.4: Inserting rows with NULL fields
For example inserting an employee with no phone number and no manager into the Employees example table:
INSERT INTO Employees
(Id, FName, Lame, PhoneNunber, MenagerId, DepartmentId, Salary, HireDate)
VALUES
(5, ‘Jane’, ‘Doe’, NULL, NULL, 2, 888, '2016-07-22")
Goolkicker-com - SQL Notes for Professionals,Chapter 5: Example Databases and Tables
Section 5.1: Auto Shop Database
In the following example - Database for an auto shop business, we have a list of departments, employees,
‘customers and customer cars, We are using foreign keys to create relationships between the various tables.
Live example: SOL fiddle
Relationships between tables
‘+ Each Department may have 0 or more Employees
‘+ Each Employee may have 0 or 1 Manager
* Each Customer may have 0 or more Cars
Departments
Id Name
1 HR
2 Sales
3 Tech
‘SQL statements to create the table:
CREATE TABLE Departments (
Td INT NOT NULL AUTO_INCREMENT,
Name VARCHAR(25) NOT NULL.
PRIMARY KEV(Td)
INSERT INTO Departments
[14], [Name]
VALUES
1, CHR)
(2, ‘sales')
(3, ‘Tech’
Employees
IdFName LName PhoneNumber Managerld Departmentid Salary HireDate
1 James Smith 1234567890 NULL 1 1000 01-01-2002
2 John Johnson 24681012141 1 400. 23-03-2005,
3 Michael Williams 13579111311 2 600 12-05-2009
4 Johnathon Smith 12121212122 1 500 24-07-2016
‘SQL statements to create the table:
CREATE TABLE Employees (
Id INT NOT NULL AUTO_INCREMENT,
FName VARCHAR(35) NOT NULL,
LName VARCHAR(35) NOT NULL,
PhoneNunber VARCHAR(11)
Managertd INT
DepartmentId INT NOT NULL,
Goolkicker-com - SQL Notes for Professionals,Salary INT NOT NULL
HireDate DATETIME NOT NULL
PRIMARY KEY(Id)
FOREIGN KEY (NanagerId) REFERENCES Employees(Id)
FOREIGN KEY (DepartmentId) REFERENCES Departments (Id)
INSERT INTO Enployees
((1d), [FName), [LName), [PhoneNunber), [ManagerId), [Departmentid), (Salary
VALUES
(1, ‘James", ‘Smith’, 1234567890, NULL, 1, 1808, '@1-01-2002")
2, ‘John’, ‘Johnson’, 2468101214, '1', 1, 408, '23-03-2605')
(3, ‘Michael’, ‘Willians’, 1957911191, °1°, 2, 608, '12-@5-2009")
4, ‘Johnathon’, ‘Smith, 1212121212, '2', 1, 588, '24-07-2016")
Customers
Id FName LName Email PhoneNumber PreferredContact
1 William Jones william
[email protected] 3347927472 PHONE
2 David Miller
[email protected] 2137921892 EMAIL
3 Richard Davis
[email protected] NULL EMAIL
‘SQL statements to create the table:
CREATE TABLE Customers (
Id INT NOT NULL AUTO_INCREMENT,
FName VARCHAR(35) NOT NULL.
UName VARCHAR(35) NOT NULL.
Email verchar(108) NOT NULL.
PhoneNunber VARCHAR(11)
PreferredContact VARCHAR(5) NOT NULL.
PRIMARY KEY(Id)
INSERT INTO Customers
((Td], [FName}, (LName), [Email], [PhoneNunber}, [PreferredContact])
VALUES
(1, ‘Willian’, "Jones", ‘william.
[email protected]’, "3347927472", "PHONE
2. ‘David’, ‘Miller’, ‘dmillergexample.net', '2137921892', ' EMATL’
(3, ‘Richard’, ‘Davis’, ‘richard®1238exanple.com’, NULL, ‘EMAIL’
cars
Id Customerld Employeeld Model Status Total Cost
4 2 FordF-150 READY 230
21 2 FordF-150 READY 200
32 1 Ford Mustang WAITING 100
43 3 Toyota Prius WORKING 1254
‘SQL statements to create the table:
CREATE TABLE Cars (
Td INT NOT NULL AUTO_INCREMENT,
CustomerId INT NOT NULL
Enployeetd INT NOT NULL
Model verchar(5@) NOT NULL
Status varchar(25) NOT NULL
HireDate))
Goolkicker-com - SQL Notes for Professionals,TotalCost INT NOT NULL
PRIMARY KEY(Id)
FOREIGN KEY (CustomerId) REFERENCES Customers (Id
FOREIGN KEY (EmployeeId) REFERENCES Enployees(Id)
INSERT INTO Cars
[Id], [Customertd], [Employed], [Model], [Status], [TotalCost))
VALUES
15, (11, '2', "Ford F-158", 'READY', '238")
2° 1", 12) "Ford F-158", "READY’, '208"
3°, '2', ‘1, ‘Ford Mustang’, ‘WAITING’, '160")
(14", °3", 13") "Toyota Prius’, "WORKING, '1254")
Section 5.2: Library Database
In this example database fora library, we have Authors, Books and BooksAuthors tables.
Live example: SOL fiddle
Authors and Books are known as base tables, since they contain column definition and dats for the actual entities in
the relational model. BooksAuthors is known as the relationship table, since this table defines the relationship
between the Books and Authors table.
Relationships between tables
‘+ Each author can have 1 or more books
* Each book can have 1 or more aut!
Authors
(View table)
IdName Country
1 J.D.Salinger USA
2 F. Scott. Fitzgerald USA
3 Jane Austen UK
4 Scott Hanselman USA
5 Jason N. Gaylord USA
6 Pranav Rastogi India
7 Todd Miranda USA
8 Christian Wenz USA
SQL to create the table:
CREATE TABLE Authors
Id INT NOT NULL AUTO_INCREMENT,
Name VARCHAR(7@) NOT NULL.
Country VARCHAR(1@@) NOT NULL.
PRIMARY KEY(Id)
INSERT INTO Authors
Goolkicker-com - SQL Notes for Professionals, 70(Name, Country)
VALUES
(J.D. Salinger’, “USA')
°F, Scott. Fitzgerald’, ‘USA
“Jane Austen’, "UK")
“Scott Hanselman’, 'USA’)
“Jason N. Gaylord’, “USA')
“Pranay Rastogi’, ‘India')
“Todd Miranda’, ‘USA’
“christian Wenz’, ‘USA')
Books
laTitle
The Catcher in the Rye
Nine Stories
Franny and Zooey
Tender id the Night
Pride and Prejudice
Professional ASP.NET 4.5 in C# and VB.
1
2
3
4 The Great Gatsby
5
6
7
SQL to create the table:
CREATE TABLE Books (
Id INT NOT NULL AUTO_INCREMENT.
Title VARCHAR(S®) NOT NULL
PRIMARY KEY (Id)
INSERT INTO Books
(Id, Title)
VALUES
qa
“The Catcher in the Rye")
2, ‘Nine Stories’)
(3, ‘Franny and Zooey’)
(4, ‘The Great Gatsby")
(S. ‘Tender id the Night")
(6, ‘Pride and Prejudice’),
(7, "Professional ASP.NET 4.5 in C# and VB")
BooksAuthors
(view table)
Bookld Authorid
1
ween
1
Goolkicker-com - SQL Notes for Professionals,evaune
SQL to create the table:
CREATE TABLE BooksAuthors (
‘Authorid INT NOT NULL
BookId INT NOT NULL.
FOREIGN KEY (AuthorId) REFERENCES Authors(Id)
FOREIGN KEY (BookId) REFERENCES Books( Id)
INSERT INTO BooksAuthors
(BookId, Authorid)
VALUES
(1)
(2.1)
3.1)
(4 2)
5, 2)
(6 3)
7.4)
78
7. 6)
@.
7
Examples
View all authors (view live example):
SELECT * FROM Authors:
View all book titles (view live example):
SELECT * FROM Books
View all books and their authors (view live example!
SELECT
ba. Authorid
@.Neme AuthorNane,
ba. BookId:
b.Title BookTitle
FROM BooksAuthors ba
INNER JOIN Authors @ ON a.id = ba.authorid
INNER JOIN Books b ON b.id = ba.bookid
Goolkicker-com - SQL Notes for Professionals,Section 5.3: Countries Table
In this example, we have a Countries table. A table for countries has many uses, especially in Financial applications
involving currencies and exchange rates.
Live example: SOL fiddle
‘Some Market data software applications like Bloomberg and Reuters require you to give their API either a 2 or 3
character country code along with the currency cade. Hence this example table has bath the 2-character 180 code
column and the 3 character 1803 code columns.
Countries
view table)
Id IS0 1SO3 ISONumeric CountryName Capital __ContinentCode CurrencyCode
1 AU AUS 36 Australia Canberra. OC AUD
2 DE DEU 276 Germany Berlin. EU EUR
2 IN IND 356 India New Delhi AS INR
3 LA LAO 418 Laos Vientiane AS LAK
4 US USA 840 United States Washington NA usp
5 ZW 2WE 716, Zimbabwe Harare. A Ze
SQL to create the table:
CREATE TABLE Countries (
Id INT NOT NULL AUTO_INCREMENT,
TSO VARCHAR(2) NOT NULL
1803 VARCHAR(3) NOT NULL
Ts0Numerie INT NOT NULL
CountryName VARCHAR(64) NOT NULL.
Capital VARCHAR(64) NOT NULL,
ContinentCode VARCHAR(2) NOT NULL
CurrencyCode VARCHAR(3) NOT NULL,
PRIMARY KEY(Td)
INSERT INTO Countries
(180, 1803, ISONumeric, CountryName, Capital, ContinentCode, CurrencyCode)
VALUES
(AU', "AUS", 96, “Australia’, ‘Canberra’, ‘Oc’, “AUD')
DE", "DEU', 276, ‘Germany’, ‘Berlin’, "EU', ‘EUR')
COIN", "IND", 956, "India", ‘New Delhi", “AS, "INR")
LA", "LAO", 418, ‘Laos’, ‘Vientiane’, 'AS', ‘LAK')
(US", "USA", 849, ‘United States’, ‘Washington’, ‘NA’, "USD"
ZW’, '7WE'| 716, ‘Zimbabwe’, ‘Harare’, "AF", ‘ZWL"
Goolkicker-com - SQL Notes for Professionals, 3Chapter 6: SELECT
‘The SELECT statement is at the heart
f most SQL queries. It defines what result set should be returned by the
query, and is almost always used in conjunction with the FROM clause, which defines what part(s) of the database
should be queried,
Section 6.1: Using the wildcard character to select all columns
in a query
Consider a database with the following two tables.
Employees tabl
Id FName LName Deptid
1 James smith 3
2 John Johnson 4
Departments table:
ld Name
1 Sales
2 Marketing
3 Finance
4a
‘Simple select statement
sisthe
{card character used to select all available columns in a table,
When used as a substitute for explicit column names, it returns all columns in all tables that a query is selecting,
FROM, This effect applies to all tables the query accesses through its JOIN clauses,
Consider the following query:
SELECT * FROM Employees
It will return all fields of all rows of the Employees table:
Id FName LName Deptid
1 James smith 3
2 John Johnson 4
Dot notation
To select all values from a specific table, the wildcard character can be applied to the table with dot notation,
Consider the following query:
SELECT
Employees.
Departments. Nane
FROM
Enployees
JOIN
Goolkicker-com - SQL Notes for Professionals,Departments
ON Departments. Id = Enployees.Deptid
This will return a data set with all fields on the Employee table, followed by just the Nane field in the Departments
table:
Id FName LName Deptid Name
1 James smith 3 Finance
2 John Johnson4 IT
Warnings Against Use
Itis generally advised that using + is avoided in production code where possible, as it can cause a number of
potential problems including:
1. Excess 10, network load, memory use, and so on, due to the database engine reading data that is not needed
and transmitting it to the front-end code. This is particularly a concern where there might be large fields such
as those used to stare long notes or attached files.
2. Further excess 10 load if the database needs to spool internal results to disk as part of the processing for a
query more complex than SELECT
FROM .
3. Extra processing (and/or even more 10) if some of the unneeded columns are:
© computed columns in databases that support them
@ in the case of selecting from a view, columns from a table/view that the query optimiser could
otherwise optimise out
4, The potential for unexpected errors if columns are added to tables and views later that results ambiguous
column names. For example SELECT = FROM orders JOIN people ON people.id = orders.personid ORDER
BY displayname - if a column column called di splaynane is added to the orders table to allow users to give
their orders meaningful names for future reference then the column name will appear twice in the output so
the ORDER BY clause will be ambiguous which may cause errors ("ambiguous column name” in recent MS SQL
Server versions), and if not in this example your application code might start displaying the order narne
where the person name is intended because the new column is the first of that name returned, and so on.
When Can You Use #, Bearing The Above Warning In Mind?
While best avoided in production code, using «is fine as a shorthand when performing manual queries against the
database for investigation or prototype work,
‘Sometimes design decisions in your application make it unavoidable (in such circumstances, prefer tablealias.*
‘over just « where possible},
When using EXISTS, such as SELECT A.col1, A.Col2 FRON A WHERE EXISTS (SELECT * FROM B where A.ID
B.A_TD), we are not returning any data from B. Thus a join is unnecessary, and the engine knows no values from B
are to be returned, thus no performance hit for using «. Similarly COUNT() is fine as it also doesn’t actually return
any of the columns, so only needs to read and process those that are used for filtering purposes.
Section 6.2: SELECT Using Column Aliases
Column aliases are used mainly to shorten code and make column names more readable.
Code becomes shorter as long table names and unnecessary identification of columns (eg. there may be 2 JDs in the
table, but only one is used in the statement) can be avoided. Along with table aliases this allows you to use longer
descriptive names in your database structure while keeping queries upon that structure concise.
Furthermore they are sometimes required, for instance in views, in order to name computed outputs.
Goolkicker-com - SQL Notes for Professionals, ®All versions of SQL
Aliases can be created in all versions of SQL using double quotes (").
SELECT
FName AS “First Name”
Wane AS "Middle Name’
LName AS “Last Name"
FROM Employees
Different Versions of SQL.
You can use single quotes (’), double quotes (") and square brackets ([]) to create an alias in Microsoft SQL Server.
SELECT
FName AS “First Name”
WWame AS “Middle Name
LName AS [Last Name
FROM Employees
Both will result in:
First Name Middle Name Last Name
James John. ‘Smith
John James Johnson
Michael Marcus Williams
This statement will return FName and LName columns with a given name (an alias). This is achieved using the AS
‘operator followed by the alias, or simply writing alias directly after the column name, This means that the following,
query has the samme outcome as the above.
SELECT
FName “Firet Name”
Wane “Middle Name
LName “Last Name’
FROM Employees
First Name Middle Name Last Name
James John. Smith
John James Johnson
Michael Marcus Williams
However, the explicit version (ie., using the AS operator) is more readable.
Ifthe alias has a single word that is nota reserved word, we can write it without single quotes, double quotes or
brackets:
SELECT
FName AS FirstName
LName AS LastName
FROM Employees
FirstName LastName
James Smith
John Johnson
Michael Williams
Goolkicker-com - SQL Notes for Professionals, 6A further variation available in MS SQL Server amongst others is = , for
instance:
SELECT FullNane = FirstNane +‘ * + LastName
Addrl = FullStreetAddress.
Addr2 = TownNane
FROM CustomerDetails
which is equivalent to:
SELECT FirstName + ° ' + LastName As FullNane
FullStreetAddress. As Addr
Townliane As Addr2
FROM CustomerDetails
Both will result in:
FullName Addr Addr2
James Smith 123 AnyStreet_ Townville
John Johnson 668 MyRoad Anytown
Michael Williams 999 High End Dr Williamsburgh
‘Some find using = instead of As easier to read, though many recommend against this format, mainly because itis
not standard so not widely supported by all databases. It may cause confusion with other uses of the = character.
All Versions of SQL
Also, f you need to use reserved words, you can use brackets or quotes to escape:
SELECT
FName as *SELEC
WName as “FROM”
LName as “WHERE
FROM Employees
Different Versions of SQL.
Likewise, you can escape keywords in MSSQL with all different approaches:
SELECT
FName AS “SELECT
Name AS ° FROM!
Lame AS [HEI
FROM Employees
SELECT FROM WHERE
James John Smith
John James Johnson
Michael Marcus Williams
Also, a column alias may be used any of the final clauses of the same query, such as an ORDER BY:
SELECT
FName AS FirstName,
LName AS LastName
FROM
Goolkicker-com - SQL Notes for Professionals,Enployees
ORDER BY
LastName DESC
However, you may not use
SELECT
FName AS SELECT
LName AS FROM
FROM
Enployees
ORDER BY
LastName DESC
To create an alias from these reserved words (SELECT and FROM)
This will cause numerous errors on execution.
Section 6.3: Select Individual Columns
SELECT
PhoneNunber
Email
PreferredContact
FROM Customers
‘This statement will return the columns PhoneNunber, Enail, and Preferredcontact from all rows of the Customers
table. Also the columns will be returned in the sequence in which they appear in the SELECT clause.
The result will be:
PhoneNumber Email PreferredContact
3347927472 william [email protected] PHONE
2137921892 —_dmiller@examplenet EMAIL
NULL [email protected] EMAIL
If multiple tables are joined together, you can select columns from specific tables by specifying the table name
before the column name: (table_nane] .[colunn_nane
SELECT
Customers. PhoneNunber.
Customers. Enail
Customers .PreferredContact
Orders.Id AS OrderId
FROM
Customers
LEFT JOIN
Orders ON Orders.custonerId ~ Customers. Id
AS OrderTd means that the Td field of Orders table will be returned as a column named OrderTd, See selecting
with column alias for further information,
To avoid using long table names, you can use table aliases. This mitigates the pain of writing long table names for
‘each field that you select in the joins. I you are performing a self join (a join between two instances of the same
table), then you must use table aliases to distinguish your tables. We can write a table alias like Custoners ¢ or
Customers AS ¢, Here ¢ works as an alias for Custoners and we can select let's say Enail like this: ¢ Email.
Goolkicker-com - SQL Notes for Professionals, 6SELECT
¢. PhoneNlunber:
Email,
©. Preferredcontact,
0.Td AS OrderTd
FROM
Customers ©
LEFT JOIN
Orders © ON o.CustomerId = ¢.Id
Section 6.4: Selecting specified number of records
‘The SQL 2008 standard defines the FETCH FIRST clause to limit the number of records returned.
SELECT Té, ProductName, UnitPrice, Package
FROM Product
ORDER BY UnitPrice DESC
FETCH FIRST 1@ ROHS ONLY
This standard is only supported in recent versions of some RDMSs. Vendor-specific non-standard syntax is provided
in other systems. Progress OpenEdge 11.x also supports the FETCH FIRST ROWS ONLY syntax.
‘Additionally, OFFSET ROWS before FETCH FIRST RONS ONLY allows skipping rows before fetching rows,
SELECT Ié, ProductName, UnitPrice, Package
FROM Product
ORDER BY UnitPrice DESC
OFFSET 5 ROWS
FETCH FIRST 18 ROWS ONLY
The following query is supported in SQL Server and MS Access:
SELECT TOP 10 Id, ProductName, UnitPrice, Package
FROM Product
ORDER BY UnitPrice DESC
To do the same in MySQL or PostgreSQL the LIMTT keyword must be used:
SELECT Té, ProductName, UnitPrice, Package
FROM Product
ORDER BY UnitPrice DESC
Limit 18
In Oracle the same can be done with RONNUM:
SELECT Ié, ProductName, UnitPrice, Package
FROM Product
WHERE ROWNUM <= 10
ORDER BY UnitPrice DESC
Results: 10 records,
Id ProductName UnitPrice Package
38 Céte de Blaye 263.50 12 - 75 cl bottles
29 Thiringer Rostbratwurst 123.79 50 bags x 30 sausgs.
9 Mishi Kobe Niku 97.00 18 - 500 g pkgs
Goolkicker-com - SQL Notes for Professionals, e20 Sir Rodney's Marmalade 81.00 30 gift boxes
18 Carnarvon Tigers 62.50 16 kg pkg.
59 Raclette Courdavault 55.00 5 ka pkg
51 Manjimup Dried Apples 53.09 50 - 300g pkgs.
62 Tarte au sucre 49.30 48 pies
43° Ipoh Coffee 46.00 16 - 500 g tins
28 -Rossle Sauerkraut 45,60 25 = 825 9 cans
Vendor Nuances
Itis important to note that the TOP in Microsoft SQL operates after the WHERE clause end will return the specified
number of results if they exist anywhere in the table, while ROHNUM Works as part of the NHERE clause so if other
conditions do not exist in the specified number of rows at the beginning of the table, you will get zero results when
there could be others to be found.
Section 6.5: Selecting with Condition
‘The basic syntax of SELECT with WHERE clause is:
SELECT colunn’, column2, column
FROM table_nane
WHERE [condition]
The {condition} can be any SQL expression, specified using comparison or logical operators like >, <, =, <>,>=,
LIKE, NOT, IN, BETWEEN etc.
The following statement returns all columns from the table ‘Cars’ where the status column is ‘READY’
SELECT * FROM Care WHERE status = ‘READY’
See WHERE and HAVING for more examples.
Section 6.6: Selecting with CASE
When results need to have some logic applied ‘on the fly’ one can use CASE statement to implement it.
SELECT CASE WHEN Col1 < S@ THEN ‘under’ ELSE ‘over’ END threshold
FROM TableName
also can be chained
SELECT
CASE WHEN Colt < 5 THEN ‘under
WHEN Col1 > 59 AND Coll <10@ THEN ‘between
ELSE ‘over"
END threshold
FROM TableName
‘one also can have CASE inside another CASE staternent
SELECT
CASE WHEN Coll < 58 THEN ‘under
ELSE
CASE WHEN Coll > 5@ AND Coll <100 THEN Colt
ELSE ‘over” END
END threshold
Goolkicker-com - SQL Notes for Professionals, 20FROM TableName
Section 6.7: Select columns which are named after reserved
keywords
When a column name matches a reserved keyword, standard SQL requires that you enclose it in double quotation
marks:
SELECT
“ORDER™
1D
FROM ORDERS
Note that it makes the column name case-sensitive,
Some DBMSes have proprietary ways of quoting names. For example, SQL Server uses square brackets for this
Purpose:
SELECT
Order]
1D
FROM ORDERS.
while MySQL (and MariaDB) by default use backticks:
SELECT
Order
ad
FROM orders
Section 6.8: Selecting with table alias
SELECT e.Fname, @.LName
FROM Employees e
The Employees table is given the alias e’ directly after the table name. This helps remove ambiguity in scenarios
where multiple tables have the same field name and you need to be specific as to which table you want to return
data from,
SELECT e.Fname, @.LNane, m.Frane AS ManagerFirstName
FROM Employees e
JOIN Managers m ON e.MenagerTd = m.Id
Note that once you define an alias, you can't use the canonical table name anymore. ie.,
SELECT e.Fname, Employees.LName, m.Fname AS ManagerFirstName
FROM Employees e
JOIN Managers m ON e.Managerid = m.Id
would throw an error.
Itis worth noting table aliases ~ more formally ‘range variables’ -- were introduced into the SQL language to solve
the problem of duplicate columns caused by INNER JOIN. The 1992 SQL standard corrected this earlier design flaw
by introducing NATURAL. JOTN (implemented in mySQL, PostgreSQL and Oracle but not yet in SQL Server), the result
‘of which never has duplicate column names. The above example is interesting in that the tables are joined on
Goolkicker-com - SQL Notes for Professionals, acolumns with different names (Id and Manager1d) but are not supposed to be joined on the columns with the same
name (LNane, FName), requiring the renaming of the columns to be performed before the join:
SELECT Fame, LName, ManagerFirstName
FROM Employees
NATURAL, JOIN
( SELECT Td AS ManagerT¢, Frame AS ManagerFirstName
FROM Managers ) m
Note that although an alias/range variable must be declared for the dervied table (otherwise SQL will throw an.
error), it never makes sense to actually use it in the query.
Section 6.9: Selecting with more than 1 condition
‘The AND keyword is used to add more conditions to the query
Name Age Gender
sam 18 M
John 21 M
Bob 22 M
Mary 23 F
SELECT name FROM persons WHERE gender = °M’ AND age > 20
This will return:
Name
John
Bob
using 08 keyword
SELECT name FROM persons WHERE gender - 'M' OR age < 28
This will return
name
sam
John
Bob
‘These keywords can be combined to allow for more complex criteria combinations:
SELECT name
FROM persons
WHERE (gender = "M' AND age < 28)
08 (gender = “F' AND age > 28)
This will return:
sam
Mary
Goolkicker-com - SQL Notes for Professionals, 2Section 6.10: Selecting without Locking the table
Sometimes when tables are used mostly (or only) for reads, indexing does not help anymore and every little bit
counts, one might use selects without LOCK to improve performance.
SQL Server
SELECT * FROM TableNane WITH (nolock)
Mysql
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED
SELECT * FROM TableNane
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ
Oracle
TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
SELECT * FROM TableName
paz
SELECT * FROM TableName WITH UR
Where UR stands for "uncommitted read”
ble results,
Irused on table that has record modifications going on might have unpredict
Section 6.11: Selecting with Aggregate functions
Average
The AVO() aggregate function will return the average of values selected.
SELECT AVG(Salary) FROM Employees
Aggregate functions can also be combined with the where clause.
SELECT AVG(Salary) FROM Employees where DepartmentId = 1
‘Aggregate functions can also be combined with group by clause.
If employee is categorized with multiple department and we want to find avg salary for every department then we
can use following query.
SELECT AVG(Salary) FROM Employees GROUP BY DepartmentId
Minimum.
The NTN() aggregate function will return the minimum of values selected.
SELECT MIN(Salary) FROM Enployees
Maximum
The HX() aggregate function will return the maximum of values selected.
SELECT WAx(Salary) FROM Employees
count
‘The COUNT () aggregate function will return the count of values selected.
SELECT Count(*) FROM
It can also be combined with where conditions to get the count of rows that satisfy specific conditions.
oyees
Goolkicker-com - SQL Notes for Professionals, BSELECT Count(*) FROM Employees where ManagerTd TS NOT NULL
Specific columns can also be specified to get the number of values in the column. Note that NULL values are not
counted.
Select Count(Managerid) from Employees
Count can also be combined with the distinct keyword for a distinct count.
Select Count (DISTINCT DepartmentId) from Employees
sum
The SUM() aggregate function returns the sum of the values selected for all rows,
SELECT SUM(Salary) FROM Employees
Section 6.12: Select with condition of multiple values from
column
SELECT * FROM Cars WHERE status IN ( ‘Waiting’, ‘Working
This is semantically equivalent to
SELECT * FROM Care WHERE ( status
‘Waiting’ OR status
"Working"
lle, value IN ( ‘ACCOUNTING’
GROUP BY department
Ifyou need to filter the results after the grouping has been done, e.g, to see only departments whose average
income is larger than 1000, you need to use the HAVING clause:
SELECT departnent, AVG(income)
FROM employees
WHERE department <> ‘ACCOUNTING’
GROUP BY department
HAVING avo(incore) > 1900
Goolkicker-com - SQL Notes for Professionals, aSection 6.14: Selection with sorted Results
SELECT FROM Employees ORDER BY LNane
‘This statement will return all the columns from the table Employees,
Id FName LName PhoneNumber
2 John — Johnson 2468101214
1 James Smith 1234567890
3 Michael Williams 1357911131
SELECT * FROM Employees ORDER BY LName DESC
or
SELECT * FROM Employees ORDER BY LName ASC
This statement changes the sorting direction.
One may also specify multiple sorting columns. For example:
SELECT * FROM Employees ORDER BV LName ASC, FName ASC
This example will sort the results first by LName and then, for records that have the same LNane, sort by FName, This
will give you a result similar to what you would find in a telephone book.
In order to save retyping the column name in the ORDER BY clause, itis possible to use instead the column's
number, Note that column numbers start from 1.
SELECT Té, FName, LName, PhoneNunber FROM Employees ORDER BY 3
You may also embed a CASE statement i
€ ORDER @Y clause.
SELECT Id, FName, LName, PhoneNunber FROM Employees ORDER BY CASE WHEN LName='Jones’ THEN @ ELSE 1
END ASC
‘This will sort your results to have all records with the LName of "jones" at the top.
Section 6.15: Selecting with null
SELECT Name FROM Customers WHERE PhoneNumber TS NULL
ise 1S NULL OF IS NOT NULL instead.
Selection with nulls take a different syntax. Don't use
Section 6.16: Select distinct (unique values only)
SELECT DISTINCT ContinentCode
FRO Countries
This query will return all DISTINCT (unique, different) values from ContinentCode column from Countries table
Continentcode
oc
eu
Goolkicker-com - SQL Notes for Professionals, 2As.
‘SOLFiddle Demo
Section 6.1
: Select rows from multiple tables
SELECT *
FROM
tabley
table?
SELECT
‘tablet .colunnt
tablet .colunn2,
table?.colunnt
FROM
tablet
table2
This s called cross product in SQL itis same as cross product in sets,
‘These statements return the selected colurnns from multiple tables in one query.
‘There is no specific relationship between the columns returned from each table,
Goolkicker-com - SQL Notes for Professionals,
26Chapter 7: GROUP BY
Results of a SELECT query can be grouped by one or more columns using the GROUP BY staternent: all results with
the same value in the grouped columns are aggregated together. This generates a table of partial results, instead of
‘one result. GROUP BY can be used in conjunction with aggregation functions using the HAVING statement to define
how non-grouped columns are aggregated,
Section 7.1: Basic GROUP BY example
It might be easier if you think of GROUP BY as “for eacl
for the sake of explanation, The query below:
SELECT EnplD, SUM (MonthlySalary)
FROM Employee
GROUP BY EmpID
is saying:
"Give me the surn of MonthlySalary’s for each EmpID"
So if your table looked like this:
|EnpID|MonthtySatary|
Result
11/200]
121300]
‘Sum wouldn't appear to do anything because the sum of one number is that number. On the other hand ifit looked
like this:
|EnpID|MonthtySatary|
[200 I
[2 [300 i
Result
Goolkicker-com - SQL Notes for Professionals, 7]|1]500]
[21300]
Then it would because there are two EmpID 1's to sum together.
Section 7.2: Filter GROUP BY results using a HAVING clause
A HAVING clause filters the results of a GROUP BY expression. Note: The following examples are using the Library
‘example database.
Examples:
Return all authors that wrote more than one book (live example)
SELECT
ald
a. Name.
COUNT(*) BooksWratten
FROM BooksAuthors ba
INNER JOIN Authors @ ON a.id = ba.authorid
GROUP BY
ald
a Name
HAVING COUNT(+) > 1 ~~ equals to HAVING BooksWritten > 1
Return all books that have more than three authors (live example.
SELECT
b.ld
b.Title,
COUNT(*) NunberofAuthors
FROM BooksAuthors ba
INNER JOIN Books b ON b.id ~ ba.bookid
GROUP BY
b.td
b.title
HAVING COUNT(*) > 3. ~~ equals to HAVING NunberOfauthors > 3
Section 7.3: USE GROUP BY to COUNT the number of rows for
each unique entry in a given column
Let's say you want to generate counts or subtotals for a given value in a column,
Given this table, "Westerosians"
Name GreatHousedlllegience
Arya Stark
Cercei_Lannister
Myrcella Lannister
Yara Greyjoy
Catelyn Stark
Goolkicker-com - SQL Notes for Professionals, 28Sansa Stark
Without GROUP BY, COUNT will simply return a tot
number of rows:
SELECT Count(*) Number_of_Mesterosians
FROM Westerosians
returns,
Number_of Westerosians
6
But by adding GROUP BY, we can COUNT the users for each value in a given column, to return the number of
people in a given Great House, say:
SELECT GreatHouseAllegience House, Count(») Number_of_Westerosians
FROM Westerosians
GROUP BY GreatHouseAllegience
returns...
House Number_of Westerosians
Stark 3
Greyjoy 1
Lannister 2
It's common to combine GROUP BY with ORDER BY to sort result
by largest or smallest category:
SELECT GreatHouseAllegience House, Count(*) Number_of_Westerosians
FROM Westerosians
GROUP BY GreatHouseAllegience
ORDER BY Nunber_of Mesterosians Desc
returns,
House Number_of Westerosians
k 3
Lannister 2
Greyjoy 1
Section 7.4: ROLAP aggregation (Data Mining)
Description
The SQL standard provides two additional aggregate operators. These use the polymorphic value “ALL” to denote
the set of all values that an attribute can take. The two operators are:
‘+ with date cube that it provides all possible combinations than the argument attributes of the clause.
‘+ with rol1 up that it provides the aggregates obtained by considering the attributes in order from left to
right compared how they are listed in the argument of the clause.
‘SQL standard versions that support these features; 1999,2003,2006,2008,2011.
Examples
Goolkicker-com - SQL Notes for Professionals, 29Consider this table:
Food Brand Total_amount
Pasta Brandt 100
Pasta Brand2 250
Pizza Brand2 300
With cube
select Food, Brand, Total_anount
fron Table
group by Food, Brand,Total_amount with cube
Food Brand Total_amount
Pasta Brand’ 100
Pasta Brand2 250
Pasta ALL 350
Pizza Brand2 300
Pizza ALL 300
ALL Brandt 100
ALL Brand2 550
ALL ALL 650
With roll up
select Food, Brand, To
from Table
group by Food, Brand,Total_amount with roll up
Food Brand Total_amount
Pasta Brand’ 100
Pasta Brand2 250
Pizza Brand2 300
Pasta ALL 350
Pizza ALL 300
ALL ALL 650
Lanount
Goolkicker-com - SQL Notes for Professionals,
30Chapter 8: ORDER BY
Section 8.1: Sorting by column number (instead of name)
You can use a colurnn’s number (where the leftmost column is 1')to indicate which column to base the sort on,
Instead of describing the column by its name.
Pro: If you think it's likely you might change column names later, doing so won't break this code.
Con: This will generally reduce readability of the query It's instantly clear what ‘ORDER BY Reputation’ means, while
‘ORDER BY 14' requires some counting, probably with a finger on the screen.)
‘This query sorts result by the info in relative column position 3 from select statement instead of column name
Reputation.
SELECT DisplayName, JoinDate, Reputation FROM Users ORDER BY 3
DisplayName JoinDate Reputation
Community 2008-09-15 4
Jerrod Dixon 2008-10-03 11739
Geoff Dalgas 2008-10-03 12567
Joel Spolsky 2008-09-16 25784
Jeff Atwood 2008-09-16 37628
Section 8.2: Use ORDER BY with TOP to return the top x rows
based on a column's value
In this example, we can use GROUP BY not only determined the sort of the rows returned, but also what rows are
returned, since we're using TOP to limit the result set.
Let's say we want to return the top 5 highest reputation users from an unnamed popular Q&A site,
Without ORDER BY
‘This query returns the Top 5 rows ordered by the default, which in this case is "Id", the first column in the table
(even though it’s not a column shown in the results)
SELECT TOP § DisplayName, Reputation
FROM Users.
returns,
DisplayName Reputation
Community 1
Geoff Dalgas 12567
Jerrod Dixon 11739
Jeff Atwood 37628
Joel Spolsky 25784
With ORDER BY
SELECT TOP 5 DisplayName, Reputation
FROM Users.
Goolkicker-com - SQL Notes for Professionals, aORDER BY Reputation dese
returns,
DisplayName Reputation
JonSkeet 865023,
Darin Dimitrov 661741
Balusc 650237
Hans Passant 625870
Mare Gravell 601636
Remarks
‘Some versions of SQL (such as MySQL) use a LIMIT clause at the end of a SELECT, instead of TOP at the beginning,
for example:
SELECT DisplayNane, Reputation
FROM Users:
ORDER BY Reputation
Umit 5
Section 8.3: Customizeed sorting order
To sort this table Employee by department, you would use ORDER BY Department. However, if you want a different
sort order that is not alphabetical, you have t
this can be done with a CASE expression:
Name Department
Hasan IT
Yusuf HR
Hillary HR
Joe IT
Merry HR
Ken Accountant
SELECT *
FROM Employee
ORDER BY CASE Departma
WHEN “HR: THEN 1
WHEN "Accountant" THEN 2
ELSE 3
END:
Name Department
Yusuf HR
Hillary HR.
Merry HR
Ken Accountant
Hasan IT
Joe IT
Section 8.4: Order by Alias
Due to logical query processing order, alias can be used in order by.
map the Department values into different values that sort correctly
Goolkicker-com - SQL Notes for Professionals,
2SELECT DisplayNene, JoinDate as jd, Reputation as rep
FROM Users:
ORDER BY jd, rep
‘And can use relative order of the columns in the select statement .Consider the same example as above and
instead of using alias use the relative order like for display name It is 1 , for jd it is 2 and so on
SELECT DisplayNane, JoinDate as jd, Reputation as rep
FROM Users:
ORDER BY 2, 3
Section 8.5: Sorting by multiple columns
SELECT DisplayName, JoinDate, Reputation FROM Users ORDER BY joinDate, Reputation
DisplayName JoinDate Reputation
Community 2008-09-15 1
Jeff Atwood 2008-09-16 25784
Joel Spolsky 2008-09-16 37628
Jarrod Dixon 2008-10-03 11739
Geoff Dalgas 2008-10-03 12567
Goolkicker-com - SQL Notes for Professionals,
BChapter 9: AND & OR Operators
Section 9.1: AND OR Example
Have a table
Name Age city
Bob 10 Paris
Mat 20 Berlin
Mary 24 Prague
select Name from table where Age>10 AND City="Prague’
Gives
Name
Mary
select Name from table where Age=10 OR City='Prague
Gives
Name
Bob
Mary
Goolkicker-com - SQL Notes for Professionals,Chapter 10: CASE
‘The CASE expression is used to implement if-then logic
Section 10.1: Use CASE to COUNT the number of rows ina
column match a condition
Use Case
‘CASE can be used in conjunction with Sut to return a count of only those items matching a pre-defined condition.
(This is similar to COUNTIF in Excel.)
‘The trick is to return binary results indicating matches, so th
for @ count of the total number of matches.
's returned for matching entries can be summed
Given this table TtenSales, let's say you want to learn the total number of items that have been categorized as
"Expensive"
Id Itemid Price PriceRating
1100 345 EXPENSIVE
2145 2.3 CHEAP
3100 345 EXPENSIVE
4100 345 EXPENSIVE
5145 10 AFFORDABLE
Query
SELECT
COUNT(Ed) AS Ttemscount
SUM (CASE
WHEN PriceRating = ‘Expensive’ THEN 1
ELSE @
END
) AS ExpensiveTtenscount
FROM Ttenales
ItemsCount ExpensiveltemsCount
5 3
Alternative:
SELECT
COUNT(Id) 95 TtemsCount
SUM (
CASE PriceRating
WHEN 'Expensive’ THEN 1
ELSE @
END.
) AS ExpensivertemsCount
FROM ItenSales
Goolkicker-com - SQL Notes for Professionals,Section 10.2: Searched CASE in SELECT (Matches a boolean
expression)
‘The searched CASE returns results when a boolean expression is TRUE.
(This differs from the simple case, which can only check for equivalency with an input.)
SELECT Id, Itemtd, Price.
CASE WHEN Price < 10 THEN “CHEAP
WHEN Price < 24 THEN “AFFORDABLE”
ELSE" EXPENST
END AS PriceRating
FROM TrenSales
Id Itemid Price PriceRating
1100 345 EXPENSIVE
2145 2.3. CHEAP
3.100 345 EXPENSIVE
4100 345 EXPENSIVE
5145 10 AFFORDABLE
Section 10.3: CASE in a clause ORDER BY
We can use 1,2,3.. to determine the type of order:
SELECT = FROM DEPT
ORDER BY
(CASE DEPARTMENT
WHEN "MARKETING’ THEN 1
WHEN 'SALES' THEN 2
WHEN "RESEARCH THEN 9
WHEN “TRNOVATION” THEN 4
ELSE 5
END.
cry
ID REGION cry DEPARTMENT EMPLOYEES NUMBER
12 New England Boston MARKETING 9
15 West San Francisco MARKETING 2
9 Midwest Chicago SALES 8
14 Mid-Atlantic NewYork SALES R
5 West Los Angeles RESEARCH "
10 Mid-Atlantic Philadelphia RESEARCH 13
4 Midwest Chicago INNOVATION "
2 Midwest Detroit HUMAN RESOURCES 9
Section 10.4: Shorthand CASE in SELECT
CCASE's shorthand variant evaluates an expression (usually a column) against a series of values. This variant is a bit
shorter, and saves repeating the evaluated expression over and over again. The ELSE clause can still be used,
though:
SELECT Id, ItemId, Price.
CASE Price WHEN 5 THEN ‘CHEAP’
WHEN 15 THEN “AFFORDABLE”
Goolkicker-com - SQL Notes for Professionals, 36