This document discusses transactions in PostgreSQL. It explains that transactions allow grouping SQL commands together as an atomic operation. Transactions are meant to have ACID properties - Atomicity, Consistency, Isolation, and Durability. It provides examples of using transactions with keywords like BEGIN, COMMIT, ROLLBACK, and SAVEPOINT. Deadlocks can occur when two transactions attempt to modify the same row at the same time. The document also covers system columns, altering tables and columns, logical and comparison operators, and mathematical functions in PostgreSQL.

1. Rapid POSTGRESQL
learning, PART-5
BY: ALI MASUDIANPOUR MASUD.AMP@GMAIL.COM
RAPID POSTGRESQL LEARNING. 1

2. Transactions
◦ Transactions are a group of SQL commands
◦ These commands will be group together as an operation
◦ Transactions are supposed to be ACID, but what does that mean?
◦ ACID: Atomicity, Consistency, Isolation, Durability
◦ ATOMICITY
◦ All or nothing
◦ All of the operations must be succeed or all fails. In other word if one command fails other will fail too
◦ CONSYSTENCY
◦ Means that any transaction should take the system from one consistency o another
◦ In other words, only valid changes to the data will take a place
◦ ISOLATION
◦ Any pear of transactions should not be effecting the same row at once
◦ DURABILITY
◦ Once the transaction is committed, its result will not be lost forever
RAPID POSTGRESQL LEARNING. 2

3. Transactions
◦ Working with transactions (KEYWORDS)
◦ To begin transaction:
◦ BEGIN
◦ To end transaction
◦ COMMIT
◦ To cancel transaction
◦ ROLLBACK
◦ Example
◦ BEGIN;
SELECT * FROM [table name]
COMMIT;
◦ Control Transactions
◦ It is possible to control the commit in transactions using SAVEPOINT
RAPID POSTGRESQL LEARNING. 3

4. Save points
◦ Save points allow us to commit part of transaction and discard other parts
◦ How to use SAVE POINT:
◦ BEGIN
UPDATE x SET y=20 WHERE 1
SAVEPOINT [save point name]
UPDATE z SET a=14 WHERE 1
SOLLBACK TO SAVEPOINT [save point name]
COMMIT;
◦ Everything before save point will be committed and everything after save point will be discarded
◦ Destroy SAVE POINT
◦ To destroy a save point we use RELEASE
◦ RELEASE SAVEPOINT [save point name]
◦ After deletion of save point if we try to ROLLBACK TO SAVEPOINT [save point name] it will show an error!
RAPID POSTGRESQL LEARNING. 4

5. DEADLOCKS
◦ A deadlock happens when two or more transactions hold locks at other transactions at once
◦ As we saw before, same operations on same rows in transaction can not be happen
◦ If we do, it will be wait until first transaction done.
◦ DEADLOCK
◦ For instance: if we start a transaction one[1] and after that start the transaction two[2] and in transaction two[2] we write a
command that will be wait for transaction one[1] to be done and after that we do the same in transaction one[1] deadlock will be
happen.
◦ At this moment we have to ROLLBACK
◦ If we try to COMMIT, it will automatically ROLLBACK
RAPID POSTGRESQL LEARNING. 5

6. System Columns
◦ Columns that are added to the table automatically called System Columns
◦ List of System Columns
◦ XMIN
◦ Transaction id of the inserting transaction for this row version. It also can be update
◦ ROW VERSION
◦ Is an individual state of a row. Every time we update the row, new row version will be generated
◦ XMAX
◦ Transaction id of deletion row
◦ CTID
◦ Physical location of the row version in the table
◦ OIDS
◦ Table object id
◦ If we want to use OIDS, we should indicate in on the table creation time
◦ CREATE TABLE … WITH OIDS;
◦ Examples:
◦ SELECT oid, tableoid, xmax, xmin FROM [table name]
RAPID POSTGRESQL LEARNING. 6

7. Alternation in tables and columns
◦ Change data type of column
◦ ALTER [table name] ALTER COLUMN [column name] TYPE [new type]
◦ Change default value of column
◦ ALTER TABLE [table name] ALTER COLUMN [column name] SET DEFAULT [value];
◦ Unset default value
◦ ALTER TABLE [table name] ALTER COLUMN [column name] SET DEFAULT NULL
◦ ALTER TABLE [table name] ALTER COLUMN [column name] DROP DEFAULT
◦ Add Column
◦ ALTER TABLE [table name] ADD COLUMN [column name] [column type]
◦ ALTER TABLE [table name] ADD COLUMN [column name] [column type] NOT NULL DEFAULT [value]
◦ Remove Column
◦ ALTER TABLE [table name] DROP COLUMN [column name]
◦ Every data and constraints will be deleted
◦ If it has a reference column, we must use CASCADE to remove
RAPID POSTGRESQL LEARNING. 7

8. Alternation in tables and columns
◦ Add Constraint
◦ CHECK
◦ ALTER TABLE [table name] ADD CONSTRAINT [constraint name] CHECK([condition])
◦ UNIQUE
◦ ALTER TABLE [table name] ADD CONSTRAINT [constraint name] UNIQUE ([column name])
◦ FOREIGN KEY
◦ ALTER TABLE [table name] ADD FOREIGN KEY [foreign key name] REFERENCES [reference table name]([reference table column
name])
◦ NOT NULL
◦ ALTER TABLE [table name] ALTER COLUMN [column name] SET NOT NULL
◦ All of the values must satisfy constraints to be done
◦ For instance we have a column that holds null value, now if we set null constraint it will generate an error, because it has a null
value.
RAPID POSTGRESQL LEARNING. 8

