USE db_name: this is used for selecting database

SELECT * FROM tablename where id=9 ORDER BY first_name, last_name: shows the rows ordered by
name

SELECT 2 AS total: shows a table with field total, and a row 2

SELECT last_name FROM table: shows only the lastname column

SELECT DISTINCT name FROM table: shows only distinct names;

!= or <> used for not equality

SELECT * FROM table1 WHERE id<>2;

Date format in sql: ‘yyyy-mm-dd’

AND and OR are used in where

AND is always evaluated before OR

NOT is for reversing the condition: WHERE NOT (id >3)

IN Operator: WHERE id IN (2,5,6)

NOT IN: WHERE id NOT IN (1,3,4)

BETWEEN operator: WHERE id BETWEEN 10 AND 15

LIKE : last_name like ‘b%’; %:any number of character , _:exactly one character

NOT LIKE: obvious

REGEXP: WHERE name REGEXP ‘sa’ == WHERE name LIKE ‘%sa%’ – ‘^sa’ : start with sa – ‘an$’ ends with
an – ‘sa|le’ whether have se or le – ‘^se|la’ whether start with se or have la – ‘[ea]b’ : eb or ab – ‘[a-g]e’
ae ,be ,ce , …

IS NULL, IS NUT NULL : where phone is null;

ORDER BY column , ORDER BY colum DESC

SELECT firstname , last name FROM table ORDER BY 1,2 : orders by firstname and lastname

ORDER BY quantity*unit_price;

LIMIT 6 : shows only 6 rows, LIMIT 5 ,6 : skips 5, shows 6 rows

SELECT * FROM TABLE1 e JOIN TALBE2 f ON TABLE e.id=f.id : SELECT * FROM TABLE1 e JOIN TALBE2 f
USING (id)

ON e.id = f.id AND e.otherid = f.otherid : compound join

SELECT * FROM table1 e,table2 f WHERE e.id = f.id : implicit join

LEFT JOIN : finds the records on left table even if there’s no corespondant data on table2
RIGHT JOIN: same as left join but reversed

SELECT * FROM table1 NATURAL JOIN table2 : database engine will join two table based on common
columns

SELECT * FROM table1 CROSS JOIN table2 : SELECT * FROM table1,table2

SELECT * , ‘active’ as status FROM table1 WHERE date> ‘1990-01-01’ UNION

SELECT * , ‘inactive’ as status FROM table1 WHERE date<= ‘1990-01-01’

INSERT INTO table VALUES(DEFAULT , ‘ehsan’ , ‘abbas nejad’ , NULL)

INSERT INTO table (first_name , last_name) VALUES(‘ehsan’ , ‘abbas nejad)

INSERT INTO table (first_name , last_name) VALUES(‘ehsan’ , ‘abbas nejad),(‘meysam’ , ‘abbasnejad’)

INSERT INTO customers (first_name) values (‘meysam’); INSERT INTO ORDERS (customer_id , item)
VALUES ( LAST_INSERT_ID() , ‘something’)

CREATE TABLE copy AS SELECT * FROM table : create a copy of table

INSERT INTO table SELECT * FROM anothertable WHERE id <100

UPDATE table SET first_name=’hoseyn’ , last_name=’abdollahi’ WHERE first_name=’ehsan’

UPDATE table SET first_name = ‘ali’ WHERE id IN (SELECT id FROM table2 WHERE point>300)

DELETE FROM table WHERE id=32

SELECT SUM(amount) AS sum, AVG(amount) AS average, COUNT(amount) AS count, MIN(amount) AS

minimum, MAX(amount) AS maximum FROM salaries

SELECT COUNT(DISTINCT customer_id) FROM invoices WHERE invoice_date > ‘2020-01-01’

SELECT client_id , SUM(amount) AS total FROM orders GROUP BY client_id WITH ROLLUP :shows the
sums

SELECT * FROM employees WHERE salary > (SELECT AVG(salary) FROM employees) : employees who
earn more than average

SELECT * FROM products WHERE product_id NOT IN (SELECT DISTINCT product_id FROM order_items) :
selects products that have never been ordered

