Comparison of commands between Apache Hive, Amazon RedShift

Below is the comparison of SQL commands between Apache Hive and Amazon RedShift.

Create a database sqlcompare:

Hive: Create database/schema [if not exists] sqlcompare;

RedShift: Create database sqlcompare [with owner <ownername>];

Drop the database sqlcompare:

Hive: Drop database/schema [if exists] sqlcompare [cascade];

RedShift: Drop database sqlcompare;

Command to rename column name salary to sal in table employee :

Hive: Alter table employee change salary sal number;
RedShift: Alter table employee rename salary to sal;

Adding a column mgr to a table employee:

Hive: Alter table employee add columns (mgr int);
RedShift: Alter table employee add column mgr int;

Dropping a column mgr from table employee:

Hive: Dropping a column is not directly supported by Hive. We can use replace columns to get the desired result. To drop mgr column from employee table, below replace command includes all columns except mgr.

Alter table employee replace columns (empId Int, empName string, dept string, salary int);

RedShift: Alter table employee drop column mgr;

Renaming a table employee to emp;

Hive: Alter table employee rename to emp;

RedShift: Alter table employee rename to emp;

Inserting a row into table employees:

Hive: Insert into employee values(1,'John','Finance',25000);

RedShift: Insert into employee values(1,'John','Finance',25000);

Insert into new table from parent table:

Hive: Insert into employee_bkp select * from employee;
RedShift: Insert into employee_bkp (select * from employee);

Create table Like:

Hive: Create table emp_bkp like employee;
RedShift: Create table emp_bkp ( like employee);

Get Current schema:

Hive: set hive.cli.print.current.db = true;
Redshift: select current_schema();

Order the result set:

Hive: Hive orders result set in different ways. ORDER BY orders the result set across all reducers. SORT BY orders the result set in each reducer. DISTRIBUTE BY partitions the data and then data is sorted by SORT BY column in each partition. CLUSTER BY partitions the data and orders the result set in ascending order on same column.

select * from employee order by empname;

select * from employee sort by empname;

select * from employee distribute by empname sort by empname;

select * from employee cluster by empname;

Redshift: select * from employee order by empname;

NULL values sort first in ASC mode and last in DESC mode both in Redshift and Hive.

Referencing columns by positional notation:

Hive: To use positional notation for Hive 0.11.0 through 2.1.x,  set hive.groupby.orderby.position.alias to true. From Hive 2.2.0 and later, hive.orderby.position.alias  is true by default.

select * from employee order by 2 desc;

RedShift: select * from employee order by 2 desc;

Column aliases in where clause:

Hive: Column name aliases cant be referenced in where clause.
RedShift: Column name aliases can be referenced in where clause.
select deptid as dept, avg(salary) avg_sal from employee where dept in (2,4,5);

IN Clause sub-query:

Hive: In Hive, IN-clause is implemented using LEFT SEMI JOIN. In left semi join, columns from left side (employee) of the join can only be referenced in select clause of sql command.

select e.* from employee e left semi join departments d where e.dept_no = d.dept_no;

Redshift: select e.* from employee e where e.dept_no in (select d.dept_no from departments d);

Amazon RedShift: Key highlights on "Temporary Tables" and "Derived Tables'

Important points to remember about Temporary Tables are

