Relational Algebra - SQL

2015-12-07T19:30:00+05:30

In the age of ORMs so many developers today doesn't know about very fundamental and basic algorithms that runs SQL. Despite being one of easiest and much useful language many people run away from using SQL directly and take shelter in using some 'wrapper' tool which is not always as good as raw SQL.

Let's start by defining very basic relation in SQL.

Database as Collection of relations ( Tables or Schemas )
Being first class predicate - State of database is final state of all relations
By joining, aggregating data from different relations one can filter out data as desired.

Relation

Relation in SQL language is defined by several terms.


Tuple	One Row in SQL Relation
Attribute	Column in Relation
Unknown	`Null` in Domain

Note:- Tuple is represented by (a, b), Attribute(Column) here will have unique domain(name - Relation name) within relation.

Relational Algebra

Relational algebra is superset of set algebra which defines formal language of relations in Database domain.
Each operation done here on relations will return new valid Relation.

This algebra has mainly two groups of operations, One it shares with set theory and other one is specific to Relational model.

	SET operations	Relation specific operations
1	UNION	SELECT
2	INTERSECTION	PROJECT
3	SET DIFFERENCE
4	CARTESIAN PRODUCT \ CROSS PRODUCT

Any operations in Relational algebra can be classified mathematically as binary and unary, this fundamental operators have all the power needed to construct complex queries as needed.
The main operators are:

SELECT ( $\sigma$ ) Can be described as below
$$ \sigma_\psi RO $$

Where:


R	Tupels sets in SQL
$\psi$	Predicate in selection retries from Tuples in R

PROJECT ( $\pi$ ) Operation which returns columnar structure in vertical dimention, If you remember this is slicing by attributes can be described as

$$ \pi _{a1,a2...an} RO $$

$_{a1,a2..an}$ are set of attributes names.

CARTESIAN\CROSS PRODUCT ( $\times$ ) This is binary operation as oppose to unary like previous two, Can be used to generate complex relations by joining each tuple operands together.

$R \times S = {r1, r2...rn,s1,s2...sn}$

UNION ($\cup$) Appends two relations together.

To be successful in this binary operations both relation needs to have same set of attributes.

$$ R \cup S = (_{r1, r2...rn}) \cup (_{s1, s2...sn}) $$

Assuming, $S \, \Sigma \, (_{s1,s2...sn}) \quad and \quad R \, \Sigma \, (_{r1,r2...rn})$

DIFFERENCE ( $\setminus or \, -$ ) A binary operation, as you may have guessed - $\cup$ only but in reverse.
Set difference can be described as

$$ R\setminus S = (_{r1,r2...rn}) \quad where \quad (_{r1,r2...rn}) \, \Sigma\, R \quad but \quad (_{r1,r2...rn}) \, \notin \, S $$

REMAME($\rho$) A unary operation that works on attributes and returns new value of attribute, This is mainly used for JOIN operations to differantiate the attributes, can be expressed as

$$ \rho_{a\setminus b}R$$

With this essential building blocks in place we can now move forward and take a look at more complex queries such as mixing many of these premitives to perform left joins, right-joins etc. In addition to these we can also add few more such as sum, multiplication to these operations on set of tuples or attributes.
These algebric math provides fundamental building block of any SQL algorithm which guarantess ACID standards are followed hence understanding them all the more important.

Improve PostgreSQL CLI

2013-12-07T14:30:00+05:30

When you work in Terminal/Browser workflow for almost 10 hours a day - 5 days a week, It becomes important kind of colors and configs you choose. For me Database has been important part of my workflow when configuring various business logic for applications.

I mainly use PostgreSQL for storing almost everything that has to resambles data, and mostly it will be automated through psycopg2 in python scripts but time to time I do dwell in CMD option that PostgreSQL provides through psql.
Given the configurability of psqlrc and flexibility that is allowed by PostgreSQL server, it's almost surprising that how little people take advantage of these available features. Aliases and setting up proper History files can be useful features that comes in handy.

PostgreSQL stores psqrc at various levels in system.

System wide psqlrc
- Will Affect all users
- Can be located using following

  pg_config --sysconfdir
  /usr/local/etc/postgresql

Note: This is for FreeBSD operating system, location will vary as per your own OS.

Per User psqlrc

 touch ~/.psqlrc

You can also have multiple psqlrc one per major version of PostgreSQL on your system.

if you have more then one version of PostgreSQL installed on your system, then name it accordingly. Ex. For version 9.4 - psqlrc-9.4 or psqlrc-9.4.3. This way It will enable you to have multiple configuration files for each user and per version as well.

Now, Decide on which specific configuration file you want to configure - System wide or User specific and start customizing your psqlrc.

Actual configuration file


-- This is comment.
\set PROMPT1 '%n@%/%R%x%# '
\set PROMPT2 '[more] %R > '
\pset null '[null]'
\set COMP_KEYWORD_CASE upper
\timing
\set PAGER less
\set HISTSIZE 2000
\encoding unicode
\x auto
\pset border 2
\set VERBOSITY verbose
\set version 'SELECT version();'

-- MACRO can be defined like this.
\set extensions 'select * from pg_available_extensions;'
\echo 'Welcome to Dev1 PostgreSQL \n'

Final output

Wrapping up

These are about the main settings that you would want to configure here, Apart from these settings only Aliases as per your convinience should be configured inside your PostgreSQL configuration file so repetation can be avoided. Putting it in version controlled dotfiles git repository and you will be able to sync same setting across all your DB server regardless So, Give custom configs a try!


R	Tupels sets in SQL
\(\psi\)	Predicate in selection retries from Tuples in R