9. Alternation in tables and columns
◦ Remove Constraint
◦ ALTER TABLE [table name] DROP CONSTRAINT [constraint name]
◦ If it uses a reference we should use CASCADE
◦ Remove Not Null Constraint
◦ ALTER TABLE [table name] ALTER COLUMN [column name] DROP NOT NULL
◦ Rename Column name
◦ ALTER TABLE [table name] RENAME COLUMN [column name] TO [new column name]
◦ Rename Table name
◦ ALTER TABLE [table name] RENAME TO [new table name]
RAPID POSTGRESQL LEARNING. 9

10. Logical Operators
◦ 3 types of Logical operators
◦ AND
◦ Will be true if both left and right operands are true
◦ OR
◦ Will be true if one of the operands is true, otherwise it will be false
◦ NOT
◦ Will be false if the operand is true and will be true if the operand is false
◦ AND / OR has 2 right and left operand
◦ NOT has one operand
◦ Examples:
◦ SELECT * FROM tableTest WHERE x>12 AND y<10
◦ SELECT * FROM tableTest WHERE x>12 OR y<10
◦ SELECT * FROM tableTest WHERE NOT x>12
RAPID POSTGRESQL LEARNING. 10

11. Comparison Operands
◦ They are
◦ <
◦ <=
◦ >
◦ >=
◦ =
◦ !
◦ Examples
◦ SELECT * FROM testable WHERE column1!=3600
◦ SELECT * FROM testable WHERE column1=3600
◦ SELECT * FROM testable WHERE column1>=3600
◦ SELECT * FROM testable WHERE column1<=3600
◦ SELECT * FROM testable WHERE column1>3600
◦ SELECT * FROM testable WHERE column1<3600
RAPID POSTGRESQL LEARNING. 11

12. Between
◦ Between
◦ To run a condition between a range
◦ Example:
◦ SELECT * FROM employee WHERE salary BETWEEN 2000 AND 9000
◦ The less value should be take place in left side of AND operator
◦ SYMETRIC BETWEEN
◦ In this case there would be no force to left operand be greater than right operand
◦ Example
◦ SELECT * FROM employee WHERE salary BETWEEN SYMETRIC 9000 AND 2000
◦ NOT BETWEEN
◦ SELECT * FROM employee WHERE salary NOT BETWEEN 5000 AND 6000
RAPID POSTGRESQL LEARNING. 12

13. IS NULL/ IS NOT NULL
◦ SELECT * FROM employee WHERE salary IS NULL
◦ SELECT * FROM employee WHERE salary IS NOT NULL
◦ SELECT * FROM employee WHERE (salary>3000) IS TRUE
◦ SELECT * FROM employee WHERE (salary>3000) IS NOT TRUE
◦ SELECT * FROM employee WHERE (salary>3000) IS FALSE
◦ SELECT * FROM employee WHERE (salary>3000) IS NOT FALSE
◦ SELECT * FROM employee WHERE (salary>3000) IS UNKNOWN
◦ SELECT * FROM employee WHERE (salary>3000) IS NOT UNKNOWN
RAPID POSTGRESQL LEARNING. 13

14. Mathematical Operators
◦ Addition
◦ SELECT 7+3
◦ Subtraction
◦ SELECT 7-3
◦ Multiplication
◦ SELECT 7*3
◦ Division
◦ SELECT 7/3
◦ Modulo
◦ SELECT 7%3
◦ Exponentiation
◦ SELECT 7^3
◦ Square Root
◦ SELECT |/4
◦ Cube root
◦ SELECT ||/8
◦ Factorial
◦ SELECT 7! AD ‘Factorial’
RAPID POSTGRESQL LEARNING. 14

15. Mathematical Functions
◦ Natural Logarithm
◦ SELECT ln(4)
◦ Base 10 logarithm
◦ SELECT log(8)
◦ PI Constant
◦ SELECT pi() AS ‘PI’
◦ Power
◦ SELECT power(2,3)
◦ Round
◦ SELECT round(2.888888)
◦ Truncate
◦ SELECT TRUNC(2.567,2) // truncate to 2 decimal points. Result : 2.56
◦ SELECT TRUNC(2.567) // result: 2
RAPID POSTGRESQL LEARNING. 15

16. Mathematical Functions
◦ Floor
◦ Largest integer not greater than entered value
◦ SELECT FLOOR(4.5)
◦ Result: 4
◦ CEIL
◦ Smallest integer not less that entered value
◦ SELECT CEIL(4.5)
◦ Result: 5
◦ Absolute value
◦ SELECT abs(-4.88)
◦ Division
◦ SELECT DIV(4,7)
◦ Modulo
◦ SELECT MOD(4,5)
◦ Square root
◦ SELECT SQRT(25)
◦ Cube Root
◦ SELECT CBRT(45)
RAPID POSTGRESQL LEARNING. 16

17. END OF PART 4
End of Part 4
◦ In part 5 we will discuss about:
◦ STRING FUNCTIONS AND OPERATIONS
◦ DATE AND TIME
◦ SEQUENCES
◦ CONDITIONAL EXPRESSIONS
◦ SCHEMA and PRIVILEGES
◦ INDEXES
RAPID POSTGRESQL LEARNING. 17