SQL queries in Derby
last modified July 6, 2020
In this chapter we work with the SQL understood by the Derby database engine. It is a quick list of the most important SQL statements present inDerby.
SQL (Structured Query Language) is a database computer language designed for managing data in relational database management systems. Derby supports only a limited set of SQL statements. Some important statements known from other database systems are missing. Derby implements an SQL-92 core subset, as well as some SQL-99 features.
Dropping tables
The DROP TABLE statement removes a table from the database.
ij> DROP TABLE AUTHORS; 0 rows inserted/updated/deleted ij> DROP TABLE BOOKS; 0 rows inserted/updated/deleted
Supposing that we have previously created the AUTHORS and BOOKS tables,
we are going to drop them and create again. The DROP TABLE SQL statement drops the
table from the database. Note that the DROP TABLE IF EXISTS statement
does not exist in Derby.
Creating tables
The CREATE TABLE statement creates a new table.
ij> CREATE TABLE AUTHORS(ID BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY > (START WITH 1, INCREMENT BY 1), NAME VARCHAR(25)); 0 rows inserted/updated/deleted
We create an AUTHORS with two columns: ID and NAME.
In the ID column we will place big integers, in the NAME column
strings with up to 25 characters.
A PRIMARY KEY uniquely identifies each record in the table. Each author is
a unique personality. Even if there are authors with the same name, each of them is
in a separate row in the AUTHORS table. Only one column in a table can
have this constraint.
The GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1) creates
and identity column. Identity column is a column that stores numbers that increment
by one with each insertion. Identity columns are sometimes called autoincrement columns.
ij> CREATE TABLE BOOKS(ID BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY > (START WITH 1, INCREMENT BY 1), AUTHOR_ID BIGINT, TITLE VARCHAR(150), > FOREIGN KEY(AUTHOR_ID) REFERENCES AUTHORS(ID)); 0 rows inserted/updated/deleted
We create a BOOKS table with three columns. The FOREIGN KEY
specifies that the values in the AUTHOR_ID column must match the values in
the ID column of the AUTHORS table. Foreign keys provide a way
to enforce the referential integrity of a database. Each book was written by one or
more authors. So in the BOOKS table for the AUTHOR_ID column we
can have only values that are present in the AUTHORS table.
Inserting rows
The INSERT statement is used to create one or more rows in the database
table.
ij> INSERT INTO AUTHORS(NAME) VALUES('Jack London');
ij> INSERT INTO AUTHORS(NAME) VALUES('Honore de Balzac');
ij> INSERT INTO AUTHORS(NAME) VALUES('Lion Feuchtwanger');
ij> INSERT INTO AUTHORS(NAME) VALUES('Emile Zola');
ij> INSERT INTO AUTHORS(NAME) VALUES('Truman Capote');
We add five rows to the AUTHORS table using the
INSERT INTO SQL statement.
ij> INSERT INTO BOOKS(AUTHOR_ID, TITLE) VALUES(1, 'Call of the Wild'); ij> INSERT INTO BOOKS(AUTHOR_ID, TITLE) VALUES(1, 'Martin Eden'); ij> INSERT INTO BOOKS(AUTHOR_ID, TITLE) VALUES(2, 'Old Goriot'); ij> INSERT INTO BOOKS(AUTHOR_ID, TITLE) VALUES(2, 'Cousin Bette'); ij> INSERT INTO BOOKS(AUTHOR_ID, TITLE) VALUES(3, 'Jew Suess'); ij> INSERT INTO BOOKS(AUTHOR_ID, TITLE) VALUES(4, 'Nana'); ij> INSERT INTO BOOKS(AUTHOR_ID, TITLE) VALUES(4, 'The Belly of Paris'); ij> INSERT INTO BOOKS(AUTHOR_ID, TITLE) VALUES(5, 'In Cold blood'); ij> INSERT INTO BOOKS(AUTHOR_ID, TITLE) VALUES(5, 'Breakfast at Tiffany');
We insert eight rows into the BOOKS table.
ij> SELECT NAME, TITLE FROM AUTHORS, BOOKS > WHERE AUTHORS.ID = BOOKS.AUTHOR_ID; NAME |TITLE ------------------------------------------------- Jack London |Call of the Wild Jack London |Martin Eden Honore de Balzac |Old Goriot Honore de Balzac |Cousin Bette Lion Feuchtwanger |Jew Suess Emile Zola |Nana Emile Zola |The Belly of Paris Truman Capote |In Cold blood Truman Capote |Breakfast at Tiffany 9 rows selected
The above SQL query joins the two tables. It assigns each book title to an author.
Queries
Queries are used to look up data from the database tables. The SELECT
statement is the main statement to perform queries.
Limiting data output
Limiting data output is essential since many databases have thousands
even millions of rows. Derby does not support the LIMIT clause known from
other databases. Derby 10.7 introduced FETCH and OFFSET clauses
that do the same thing.
ij> SELECT * FROM BOOKS FETCH FIRST 4 ROWS ONLY; ID |AUTHOR_ID |TITLE ------------------------------------------------- 1 |1 |Call of the Wild 2 |1 |Martin Eden 3 |2 |Old Goriot 4 |2 |Cousin Bette
In the first example, we have fetched only the first 4 rows from the
BOOKS table.
ij> SELECT * FROM BOOKS OFFSET 4 ROWS; ID |AUTHOR_ID |TITLE ----------------------------------------------- 5 |3 |Jew Suess 6 |4 |Nana 7 |4 |The Belly of Paris 8 |5 |In Cold blood 9 |5 |Breakfast at Tiffany
With the OFFSET cluase, we skip the first four rows and display the rest.
ij> SELECT * FROM BOOKS OFFSET 4 ROWS FETCH NEXT 3 ROWS ONLY; ID |AUTHOR_ID |TITLE ----------------------------------------------------------------- 5 |3 |Jew Suess 6 |4 |Nana 7 |4 |The Belly of Paris 3 rows selected
We can select a portion of the rows using the combination of OFFSET
and FETCH clauses.
Selecting specific rows with the WHERE clause
The WHERE clause can be used to filter the results. It provides a selection criteria to select only specific rows from the data.
ij> SELECT * FROM CARS WHERE PRICE > 40000; ID |NAME |PRICE ------------------------------------------------------ 1 |Audi |52642 2 |Mercedes |57127 5 |Bentley |350000 7 |Hummer |41400 4 rows selected
With the WHERE clause we only select the cars which have
a price higher than 40000.
ij> SELECT NAME FROM CARS WHERE NAME LIKE '%en'; NAME ------------------------------ Citroen Volkswagen 2 rows selected
With a LIKE clause we select specific car names that fit the
search pattern. In our case it is cars that end in 'en' characters.
ij> SELECT * FROM CARS WHERE ID IN (2, 5, 7); ID |NAME |PRICE ------------------------------------------------------ 2 |Mercedes |57127 5 |Bentley |350000 7 |Hummer |41400 3 rows selected
The IN clause can be used to select rows from a specific range of values.
The above SQL statement returns rows that have IDs equal to 2, 5, and 7.
ij> SELECT * FROM CARS WHERE PRICE BETWEEN 20000 AND 50000; ID |NAME |PRICE ------------------------------------------------------ 4 |Volvo |29000 6 |Citroen |21000 7 |Hummer |41400 8 |Volkswagen |21600 4 rows selected
We select cars that cost in the range 20000 and 50000. For this
we use the BETWEEN AND keywords following the
WHERE clause.
Ordering data
Ordering data can be done with the ORDER BY clause.
ij> SELECT * FROM CARS ORDER BY PRICE; ID |NAME |PRICE ------------------------------------------------------ 3 |Skoda |9000 6 |Citroen |21000 8 |Volkswagen |21600 4 |Volvo |29000 7 |Hummer |41400 1 |Audi |52642 2 |Mercedes |57127 5 |Bentley |350000 8 rows selected
We order the cars by price. The default order type is ascending order.
ij> SELECT * FROM CARS ORDER BY PRICE DESC; ID |NAME |PRICE ------------------------------------------------------ 5 |Bentley |350000 2 |Mercedes |57127 1 |Audi |52642 7 |Hummer |41400 4 |Volvo |29000 8 |Volkswagen |21600 6 |Citroen |21000 3 |Skoda |9000
To order data in descending order, we add the DESC keyword.
Derby functions
Derby supports a few useful functions. These built-in functions are expressions in which an SQL keyword or special operator executes some operation.
Aggregate functions
Aggregate functions evaluate an expression over a set of rows. Whereas the other built-in functions operate on a single expression, aggregates operate on a set of values and reduce them to a single scalar value. Built-in aggregates can calculate the minimum, maximum, sum, count, and average of an expression over a set of values as well as count rows.
ij> SELECT COUNT(ID) FROM AUTHORS; 1 ----------- 5
The COUNT is an aggregate function that counts the number of
rows accessed in an expression. There are five authors in the AUTHORS table.
ij> SELECT MIN(PRICE) AS "PRICE", MAX(PRICE) AS "MAX", > AVG(PRICE) AS "AVG", SUM(PRICE) AS "SUM" FROM CARS; PRICE |MAX |AVG |SUM ----------------------------------------------- 9000 |350000 |72721 |581769 1 row selected
In the above query we use other four functions: MAX, MIN,
AVG, and SUM. The AS clause gives a
label for a column.
Date and time functions
Date and time functions work with date and time
ij> VALUES CURRENT_DATE; 1 ---------- 2017-03-15 ij> VALUES CURRENT SCHEMA; 1 -------------------------- USER12
The VALUES CURRENT_DATE returns the current date.
ij> VALUES CURRENT_TIME; 1 -------- 17:22:49
The VALUES CURRENT_TIME returns the current time.
ij> VALUES CURRENT_TIMESTAMP; 1 ----------------------------- 2017-03-15 17:29:49.987
The VALUES CURRENT_TIMESTAMP returns the current timestamp,
i.e., the current date and time as one value.
String functions
Derby contains functions that work with strings.
ij> VALUES LENGTH('Wonderful day');
1
-----------
13
1 row selected
The LENGTH function returns the number of characters
in a string.
ij> VALUES UPPER('derby');
1
-----
DERBY
1 row selected
ij> VALUES LOWER('Derby');
1
-----
derby
1 row selected
The UPPER function converts characters to upper case and
LOWER to lower case.
ij> VALUES SUBSTR('blueberries', 5);
1
-----------
berries
The SUBSTR returns the part of a string. The first parameter
is the string and the second is the starting position. The first position's
index is 1.
ij> VALUES SUBSTR('blueberries', 1, 4);
1
----
blue
The third parameter is optional; it provides the length of the substring to be returned.
Math functions
Derby contains a few math functions.
ij> VALUES ABS(-4); 1 ----------- 4
ABS returns the absolute value of a numeric expression.
ij> VALUES CEIL(3.4), CEIL(3.8); 1 ------------------------ 4.0 4.0
The CEIL functions rounds the specified number up.
ij> VALUES FLOOR(3.4), FLOOR(3.8); 1 ------------------------ 3.0 3.0
The FLOOR functions rounds the specified number down.
ij> VALUES COS(0.6), SIN(0.6); 1 ------------------------ 0.8253356149096783 0.5646424733950354
The COS and SIN are trigonometric cos and sin
functions.
ij> VALUES RADIANS(180), DEGREES(3.141592653589793); 1 ------------------------ 3.141592653589793 180.0
The RADIANS function converts degrees to radians and the
DEGREES function converts radians to degrees.
ij> VALUES SQRT(16.0); 1 ------------------------ 4.0
The SQRT function returns the square root
of a floating point number.
Updating and deleting data
Now we will concern ourselves with updating and deleting data in
the CARS table.
ij> UPDATE CARS SET PRICE=58000 WHERE ID=2; 1 row inserted/updated/deleted
The UPDATE statement is used to modify data in a database table.
The PRICE of a Mercedes car is set to 58000.
ij> SELECT * FROM CARS WHERE ID=2; ID |NAME |PRICE ------------------------------------------------------ 2 |Mercedes |58000 1 row selected
The subsequent SELECT statement confirms the modification of the data.
ij> CREATE TABLE CARS2(ID BIGINT NOT NULL PRIMARY KEY GENERATED ALWAYS AS IDENTITY > (START WITH 1, INCREMENT BY 1), NAME VARCHAR(30), PRICE INT);
For the next case, we create a new CARS2 table.
ij> INSERT INTO CARS2(NAME, PRICE) SELECT NAME, PRICE FROM CARS; 8 rows inserted/updated/deleted
We insert all the rows from the CARS table into the
CARS2 table, thus copying all data.
ij> SELECT * FROM CARS2; ID |NAME |PRICE ------------------------------------------------------ 1 |Audi |52642 2 |Mercedes |58000 3 |Skoda |9000 4 |Volvo |29000 5 |Bentley |350000 6 |Citroen |21000 7 |Hummer |41400 8 |Volkswagen |21600 8 rows selected
We check the CARS2 table and see that all data was copying OK.
ij> DELETE FROM CARS2 WHERE ID=8; 1 row inserted/updated/deleted
We used the DELETE FROM statement to delete a rown in the table.
ij> DELETE FROM CARS2; 7 rows inserted/updated/deleted
The DELETE FROM statement without the WHERE clause
deletes all rows in the table.
ij> DROP TABLE CARS2; 0 rows inserted/updated/deleted
The DROP TABLE statement deletes the table completly
from the database.
RENAME statements
The RENAME statement belongs to the data definition
language of the SQL.
ij> RENAME TABLE CARS TO MYCARS;
The RENAME TABLE statement allows us to rename an existing table. We
rename a FRIENDS table to MYFRIENDS.
ij> RENAME COLUMN MYCARS.ID TO CID;
The RENAME COLUMN statement renames a particular table column.
In the chapter, we have worked with the basics of the SQL language in Derby.