• Temporary tables are visible only within the current session. They are automatically dropped at the end of the session.
• If we begin the table name with #, it will automatically creates a temporary table.
• Operations on temporary tables
• create table #employee_temp ...  
• This sql automatically creates employee_temp as temporary table due to # at the front of the table name.
• insert into #employee_temp select * from employee; 
• # is required at the front of the temporary table name while inserting.
• create temp table employee_temp like employee;
• This command creates a temporary table employee_temp. It inherits its columns, Distkey ,sortkey and NOT NULL from employee table.
• create temp table employee_temp as select * from employee;
• This command creates a temporary table employee_temp. The temporary table only inherits the column names.
• create temp table employee_temp as select firstname,lastname from employee;
• Creates temporary table employee_temp that has firstname and lastname from employee.
• create temp table emp_temp distkey(emp_id) as select * from employee;
• create temp table emp_temp diststyle even as select * from employee;
• create temp table emp_temp diststyle even sortkey(emp_name) as select * from employee;
• A derived table lasts the life of a query but temporary table lasts the life of a session.
• A temporary table can have the same name as permanent table,but not recommended.
• All Users by default has temporary table creation privilege. To remove, revoke TEMP privilege from PUBLIC and grant TEMP privilege to specific user/group.
• Deep Copy:
• Deep copy operation recreates and repopulates the table using bulk insert  and also automatically sorts the table.
• If a table has large unsorted region, deep copy is a preferred method compared to vacuum to sort the table.
• 4 Methods to perform deep copy:
• Use original DDL command - CREATE TABLE command. We can specify all PK, FK, distkey, sortkey in DDL command.
• CREATE TABLE LIKE - The new table doesn't inherit PK and FK. It only inherits distkey, sortkey and not null attributes from parent table.
• CTAS - The new table will not inherit PK, FK, not null, distkey, sortkey from parent table.
• Create temporary table - If we need to retain all the attributes of the original table, then we have to create temporary table using CTAS command. Then, truncate parent table and then insert into parent table from temporary table.
• During deep copy operation concurrent updates are not allowed whereas its allowed during vacuum.
• v_generate_tbl_ddl script is used to generate the table DDL. 
• Derived Tables:
• Exists only within query.
• Analogous to subquery concept in RDBMS world.
• Derived table lives in memory.
• Derived table must be given name.
• All columns must be given name in the derived table. 
• Derived table is materialized by a select statement inside the query and exists between open and closed parenthesis.
• Different ways to define derived tables:
• select * from (select dept,avg(salary) from employee) as salavg(dept, avgsal);
• salavg is the name given to derived table. dept, avgsal are aliases defined externally to dept, avg(salary) columns.
• select * from (select dept,avg(salary) avgsal from employee) as salavg;
• Salavg is the name given to derived table. dept column is not aliased because it can default to normal column and avgsal alias is defined within the derived table query.
• WITH salavg(avgsal) as (select avg(salary) from employee) select * from salavg;
• Using with command we create derived table with column alias before running the main query.
• WITH emp as (select * from employee) select * from emp;
• Derived table emp selects all rows and columns from main table employee. 
• The following query creates two derived tables using WITH command and then performs a join.

                              WITH emp(deptid,avgsal) as (select deptid, avg(sal) from employee) ,
                                      dept as (select deptid,deptname from department)
                              select emp.deptid, dept.deptname, avgsal from emp inner join dept
                              on emp.deptid = dept.deptid;          

• The derived table is built first while executing a query.

Check my post on Key highlights on Explain.

Amazon RedShift: Key highlights on "Compression"

This post highlights important points on Compression in Redshift.

• Compression is at column-level in Redshift.
• By default, Amazon Redshift stores data in raw and uncompressed format.
• Types of compression supported by Redshift are

• Byte Dictionary encoding stores a dictionary of unique values for each block of column values. Due to 1MB disk block size, dictionary can hold upto 256 unique values in a single block. Any more distinct values above 256 are stored in raw, uncompressed form. This encoding is effective when distinct values are less than 256.
• Delta encoding is useful mostly for date and time columns. This encoding compress data by storing the difference between values that follow each other in the column. DELTA records difference as 1 byte values, DELTA 32k records difference as 2-byte values.
• LZO encoding works best with character strings. LZO provides high compression ratio, so compression is little slower but supports extremely fast decompression.
• Mostly encoding is useful when the declared data type for a column has large capacity than the majority of values actually stored. 
• Run Length encoding is useful when a column has consecutively repetitive data values. This encoding replaces the consecutively repetitive value in a column with a token that contains the value and number of consecutive occurrences.
• Text255 and Text32k encodings are useful for compressing VARCHAR columns only.  A separate dictionary is created with unique words in the column value and an index value is associated with each unique word. 
• Analyze Compression Commands performs compression analysis and makes suggestions. To implement suggestions, we should recreate table.
• analyze compression : Analyzes all the tables in current DB 
• analyze compression table : analyzes the table specified. More than one table cant be specified in this command.
• analyze compression table_name column_name : analyzes the column specified. More than one column can be specified.
• analyze compression comprows : This is the number of rows <numrows> to be used as the sample size for compression analysis.
• analyze compression comprows numrows: numrows is the number of rows to be used as the compression sample size.
• Analyze compression acquires table lock.
• Analyze compression doesn't consider Run Length encoding for SortKey columns.

Check my next blog on "Key highlights on Temporary Tables and Derived Tables".

Amazon RedShift: Key highlights on "System Tables"

This post has key points on System Tables used in Redshift.

