Review SQL syntax and concepts, including CRUD operations, data types, and relational database design.

SELECT: used to retrieve data from a database.
Example: SELECT * FROM customers;
INSERT: used to insert new data into a database.
Example: INSERT INTO customers (name, address, city) VALUES ('John Doe', '123 Main St', 'New York');

UPDATE: used to modify existing data in a database.
Example: UPDATE customers SET city = 'Los Angeles' WHERE name = 'John Doe';

DELETE: used to delete data from a database.
Example: DELETE FROM customers WHERE name = 'John Doe';

CREATE: used to create a new database object, such as a table, index, or view.
Example: CREATE TABLE customers (id INT PRIMARY KEY, name VARCHAR(50), address VARCHAR(100), city VARCHAR(50));

ALTER: used to modify an existing database object.
Example: ALTER TABLE customers ADD email VARCHAR(100);

DROP: used to delete a database object.
Example: DROP TABLE customers;

INDEX: used to create an index on a table.
Example: CREATE INDEX idx_customers_name ON customers (name);

JOIN: used to combine data from two or more tables based on a common column.
Example: SELECT * FROM customers JOIN orders ON customers.id = orders.customer_id;

GROUP BY: used to group data based on one or more columns.
Example: SELECT city, SUM(total) FROM orders GROUP BY city;

DISTINCT: used to return only unique values in the result set.
Example: SELECT DISTINCT city FROM customers;

WHERE: used to filter data based on certain conditions.
Example: SELECT * FROM customers WHERE city = 'New York';

LIKE: used to match values based on a pattern.
Example: SELECT * FROM customers WHERE name LIKE 'John%';

INNER JOIN: used to return only matching rows from both tables.
Example: SELECT * FROM customers INNER JOIN orders ON customers.id = orders.customer_id;

LEFT JOIN: used to return all rows from the left table and matching rows from the right table.
Example: SELECT * FROM customers LEFT JOIN orders ON customers.id = orders.customer_id;

RIGHT JOIN: used to return all rows from the right table and matching rows from the left table.
Example: SELECT * FROM customers RIGHT JOIN orders ON customers.id = orders.customer_id;

FULL OUTER JOIN: used to return all rows from both tables, with NULL values for non-matching rows.
Example: SELECT * FROM customers FULL OUTER JOIN orders ON customers.id = orders.customer_id;

COUNT: used to count the number of rows in a result set.
Example: SELECT COUNT(*) FROM customers;

SUM: used to return the sum of values in a column.
Example: SELECT SUM(total) FROM orders;

AVG: used to return the average of values in a column.
Example: SELECT AVG(total) FROM orders;
MIN: used to return the minimum value in a column.
Example: SELECT MIN(price) FROM products;

MAX: used to return the maximum value in a column.
Example: SELECT MAX(price) FROM products;

GROUP BY: used to group data based on one or more columns.
Example: SELECT city, SUM(total) FROM customers GROUP BY city;

HAVING: used to filter groups based on conditions.
Example: SELECT city, SUM(total) FROM customers GROUP BY city HAVING SUM(total) > 10000;

UNION: used to combine the result sets of two or more SELECT statements.
Example: SELECT city FROM customers UNION SELECT city FROM suppliers;

INTERSECT: used to return only the matching rows from two or more SELECT statements.
Example: SELECT city FROM customers INTERSECT SELECT city FROM suppliers;

EXCEPT: used to return the unique rows from the first SELECT statement that are not in the second SELECT statement.
Example: SELECT city FROM customers EXCEPT SELECT city FROM suppliers;

UPDATE: used to modify data in a table.
Example: UPDATE customers SET city = 'London' WHERE id = 1;

DELETE: used to delete data from a table.
Example: DELETE FROM customers WHERE city = 'London';

DROP: used to delete a table or other database object.
Example: DROP TABLE customers;
Subqueries: used to return data from one query based on the result of another query.
Example: SELECT * FROM orders WHERE customer_id = (SELECT id FROM customers WHERE name = 'John Doe');

Joins: used to combine rows from two or more tables based on a related column.
Example: SELECT customers.name, orders.total FROM customers JOIN orders ON customers.id = orders.customer_id;

Inner Join: returns only the matching rows from both tables.
Example: SELECT customers.name, orders.total FROM customers INNER JOIN orders ON customers.id = orders.customer_id;

Left Join: returns all rows from the left table (table 1), 
and the matching rows from the right table (table 2). 
The result will have NULL values for non-matching rows from the right side.
Example: SELECT customers.name, orders.total FROM customers LEFT JOIN orders ON customers.id = orders.customer_id;

Right Join: returns all rows from the right table (table 2), and the matching rows from the left table (table 1). 
The result will have NULL values for non-matching rows from the left side.
Example: SELECT customers.name, orders.total FROM customers RIGHT JOIN orders ON customers.id = orders.customer_id;

Full Outer Join: returns all rows from both tables, and includes NULL values for non-matching rows.
Example: SELECT customers.name, orders.total FROM customers FULL OUTER JOIN orders ON customers.id = orders.customer_id;

Indexes: used to improve the performance of SELECT statements. An index allows the database to quickly 
locate the rows that match a WHERE clause.
Example: CREATE INDEX idx_customers_name ON customers (name);

Transactions: used to ensure that a series of SQL statements are executed as a single unit of work. 
Transactions allow you to roll back changes in case of an error, or commit changes to the database if everything goes smoothly.
Example: BEGIN TRANSACTION; UPDATE customers SET city = 'London' WHERE id = 1; COMMIT;

Views: used to store a SELECT statement as a virtual table. Views can be used to simplify complex queries or to restrict 
access to specific columns in a table.
Example: CREATE VIEW vw_customer_orders AS SELECT customers.name, orders.total FROM customers JOIN orders ON 
customers.id = orders.customer_id;

Stored Procedures: used to store a series of SQL statements in the database. 
Stored procedures can be used to encapsulate complex logic 
and to improve performance by reducing the amount of data that needs to be transmitted between the client and the server.
Example: CREATE PROCEDURE sp_update_customer (@id int, @city varchar(50)) AS BEGIN UPDATE customers SET city = @city 
WHERE id = @id; END;