In this post, I am sharing the different options to check weather your table exists in your database or not.

For checking the existence of table is a ubiquitous requirement for PostgreSQL Database Developer.
PostgreSQL 9.4 introduced to_regclass to check object presence very efficiently.

You can check other below options as well.

Use to_regclass (From PostgreSQL 9.4): This is the fastest option.

SELECT to_regclass('schema_name.table_name');

Use information_schema.tables:

SELECT EXISTS 
(
	SELECT 1
	FROM information_schema.tables 
	WHERE table_schema = 'schema_name'
	AND table_name = 'table_name'
);

Use catalogs tables:

SELECT EXISTS 
(
	SELECT 1 
	FROM pg_catalog.pg_class c
	JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
	WHERE n.nspname = 'schema_name'
	AND c.relname = 'table_name'
	AND c.relkind = 'r' -- r = tables 
);

Use pg_tables catalog:

SELECT EXISTS 
(
	SELECT 1 
	FROM pg_tables
	WHERE schemaname = 'schema_name'
	AND tablename = 'table_name'
);

PostgreSQL 9.4 introduced WITH ORDINALITY for generating a sequence number for each element which are produced by UNNEST().

When we are talking about the string array, internal element numbering is also important for further operation.

I have prepared a small demonstration of this, you can access here.

Create a table with sample data:

CREATE TABLE tbl_TextArray(key varchar(100), tags text[]);

INSERT INTO tbl_TextArray(key, tags)
VALUES 
('first', '{aa,fe,gr,fh}'::text[]),
('sec', '{tr,we,et,ui,er}'::text[]),
('third', '{we,gh,fv,dc,sx}'::text[]);

UNNEST() WITH ORDINALITY:

SELECT key, ArrayOrder, tag
FROM tbl_TextArray, unnest(tags) 
WITH ORDINALITY As T (tag, ArrayOrder);

The Result:

dbrnd=# SELECT key, ArrayOrder, tag
dbrnd-# FROM tbl_TextArray, unnest(tags)
dbrnd-# WITH ORDINALITY As T (tag, ArrayOrder);
  key  | arrayorder | tag
-------+------------+-----
 first |          1 | aa
 first |          2 | fe
 first |          3 | gr
 first |          4 | fh
 sec   |          1 | tr
 sec   |          2 | we
 sec   |          3 | et
 sec   |          4 | ui
 sec   |          5 | er
 third |          1 | we
 third |          2 | gh
 third |          3 | fv
 third |          4 | dc
 third |          5 | sx
(14 rows)

I have already written a couple of articles about the PostgreSQL JSON Data type and its different type of operations.

PostgreSQL 9.4: The JSON data type is Awesome (Part 1/3)

PostgreSQL: How to convert Table Data into JSON formatted Data?

In this post, I am going to share one more demonstration about PostgreSQL JSON.

In our system, I have stored communication message information in the form of JSON. This JSON column contains lots of different types of elements.
Now one of module required to fetch this JSON array elements into a form of STRING Array only. (Something like comma separated).

We have different type of JSON functions and operator so I have achieved this solution using jsonb_array_elements.

Below is a full demonstration of this:

Create one table with sample data:

CREATE TABLE tbl_TestJsonArray
(
	ID INT
	,JsonData JSONB
);

INSERT INTO tbl_TestJsonArray
VALUES (1,'{"Name": ["Anvesh","Roy","Jenny","Neevan"]}');

SQL Query to convert JSON elements into String Array:

SELECT 
	ID
	,(
		SELECT string_agg(trim(JsonString::text, '"'), ', ')
		FROM jsonb_array_elements(JsonData->'Name') JsonString
	) AS StringArray
FROM   tbl_TestJsonArray;

id  |       StringArray
----------------------------------
   1   | Anvesh, Roy, Jenny, Neevan

PostgreSQL 9.4 has introduced one of the very good FILTER CLAUSE which is used to apply filters in aggregate functions.

Using FILTER, You can use different types of aggregate functions without applying any GROUP BY CLAUSE.

Now Imagine, that I have one Student table and I want total number of Students based different grades.
What happened without FILTER CLAUSE, We have to perform this calculation in the individual SELECT query.

But with the use of FILTER CLAUSE we can perform aggregation based on different FILTER values in a single SQL Query.

Below is a small demonstration of this:

Create one Student table with sample data:

