SQL Server 2014 introduced DBCC CLONEDATABASE for creating a blank database with only Schema and Statistics.

SQL Server 2016 added support of the Query Store in DBCC CLONEDATABASE.

This feature is very helpful in certain conditions.
For example, Your production database size is around 800 GB, and You faced some performance related issues because the problem of outdated Statistics or Indexes issue.

Now the situation is, you can do a test and trial in your Production Database, so DBA takes a copy of Production Database and restore it in different server for further investigation.

Do you think, this is the only one solution because Its require additional time and infrastructure.

In this kind of situation, you can use the DBCC CLONEDATABASE feature of SQL Server 2014.

It creates a blank database copy with the only Schema, Statistics and Query Store information. It is not copying the data, so it does not require any additional space.

You can find the same statistical information in the new clone database which generates the same execution plan for your investigation.

A Query Execution Plan is prepared to base on Database Statistics so If Database Statistics are same then you check your query execution plan without data.

Once you are finished with your task with Clone Database, you can delete it.

How internally SQL Server creates a Clone Database?

It validates the source database and acquires the shared lock on the source database

It creates a snapshot of the source database (Include only: Schema, Statistics, Query Store)

Create Clone Database and acquires an exclusive lock on it

Copy the metadata, schema, statistics, query store information from the source database to clone database

Release all locks from Clone Database

How to create a Clone Database?

Use DBCC CLONEDATABASE command to create a Clone Database.

DBCC CLONEDATABASE (MyDatabase,MyDatabase_Clone);

In this post, I am sharing a quick way to move your table with data from one schema to another schema of PostgreSQL.

I already shared an article on, how to copy a table from one schema to another schema.

PostgreSQL: Script to copy Table Data from one Schema to another Schema

For moving the table between the schemas is a very simple, you should just update the entry in pg_class and pg_type table.
Something like update the table schema name from old to the new basis on given table name.

Please check the below solution, try it your self:

UPDATE pg_catalog.pg_class
SET relnamespace = (SELECT oid FROM pg_catalog.pg_namespace
                    WHERE nspname = 'destination_schema')
WHERE relnamespace = (SELECT oid FROM pg_catalog.pg_namespace
                      WHERE nspname = 'source_schema')
AND relname = 'table_name';

UPDATE pg_catalog.pg_type
SET typnamespace = (SELECT oid FROM pg_catalog.pg_namespace
                    WHERE nspname = 'destination_schema')
WHERE typnamespace = (SELECT oid FROM pg_catalog.pg_namespace
                      WHERE nspname = 'source_schema')
AND typname = 'table_name';

In this post, I am sharing a few scripts for checking the size of Database, Schema and Table of Greenplum Server.

Here, I am doing this exercise using the views of the gp_toolkit schema of Greenplum.

Check the size of database in MB, GB and TB:

SELECT sodddatname, (sodddatsize/1048576) AS Sizein_MB
FROM gp_toolkit.gp_size_of_database;
 
SELECT sodddatname, (sodddatsize/1073741824) AS Sizein_GB
FROM gp_toolkit.gp_size_of_database;
 
SELECT sodddatname, (sodddatsize/1073741824)/1024 AS Sizein_TB
FROM gp_toolkit.gp_size_of_database;

Checkt the size of database in MB, GB and TB:

SELECT sosdnsp, (sosdschematablesize/1048576) AS Sizein_MB
FROM gp_toolkit.gp_size_of_schema_disk;
 
SELECT sosdnsp, (sosdschematablesize/1073741824) AS Sizein_GB
FROM gp_toolkit.gp_size_of_schema_disk;
 
SELECT sosdnsp, (sosdschematablesize/1073741824)/1024 AS Sizein_TB
FROM gp_toolkit.gp_size_of_schema_disk;

Check the size of any Table or Index:

SELECT pg_size_pretty(pg_total_relation_size('schema_name.table_name'));

Greenplum is a based on MVCC architecture that means user’s action like UPDATE will insert a new record in a database.
Greenplum Data warehouse can manage billions of data, but it doesn’t mean that user can generate or UPDATE random data set.
Periodically, The Greenplum DBA should check the size of database schemas and their appropriate usage.

In this post, I shared different scripts to check the size of Greenplum Database Schemas.

Option 1:

select *
from gp_toolkit.gp_size_of_schema_disk;

Option 2:

select
	schemaname
	,round(sum(pg_total_relation_size(schemaname||'.'||tablename))) SchemaSize
from pg_tables group by 1;

Option 3:

SELECT
	schema_name
	,pg_size_pretty(sum(table_size)::bigint)