SELECT * FROM invoices WHERE invoice_total > ALL ( SELECT invoice_total FROM invoices WHERE
client_di = 3) : SELECT * FROM invoices WHERE invoice_total > ( SELECT MAX(invoice_total) FROM
invoices WHERE client_di = 3)

= ANY : = SOME : IN

SELECT client_id FROM invoices GOURP BY client_id HAVING COUNT(*) >= 2 : shows only the clients_id
who have more than two invoices
SELECT * FROM employees e WHERE salary > (SELECT AVG(salary) FROM employees WHERE office_id =
e.office_id) : select employees who earn more than average in their office(correlated subquery)

SELECT * FROM clients c WHERE EXISTS ( SELECT client_di FROM invoices WHERE client_id = c.client_id)

SELECT invoice_id, invoice_total ( SELECT AVG(invoice_total) FROM invoices ) AS invoice_Average ,

invoice_total – ( SELECT invoice_average) AS diff FROM invoices

SELECT * FROM ( SELECT invoice_id, invoice_total, ( SELECT AVG(invoice_total) FROM invoices ) AS

invoice_Average , invoice_total – ( SELECT invoice_average) AS diff FROM invoices) AS sales_summary
WHERE diff>200

SELECT ROUND(5.73 , 1) = 5.7 , CEILING(5.8) , FLOOR(5.2) , ABS(-7) , RAND() = between 0 and 1

LENGTH(‘sky’) =3 , LOWER() , UPPER() , LTRIM() : left trim , RTRIM() : right trim , LEFT(‘hello’, 2) = ‘he’ ,
RIGHT() , SUBSTRING(‘mystring’ , 3 , 5) , LOCATE(‘n’ , ‘kindergarden’)=3 , REPLACE(‘kindergarden’ ,
‘garden’ , ‘garten’) , CONCAT(‘first’ , ‘last’)

NOW() : current date and time , CURDATE() : current date , CURTIME() : current time , YEAR(NOW()) :
gets the current year , MONTH , DAY, HOUR , MINUTE , SECOND , DAYNAME , MONTHNAME

EXTRACT(DAY FROM NOW())

DATE_FORMAT(NOW() , ‘%y’ ) : 2 digit year, ‘%Y’ for 4 digit year , ‘%m’ two digit month, ‘%M’ month
name , ‘%d’

TIME_FORMAT(NOW(), ‘%H:%i %p’) : 12:58 PM

DATE_ADD(NOW() , INTERVAL 1 DAY) , DATE_SUB() , DATEDIFF() : difference in days

TIME_TO_SEC(’09:00’) : return seconds passed from midnight

SELECT IFNULL(shipper_id , ‘not assigned’) , COALESCE (shipper_id, another_column , ‘some string’)

IF(expression, firstvalue, secondvalue)

SELECT CASE WHEN expression THEN ‘somevalue’ WHEN …. ELSE ‘default’ END AS ‘columnname’

CREATE VIEW viewname AS SELECT * FROM table WHERE condition, then we can :

SELECT * FROM viewname

DROP VIEW viewname : deletes view

CREATE OR REPLACE VIEW viewname AS SELECT …

if view doesn’t have DISTINCT, agregate functions(SUM, AVG,…), UNTION, we can update data in view

WITH CHECK OPTIONS : checks to see whether after updating a record in table it does not dissapears
DELIMITER $$ CREATE PROCEDURE get_clients() BEGIN SELECT * FROM clients; END$$ DELIMETER ;

CALL get_clients()

DROP PROCEDURE IF EXISTS get_clients : drops the stored procedure

DELIMITER $$ CREATE PROCEDURE get_clients_by_state( pstate CHAR(2)) BEGIN SELECT * FROM clients
WHERE state=pstate; END$$ DELIMETER ;

DELIMITER $$ CREATE PROCEDURE get_clients_by_state( pstate CHAR(2)) BEGIN IF pstate IS NULL pstate
=’CA’; END IF; SELECT * FROM clients WHERE state=pstate; END$$ DELIMETER ;