CREATE TABLE tbl_Students
(
	StudID INT PRIMARY KEY
	,StudentName CHARACTER VARYING
	,Marks INTEGER
);

INSERT INTO tbl_Students 
VALUES (1,'Anvesh',88),(2,'Jenny',55),(3,'Tushar',85)
,(4,'Kavita',75),(5,'Manas',42),(6,'Martin',69)
,(7,'Roy',95),(8,'Benny',92),(9,'Neevan',82)
,(10,'Lee',43),(11,'Loother',65),(12,'Eric',58);

Apply FILTER clause to count number of Students based on Marks:

SELECT 
	COUNT(1) AS TotalStudents 
	,COUNT(1) FILTER (WHERE Marks BETWEEN 40 AND 60) AS TotalGrade_C
	,COUNT(1) FILTER (WHERE Marks BETWEEN 60 AND 80) AS TotalGrade_B
	,COUNT(1) FILTER (WHERE Marks BETWEEN 80 AND 100) AS TotalGrade_A	
FROM tbl_Students;

/* Result:
-------------- --------------- --------------- ---------------
TotalStudents |  TotalGrade_C |  TotalGrade_B |  TotalGrade_A
--------------|---------------|---------------|---------------
      12      |       4       |       3       |       5
-------------- --------------- --------------- ---------------
 */

PostgreSQL is a powerful, open source object-relational database system. It has more than 15 years of active development and a proven architecture that has earned it a strong reputation for reliability, data integrity, and correctness.

I am going to share few steps on how to install PostgreSQL 9.4 on Ubuntu 14.04.

First, check the version of Ubuntu:

lsb_release -sc

You need to add the latest PostgreSQL repository for the latest version, otherwise It will install PostgreSQL 9.3. This is for trusty version.

sudo add-apt-repository "deb https://apt.postgresql.org/pub/repos/apt/ trusty-pgdg main"

Update and Install PostgreSQL 9.4:

sudo apt-get update
sudo apt-get install postgresql-9.4

Default postgres super user and postgres database is created. You need to set a password for the postgres super user.

ubuntu@:~$ sudo passwd postgres
Enter new UNIX password:****
Retype new UNIX password:****
passwd: password updated successfully

If service is not started, you can start the PostgreSQL service.

sudo service postgresql start

Connect PostgreSQL server using postgres user:

ubuntu@:~$ su postgres
Password:****

Create a sample database:

createdb database_name

Connect to that database:

psql -d database_name

Create a sample table:

create table Test (rno integer);

Exit to database session:

\q

Exit to PostgreSQL server:

exit

Recently, PostgreSQL introduced JSON data type which is very powerful to manipulate JSON formatted data.

I published a couple of articles on JSON Data Type.
You can start from here.

In this post, I am showing aggregation of table data into a JSON formatted array using json_agg().

Our requirement is to aggregate non json formatted data into JSON array and even also required to aggregate JSON formatted data.

I prepared a small demonstration using json_agg().

Create a table with sample JSON formatted data:

CREATE TABLE tbl_TestJSON
(
	ID INTEGER PRIMARY KEY
	,DepartName VARCHAR(250)
	,EmployeeDetails JSONB
);

INSERT INTO tbl_TestJSON
VALUES 
(
	1
	,'Sales'
	,'
	{"employees":[
	    {"firstName":"Anvesh", "lastName":"Patel"}	  
	]}'
)
,(
	2
	,'Production'
	,'
	{"employees":[	    
	    {"firstName":"Nancy", "lastName":"Shah"}
	]}'
);

Aggregates JSON formatted data:

SELECT json_agg(employeedetails) AS JsonArray FROM tbl_TestJSON;

JsonArray
------------------------
[{"employees": [{"lastName": "Patel", "firstName": "Anvesh"}]}, {"employees": [{"lastName": "Shah", "firstName": "Nancy"}]}]

Aggregates non JSON formatted data:

SELECT json_agg(DepartName) AS JsonArray FROM tbl_TestJSON;

JsonArray
------------------------
["Sales", "Production"]

In the previous two parts, I shared basic about JSON data types, operators and functions of PostgreSQL 9.4.

In this post, I am showing to create a GIN INDEX on the jsonb data type of PostgreSQL 9.4.

If we are thinking to store large JSON document in PostgreSQL, we should also apply proper indexing on it.
The GIN indexing is very useful to search key and value pairs from the large jsonb documents.
The GIN index supports queries with this all @>, ?, ?& and ? different operators.