FROM
(
	SELECT pg_catalog.pg_namespace.nspname as schema_name,
	pg_relation_size(pg_catalog.pg_class.oid) as table_size
	FROM pg_catalog.pg_class
	JOIN pg_catalog.pg_namespace ON relnamespace = pg_catalog.pg_namespace.oid
) t
GROUP BY schema_name
ORDER BY schema_name;

In this post, I am sharing one script to copy your Schema tables into another Schema of PostgreSQL.
I found this script at wiki.postgresql.org and modified the coding standard for the best use.

In our organization, I am creating a different schema for all the database developers, and at every new schema, we require to migrate development origin schema’s table data into a newly created schema.

I created different database users for each database developer, and they can only access their assigned schema. I am doing this for security reason, and it is also very easy to audit the changes and work progress of all the database developers.

Create a below function and execute to migrate your schema.

Create a function to copy old schema data to new schema:

CREATE OR REPLACE FUNCTION fn_CopySchemaData(source_schema text, dest_schema text) 
RETURNS void AS
$$
 
DECLARE
  object text;
  buffer text;
  default_ text;
  column_ text;
BEGIN

	-- Create a new schema
	EXECUTE 'CREATE SCHEMA ' || dest_schema; 
  
FOR object IN
	SELECT sequence_name::text 
	FROM information_schema.SEQUENCES 
	WHERE sequence_schema = source_schema
LOOP
	EXECUTE 'CREATE SEQUENCE ' || dest_schema || '.' || object;
END LOOP;
 
FOR object IN
	SELECT TABLE_NAME::text 
	FROM information_schema.TABLES 
	WHERE table_schema = source_schema
LOOP
	buffer := dest_schema || '.' || object;
	EXECUTE 'CREATE TABLE ' || buffer || ' (LIKE ' || source_schema || '.' || object || ' INCLUDING CONSTRAINTS INCLUDING INDEXES INCLUDING DEFAULTS)';
 
	FOR column_, default_ IN
		SELECT column_name::text, REPLACE(column_default::text, source_schema, dest_schema) 
		FROM information_schema.COLUMNS 
		WHERE table_schema = dest_schema 
			AND TABLE_NAME = object 
			AND column_default LIKE 'nextval(%' || source_schema || '%::regclass)'
	LOOP
	EXECUTE 'ALTER TABLE ' || buffer || ' ALTER COLUMN ' || column_ || ' SET DEFAULT ' || default_;
	END LOOP;
END LOOP;
 
END;
 
$$ LANGUAGE plpgsql VOLATILE;

Sample Execution:

select *from fn_CopySchemaData('old_schema','new_schema');

In this post, I am sharing one T-SQL script to change the schema name of all the tables in a SQL Server Database.

When you require to alter your database schema name and you have a large number of tables, you can use this kind of script to alter the schema name.

First, you need to create one new schema and you can replace [New_Schema_Name] by your newly created schema name. You can also add a table filter in the cursor main query.

USE [DB_NAME]
GO

DECLARE @TABNAME VARCHAR(255)
DECLARE @SQLCMD VARCHAR(500)
DECLARE CHANGESCHEMA CURSOR

FOR SELECT TABNAME FROM (SELECT '['+B.NAME+'].['+A.NAME+']' TABNAME FROM SYS.TABLES A
	INNER JOIN SYS.SCHEMAS B ON A.SCHEMA_ID= B.SCHEMA_ID) T
OPEN CHANGESCHEMA
FETCH NEXT FROM CHANGESCHEMA INTO @TABNAME
	WHILE @@FETCH_STATUS = 0	
	BEGIN
		SET @SQLCMD= 'ALTER SCHEMA [New_Schema_Name] TRANSFER '+@TABNAME
		PRINT @SQLCMD
	EXEC(@SQLCMD)
FETCH NEXT FROM CHANGESCHEMA INTO @TABNAME
END
CLOSE CHANGESCHEMA
DEALLOCATE CHANGESCHEMA
GO

This title looks like a very basic topic, but this is one of the most important topics for PostgreSQL database professionals.

I have observed that most of the new PostgreSQL users are creating multiple databases into PostgreSQL Server which is not wrong

We all have common practice for creating multiple databases for the different purpose of the project.
But in the PostgreSQL server, we should create multiple schemas instead of multiple databases.

I recommended 1-database many-schemas approach for the PostgreSQL Server because cross database queries is very costly in PostgreSQL.

In the Microsoft SQL Server, we are creating different databases and we can also execute query between multiple databases by specifying a database name.
But this is not possible with the PostgreSQL.

For more details, You can visit this article of cross database queries in PostgreSQL.

The Schemas in PostgreSQL are a lot like packages in Oracle. A number of schemas should be more lightweight than a number of databases.

We require to take a backup of the only single database, including all schemas. We can also add or remove particular schema during the backup or restore operation.

We can also create different database permission groups & roles for each and every different schema so that we can control the access of database user.