DELIMITER $$ CREATE PROCEDURE get_clients_by_state( pstate CHAR(2)) BEGIN IF pstate IS NULL

SELECT * FROM clients; ELSE SELECT * FROM clients WHERE state=pstate; END IF; END$$ DELIMETER ;

DELIMITER $$ CREATE PROCEDURE get_clients_by_state( pstate CHAR(2)) BEGIN SELECT * FROM clients
WHERE state = IFNULL(pstate, state); END$$ DELIMETER ;

DELIMITER $$ CREATE PROCEDURE get_clients_by_id(pid INT) BEGIN IF id<=0 SIGNAL SQLSTATE ‘22003’
SET MESSAGE_TEXT = ‘invalid input’END IF … :22003 is the code for invalid data …

DELIMITER $$ CREATE PROCEDURE get_count_avg( dep CHAR(2) , OUT count INT , OUT average INT)
BEGIN SELECT COUNT(*) , AVG(salary) INTO count, average FROM employee WHERE dep=dep; END$$
DELIMETER ;

SET @count =0; SET @average=0; CALL get_count_avg (‘hr’ , @count , @average); SELECT @count ,
@average;

DELIMITER $$ CREATE PROCEDURE get_count () BEGIN DECLARE count INT DEFAULT 0; SELECT count(*)
INTO count FROM employee; SELECT count; END$$ DELIMETER ;

DELIMITER $$ CREATE FUNCTION get_count ( client_id INT) RETURNS INTEGER DETERMINISTIC READS
SQL DATA BEGIN DECLARE count INT DEFAULT 0; SELECT count(*) INTO count FROM employee; RETURN
count; END$$ DELIMETER ;

attributes : DETERMINISTIC , READS SQL DATA, MODIFIES SQL DATA

DELIMITER $$ CREATE TRIGGER payment_after_insert AFTER INSERT ON payments FOR EACH ROW
BEGIN UPDATE invoices SET payment_total = payment_total + NEW.amount WHERE invoice_id =
NEW.invoice_id END $$ DELIMITER ;

AFTER or BEFORE – INSERT or UPDATE or DELETE

SET GLOBAL event_scheduler = ON/OFF :turns on or off

DELIMITER $$ CREATE EVENT yearly_delete_stale_audit_rows ON SCHEDULE ((AT ‘2019-05-01’)) EVERY

1 YEAR STARTS ‘2019-01-01’ ENDS ‘2029-01-01’ DO BEGIN DELETE FROM payments_audit where
Action_date<NOW() – INTERVAL 1 YEAR; END $$ DELIMITER ;

ALTER EVENT eventname DISABLE;

START TRANSACTION;

INSERT INTO orders(customer_id, stat) VALUES (12, ‘ok’) ;

INSERT INTO order_items VALUES ( LAST_INSERT_ID(),1);

COMMIT; /ROLLBACK

SHOW VARIABLES LIKE ‘autocommit’ : show wether automit is on

SHOW VARIABLES LIKE ‘transaction_isolation’;

SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;

SET GLOBAL TRANSACTION ISOLATION LEVEL SERIALIZABLE;

CHAR(x) : fixed length

VARCHAR(x) : max : 65535 characters

MEDIUMTEXT : max : 16mb

LONGTEXT : max : 4gb

TINYTEXT : max : 255 byte

TEXT : max : 64kb

TINYINT 1b

SMALLINT 2b

MEDIUMINT 3b

INT 4b

BIGINT 8b

DECIMAL(p,s) : p : total digits, s : number of digits after

DEC , NUMERIC , FIXED are same as DECIMAL

FLOAT 4b

DOUBLE 8b

BOOL BOOLEAN : implemented as tiny int

ENUM(‘small’,’medium’,large)

SET(‘option1’,’option2’) set is multi select

DATE

TIME

DATETIME 8b

TIMESTAMP 4b

YEAR 4digit

TINYBLOB 255b

BLOB 65kb

MEDIUMBLOB 16mb

LONGBLOB 4gb

JSON