Below is a small demonstration on GIN index:
First, create a sample table with jsonb data type and JSON data:

CREATE TABLE tbl_TestJSONData
(
	ID INTEGER PRIMARY KEY
	,DepartName VARCHAR(250)
	,EmployeeDetails JSONB
);

INSERT INTO tbl_TestJSONData
VALUES 
(
	1
	,'Sales'
	,'	
	{
		"firstName":"Anvesh"
		,"lastName":"Patel"
		,"gender":"Male"
		,"address":"Hyederabad"
		,"age":28
		,"role":
		[
			"admin"
			,"vendor"
		]
	}	    
	'
)
,(
	2
	,'Production'
	,'	
	{
		"firstName":"Neevan"
		,"lastName":"Patel"
		,"gender":"Male"
		,"address":"Hyederabad"
		,"age":20
		,"role":
		[
			"user"
			,"production"
		]
	}	    
	'
);

Create a GIN index on jsonb column:

CREATE INDEX idx_tbl_TestJSONData_EmployeeDetails 
ON tbl_TestJSONData USING GIN (EmployeeDetails);

The SELECT query which makes use of this created index:

SELECT 
	EmployeeDetails -> 'firstName'
	,EmployeeDetails -> 'lastName'
	,EmployeeDetails -> 'gender'
FROM tbl_TestJSONData
WHERE EmployeeDetails @> '{"age":28}'

Create expression indexes for particular internal items and keys:

CREATE INDEX idx_tbl_TestJSONData_EmployeeDetails_Roles 
ON tbl_TestJSONData USING GIN ((EmployeeDetails -> 'role'));

To SELECT internal ‘role’ key which uses the index:

SELECT 
	EmployeeDetails -> 'firstName'
	,EmployeeDetails -> 'lastName'
	,EmployeeDetails -> 'gender'
FROM tbl_TestJSONData
WHERE EmployeeDetails -> 'role' ? 'admin';

In the previous post, I discussed newly introduced JSON data type of PostgreSQL 9.4.

In this post, I am showing some of the basic JSON functions and operators which are also introduced by PostgreSQL 9.4.

Create sample table with jsonb data type and insert sample JSON data:

CREATE TABLE tbl_TestJSONData
(
	ID INTEGER PRIMARY KEY
	,DepartName VARCHAR(250)
	,EmployeeDetails JSONB
);

INSERT INTO tbl_TestJSONData
VALUES 
(
	1
	,'Sales'
	,'	
	{
		"firstName":"Anvesh"
		,"lastName":"Patel"
		,"gender":"Male"
		,"address":"Hyederabad"
		,"age":28
		,"role":
		[
			"admin"
			,"vendor"
		]
	}	    
	'
)
,(
	2
	,'Production'
	,'	
	{
		"firstName":"Neevan"
		,"lastName":"Patel"
		,"gender":"Male"
		,"address":"Hyederabad"
		,"age":20
		,"role":
		[
			"user"
			,"production"
		]
	}	    
	'
);

SELECT JSON Data using ‘->’ and ‘->>’ operators:

SELECT EmployeeDetails->'firstName' AS FirstName 
FROM tbl_TestJSONData;

/* Result as a JSON object. (Using ->)
firstname
----------
"Anvesh"
"Neevan"
*/

SELECT EmployeeDetails->>'firstName' AS FirstName 
FROM tbl_TestJSONData;

/* Result as a TEXT. (Using ->>)
firstname
----------
Anvesh
Neevan
*/

JSON Key value criteria in WHERE clause:

SELECT *FROM tbl_TestJSONData 
WHERE EmployeeDetails @> '{"age":28}'; 

/* one sales record is returned. */

JSON_EACH and JSONB_EACH Functions:
JSON_EACH and JSONB_EACH function to expand a JSONs data and nested JSONs are not expanded.
JSON_EACH for json data type and JSONB_EACH for jsonb data type.

SELECT jsonb_each(EmployeeDetails) AS JSONData FROM tbl_TestJSONData;

/*Result:

JSONData 
---------------
"(age,28)"
"(role,"[""admin"", ""vendor""]")"
"(gender,"""Male""")"
"(address,"""Hyederabad""")"
"(lastName,"""Patel""")"
"(firstName,"""Anvesh""")"
"(age,20)"
"(role,"[""user"", ""production""]")"
"(gender,"""Male""")"
"(address,"""Hyederabad""")"
"(lastName,"""Patel""")"
"(firstName,"""Neevan""")"

*/