• Redshift has following system tables
• STL (System Table Logging) - These system tables are generated from log files. Logging tables has STL prefix.
• STV (System Table Virtual) -  These virtual system tables has snapshots of the current system data. These virtual tables has STV as prefix.
• System Views - Subset of data found in STL and STV tables is available in the system views, SVL (System View Logging) and SVV (System View Virtual) respectively. 
• System Catalog tables - These tables store schema metadata, such as information on tables and columns. These tables have PG prefix.
• For system tables to return a table metadata, the schema of the table should be added to the search_path. Below command adds sql_class database to search_path. Once it is done, we can retrieve any table metadata in sql_class database.
• set search_path to '$user','public','sql_class';
• All system tables exists in pg_catalog database in Redshift.
• Some of the Redshift system tables:
• pg_table_def: Contains table information like columns, datatypes etc.
• pg_aggregate 
• svv_diskusage : Is used to find the data distribution skew in each table like number of rows stored in each slice for a given table.
• svl_statementtext : Checks all statements that used the analyze command.
• stv_blocklist : Is used to find how many 1MB blocks of disk space are used for each table
• stl_load_commits: we can check the details of the COPY operation.
• stl_query: Can find out when a table has been last analyzed
• stv_table_perm: Has table Id's.
• svl_qlog: Contains elapsed time of queries
• svl_query_summary: We can determine if query is writing to disk. If is_diskenabled field is ("t") for any step, then that step wrote data to disk.

View my next post on Key Highlights on Compression.

Amazon RedShift: Key highlights on "Introduction" and "Best Practices For Designing a Table"

Amazon Redshift is a MPP (massive parallel processing) peta-byte scale data warehouse service hosted on Amazon Web Services. Here I have provided some key highlights or important points to remember about Amazon RedShift. To refresh your knowledge on Amazon Redshift the below provided information is wealth.

This post contains highlights on Amazon RedShift Introduction and Best Practices For Designing a Table.

• Amazon Redshift is a columnar database.
• Tables can be distributed as
• Distribution on unique key
• Distribution on non-unique key 
• Distribution Style is ALL
• Distribution Style is EVEN
• Matching Distribution Keys for co-location of Joins
• Big table/Small table joins
• Defining a Sort Key helps in performance improvement. Data is stored on disk in sorted order.
• Columns that are good candidates to be defined as sort key are
• Timestamp or date columns on which we frequently access the recent data 
• Columns on which we perform range or equality filtering 
• Columns frequently used for order by, group by or window functions
• The joining column, on which two tables can be joined 
• Columns that are good candidates to be defined as distributed key:
• To distribute data evenly among the nodes and slices in a cluster
• To collocate data for joins and aggregations
• When two tables are frequently joined on a join column, specify that join column as both sort key and distribution key.
• RedShift stores columnar data in 1MB disk blocks.
• Each block comes with metadata. The min and max values of keys for each block are stored as part of metadata. This helps range or equality queries to quickly identify the block which matches the filter condition.

• Analyze command collects statistics
• Analyze; -> analyzes all tables in current database
• Analyze verboze; -> Analyzes all tables in current database and report progress
• analyze table -> analyzes the table specified
• analyze table(col1, col2) -> analyzes the columns col1 and col2 in table
• Redshift automatically analyzes some tables created with the following commands.
• Create table as
• create temp table as
• select into 
• Vacuum:
• Redshift doesn't automatically reclaim or reuse space that is freed by delete and update operations. These rows are logically deleted but not physically. Vacuum will reclaim the space.
• Redshift during update operation marks the old row as delete and inserts a new row. So every update is a delete followed by insert. The sort order might be disturbed by updates.
• When delete operation is performed, the row is marked for delete but not removed until Vacuum.
• Vacuum operation is time consuming, so its preferred to run it during maintenance window.
• Vacuum commands:
• vacuum;  -> reclaims space of all tables in current database
• vacuum table -> reclaims space of specified table.
• vacuum sort only table -> resorts rows for table
• vacuum delete only table -> claims space from deletes and updates for table 
• Best Practices for designing tables
• Choose the best sort key
• Choose the great distribution key
• Consider defining primary key and foreign key constraints
• Use the smallest possible column size
• Use date/time data types for date columns
• Specify redundant predicates on the sort column
• Primary key, foreign key, unique key constraints are not enforced by Redshift. They are for informational purpose and is used by query planner to generate a better query plan.
• RedShift does enforce NOT NULL constraints.
• Redshift stores Date and Timestamp data more efficiently than other datatypes.
• While performing joins, specify redundant predicates so unwanted blocks are skipped.

To continue, go to my next post on System Tables.