INSERT INTO table JASON_OBJECT(‘key’ , ‘value’ , ‘anotherkey’ . JSON_ARRAY(1,2,3), ‘anotherkeyagain’ ,

JSON_OBJECT(‘innerkey’ , ‘innerval’) )

or

INSERT INTO table ‘ {“key” : “value” , “anotherkey” : [ 1,2,3 ] , “anotherkeyagain” : {“innerkey”:

“innerval”}}’

SELECT JSON_EXTRACT(column_name , ‘$.key’) FROM table

SELECT column_name -> ‘$.key’ FROM table

SELECT column_name -> ‘$.anotherkey[1]’ FROM table

SELECT column_name -> ‘$.anotherkeyagain.innerkey’ FROM table

if we use ->> instead of -> we wont get “” when retrieving strings from json

UPDATE table set column_name = JSON_SET(column_name , ‘$.key’ , ‘anotherval’)

UPDATE table set column_name = JSON_REMOVE(column_name , ‘$.key’ )

DROP TABLE IF EXISTS folan;

CREATE TABLE IF NOT EXISTS …

ALTER TABLE folan ADD last_name VARCHAR(50) NOT NULL AFTER first_name, ADD city VARCHAR(50)
NOT NULL, MODIFY (COLUMN) first_name VARCHAR(55) DEFAULT ‘’, DROP points;

CREATE TABLE orders ( order_id INT PRIMARY KEY, customer_id INT NOT NULL, FOREIGN KEY
fk_orders_customers (customer_id) REFERENCES customer(id) ON UPDATE CASSCADE ON DELETE NO
ACTION)

ALTER TABLE orders DROP PRIMARY KEY, ADD PRIMARY KEY (order_id), DROP FOREIGN KEY
fk_orders_customers, ADD FOREIGN KEY fk_something_id (customer_id) REFERENCES customers
(customer_id);

SHOW CHARSET;

CREATE DATABASE db_name CHARACTER SET larin1;

CREATE TABLE table1 () CHARACTER SET latin1;

ALTER TABLE table1 CHARACTER SET latin1;

ALTER TABLE table1 MODIFY column1 VARCHAR(50) CHARACTER SET latin1;

SHOW ENGINES;

ALTER TABLE customers ENGINE = InnoDB;

EXPLAIN SELECT customer_id FROM customers WHERE state=’ca’ : shows how many rows does db
search

CREATE INDEX idx_state ON customers (state);

DROP INDEX indexname ON table;

SHOW INDEXES IN customers;

ANALYZE TABLE customers; refreshes the data for statistics for table

CREATE INDEX idx_lastname ON customers (last_name(20) ) : indexes the first 20 characters in string
column

CREATE FULLTEXT INDEX idx_title_body ON posts (title, body);

SELECT * , MATCH(title, body) AGAINST(‘react redux’) FROM posts WHERE MATCH(title, body)
AGAINST(‘react redux’); shows also the relevancy level

SELECT * , MATCH(title, body) AGAINST(‘react redux’) FROM posts WHERE MATCH(title, body)
AGAINST(‘react –redux +form’ IN BOOLEAN MODE); must have from and not have redux, use “ for exact
phrase

CREATE INDEX compositeindex ON customers(state,points); order is important(use base on cardinality

and query)

SELECT * FROM customer USE INDEX (indexname) …

Should always isolate columns in queries to use indexes, otherwise indexes will be ignores: WHERE
id+10>200;

SHOW STATUS LIKE ‘last_query_cost’ ; shows the cost of the last query

CREATE USER john@127.0.0.1 IDENTIFIED BY ‘password’;

SELECT * FROM mysql.user; shows the users

DROP USER username@host;

SET PASSWORD FOR john = ‘1234’;

SET PASSWORD = ‘1234’; for current user

GRANT SELECT,INSERT,UPDATE,DELETE,EXECUTE ON dbname.* TO user;

there are lots of privilages;

GRANT ALL ON *.* TO john;

SHOW GRANTS FOR john; shows priviledges for john

REVOKE CREATE VIEW ON db.* FROM user;

todos :

search WITH clause

search why sorting by column1 and column2 desc ignores index with (column1,column2)