JSON_OBJECT_KEYS and JSONB_OBJECT_KEYS Functions:
Returns all set of keys of JSON object and nested keys are not displayed.
JSON_OBJECT_KEYS is for json data type and JSONB_OBJECT_KEYS is for jsonb data type.

SELECT jsonb_object_keys(EmployeeDetails) AS JSONKeys
FROM tbl_TestJSONData;

/*Result:
age
role
gender
address
lastName
firstName
age
role
gender
address
lastName
firstName

*/

JSON_TYPEOF and JSONB_TYPEOF Functions:
This both functions respectively, for each data type and return the data type of the JSON keys.

SELECT jsonb_typeof(EmployeeDetails->'firstName') AS JSONKeyDataType
FROM tbl_TestJSONData;

JSON is one of the interesting topics or new RDBMSs, now with the new version of PostgreSQL 9.4, we can store JSON formatted data.

You can visit this article, on the overview of PostgreSQL 9.4 features.

Now We can say, we have PostgreSQL 9.4 with the RDBMS + NOSQL concepts.

We can also store JSON data as text, but the JSON Data types have the advantage of enforcing each stored for validing JSON rules or formats.

PostgreSQL 9.4 also introduced some set of JSON specific functions and operators.

Two type of SON data types:

json: It stores an exact copy of the input json text, while processing functions it reparses for each execution. Our insertion process may faster by using this json data type.
The JSON data type also preserves a white space between tokens and order of the keys because it stores an exact copy of json input text.

jsonb:
It stores the JSON formatted data in a decomposed binary format so input slightly slower because of the conversion overhead.
(While inserting, it is validating the correct format of JSON. If JSON format is invalid, you cannot insert it.)

The jsonb data type does not preserve white space and order of object keys.
Automatically, it also removes a duplicate key from the input string and keep last value only.

If we do not have any problem with ordering of object key, we should use jsonb data type to store JSON formatted data.

Below is a small practical demonstration of this:

First, create sample table with jsonb data type:

CREATE TABLE tbl_TestJSON
(
	ID INTEGER PRIMARY KEY
	,DepartName VARCHAR(250)
	,EmployeeDetails JSONB
);

Insert correct JSON formatted data:
Please also test and try to insert some incorrect JSON formatted data, you will get an error like: invalid input syntax for type json.

INSERT INTO tbl_TestJSON
VALUES 
(
	1
	,'Sales'
	,'
	{"employees":[
	    {"firstName":"Anvesh", "lastName":"Patel"},
	    {"firstName":"Eric", "lastName":"Marin"},
	    {"firstName":"Martin", "lastName":"Loother"}
	]}'
)
,(
	2
	,'Production'
	,'
	{"employees":[
	    {"firstName":"Neevan", "lastName":"Patel"},
	    {"firstName":"Roy", "lastName":"Boon"},
	    {"firstName":"Nancy", "lastName":"Shah"}
	]}'
);

SELECT data by searching the key value using WHERE clause:

SELECT * FROM tbl_TestJSON 
WHERE EmployeeDetails @> '{"employees":[{"lastName":"Loother"}]}'

The Result: Returned only one record.

In this post, I am sharing a short note on the new feature of PostgreSQL 9.4.

PostgreSQL 9.4 has one of the best features that I have liked it JSON data type.

PostgreSQL 9.4 New Features:

• JSONB Binary JSON Storage Data Type: You don’t require to take a decision between RDBMS and NOSQL because you can have now both at the same time.
• Replication Slots: The information is available to the primary server, when the standby server is offline or disconnected.
• Changeset Streaming/Logical decoding:
  It supplies a new API for filtering, reading and manipulating the replication stream.
• GIN indexes now faster and smaller:
  pg_prewarm: This is also one of the good parameters. When you restart your PostgreSQL Server, the shared buffer is empty again. But using this parameter you can take backup of buffer as well.
• ALTER SYSTEM: you can change your system setting using this ALTER SYSTEM and don’t require to edit postgresql.conf.
• REFRESH MATERIALIZED VIEW CONCURRENTLY.
• Improvement in Updatable view.
• WITH ORDINALITY: A column containing an ordered sequence of numbers is added.
• Added some new aggregate features.

Reference taken from this URL: