SNOWFLAKE:

CLOUD BASED DATA WAREHOUSE

WE WILL STORE THE DATA
PROCESS THE DATA
ANALYSE THE DATA

DATA WAREHOUSE: OLAP (ONLINE ANALYTICAL PROCESS) -- BOTH HISTORICAL DATA &
CURRENT DATA -- TO TAKE APPROPRIATE DECISION--

SAAS MODEL --(SOFTWARE AS A SERVICE) --

DIFFERENT ARCHITECTURE

STRUCTURED AND SEMI-STRUCTURED DATA

ETL & ELT PROCESS

PRE- REQUSITES:

SQL

COMMANDS, SET OPERATORS, JOINS, WINDOWS FUNCTIONS & AGGREGATE FUNCTIONS

SNOWFLAKE CONCEPTS:

TABLE TYPES, TIME - TRAVEL, CLONNING, DATA SHAR, DATA SECURITY,

1. WHAT WE ARE LEARNING?

2. WHERE WE ARE USING
3. WHY WE ARE USING

FOR DATA MIGRATIONS -- MOVING DATA FROM ONCE SOURCE TO TARGET

ON-PREM TO CLOUD

ON-PREM -- MORE MAN MANUAL INTERVENTIONS --

2 ROLES:

SNOWFLAKE DEVELOPER
SNOWFLAKE DATA ENGINEER

1.5 YRS TO 15 YRS EXP--

------------------------------------------------------
SQL --STRUCTURED QUERY LANGUAGE

USED TO COMMUNICATE WITH DATABASES

SQL EITHER IN UPPER CASE OR LOWER CASE

DATA BASE:
 ORGANISED COLLECTION OF DATA

DBMS -- DATABASE MANAGEMENT SYSTEM

SQL:

SQL COMMANDS --
SQL LOGICAL OPERATORS
SWT OPERATORS
JOINS
SUB QUERIES
AGGREGATE FUNCTIONS
WINDOWS/ANALYTICAL FUNCTIONS
CTEs --COMMON TABLE EXPRESSIONS
CASE & DECODE STATEMENTS

----------------------------------------------
DAY 1:
---------------------------------------------

SQL:

DATA WAREHOUSE : A CENTRALISED REPORISITORY TO STORE DATA -- OLAP

DATABASE : IS A PLACE WHERE STORE DATA IN THE FORM OF TABLES AS ROWS & COLUMNS
-- OLTP

SQL : AS COMMUNICATION BETWEEN A DATABASE AND A USER

SQL COMMANDS:

5 TYPES OF COMMANDS:

DDL -- DATA DEFINITION LANGUAGE

DML -- DATA MANIPULATION LANGUAGE
DQL -- DATA QUERY LANGUAGE
DCL --DATA CONTROL LANGUAGE
TCL -- TRANSACTIONAL CONTROL LANGUAGE

DDL -- DATA DEFINITION LANGUAGE:

CREATE, ALTER, DROP, TRUNCATE

SYNTAX:

CREATE TABLE TBNM (COLNM1 DATATYPES, COLNM2 DATATYPE, COL3

DATATYPE......COLN DATATYPES)

DATA TYPES:

NUMBER --INTEGER
ALPHABETS -- STRING/VARCHAR
DECIMEL -- FLOAT
BOOLEAN(TRUE/FALSE)

CREATE TABLE EMP (EMP_ID INT, EMP_NAME VARCHAR);

CREATE DATABASE DB_SF; --DDL COMMAND

CREATE TABLE EMP (EMP_ID INT, EMP_NAME VARCHAR);

create or replace TABLE DB_SF.PUBLIC.EMP (

EMP_ID NUMBER(38,0),
EMP_NAME VARCHAR(16777216)
);

CREATE TABLE NUM (ID INTEGER); --DDL COMMANDS

ALTER TABLE NUM ADD COLUMN NAME VARCHAR(25) ; --DDL COMMAND

SELECT * FROM NUM; -- DQL COMMAND

DROP TABLE NUM; --

DROP DATABASE DB_SF;

USE DATABASE DB_SF;

create or replace TABLE DB_SF.PUBLIC.EMP (

EMP_ID NUMBER(38,0),
EMP_NAME VARCHAR(16777216)
);

SELECT * FROM DB_SF.PUBLIC.EMP; --5 ROWS

--DATA MANIPULATION STATEMENTS

--INSERT, DELETE, UPDATE

INSERT INTO DB_SF.PUBLIC.EMP VALUES (1,'ANIL'),(2,'SANTHOSH'); -- DML STMT

INSERT INTO DB_SF.PUBLIC.EMP VALUES (3,'PRASAD'),(4,'MANJU'),(5,'ANEESHA');

DELETE FROM DB_SF.PUBLIC.EMP WHERE EMP_ID = 5;

UPDATE DB_SF.PUBLIC.EMP SET EMP_NAME = 'VEERA' WHERE EMP_ID = 3;

TRUNCATE TABLE DB_SF.PUBLIC.EMP;

--DIFFERENECE BETWEEN DROP, DELETE & TRUNCATE

-- DROP -- IT WILL REMPOVE TABLE COMPLETELY WITH DATA & STRUCTURE TOO
-- DELETE -- IT WILL REMOVE RECORD/ROWS BASED UPON CONDITION
--TRUNCATE -- IT WILL REMOVE DATA BUT STRUCTURE REMAINS SAME

--DQL -- DATA QUERY LANGUAGE -- SELECT USED TO RETIREVE/FETCH THE DATA FROM TABLES

--DCL -- DATA CONTROL LANGUAGE

--RBAC --ROLE BASED ACCESS CONTROL

--GRANT -- WE WILL BE GIVING PERMISSIONS
--REVOKE -- REMOVING ALL THE GRANTED PREVILIGES

--TRANSACTIONAL CONTROL LANGUAGE(TCL)

-- COMMIT -- TO SAVE THE CHANGES
-- ROLLBACK
-- SAVEPOINT

-- IN SNOWFLAKE DMLs/DQL ARE AUTO COMMITED

---------------------------
PRE-DEFINED FUNCTION:

NUMERICS FUNCTIONS
STRING FUNCTIONS
DATA & TIME FUNCTIONS

STRING FUNCTIONS:

CONCAT()
CHAR_LENGTH()
UPPER()
LOWER()
REPLACE()
SUBSTRING()
INSTR()
TRIM()
REVERSE()

SNOwFlaKE --

SNOW FLAKE -- SNOWFLAKE --FLAKE

SNOWFLAKE

----------------------------
DAY 2
-----------------------------

5 SQL COMMANDS:

DDL-- DATA DEFINITION LANGUAGE -- CREATE, ALTER, DROP & TRUNCATE

DML -- DATA MANIPULATION LANGUAGE -- INSERT, UPDATE & DELETE
DQL -- DATA QUERY LANGUAGE -- SELECT -- TO FETCH THE DATA FROM TABLES
DCL --DATA CONTROL LANGUAGE -- GRANT, REVOKE
TCL -- TRANSACTIONAL CONTROL LANGUAGE -- COMMIT, ROLLBACK & SAVE POINT

IN SNOWFLAKE DMLS & DDLS ARE AUTO COMMITED

---------------------
STRING FUNCTION:

-- CONCAT -- USED TO COMBINE TO OR MORE STRINGS SNOW FLAKE

SELECT CONCAT('SNOW',' ','FLAKE', ' ','COURSE');

--CHAR_LENGTH()

SELECT CHAR_LENGTH('HELLO');
--UPPER

SELECT UPPER('hello') as word;

--LOWER()

SELECT LOWER('HELLO') AS WORD;

--LENGTH() --

SELECT LENGTH('SNOW FLAKE') AS WORD;

--REPLACE()

SELECT REPLACE('HELLO WORLD','WORLD','SQL') AS WORD;

SELECT REPLACE('SNOWFLAKE','O','I');

--SUBSTR()

SELECT SUBSTR('SNOWFLAKE',4,9);

--TRIM() -- USED TO REMOVE THE SPACES

SELECT TRIM(' SNOWFLAKE');

SELECT TRIM(' SNOWFLAKE COURSE STARTED');

SELECT REVERSE('SNOWFLAKE');

SELECT SUBSTR('HELLO WORLD',3,6) A,REPLACE('ORACLE','O','S') AS B;

----------------------
DATE & TIME FUNCTION:

DATEADD
DATEDIFF
ADDMONTH

SELECT CURRENT_TIMESTAMP(),
DATEADD('HOUR',2,CURRENT_TIMESTAMP);

SELECT CURRENT_TIMESTAMP(),
DATEADD('MINUTES',2,CURRENT_TIMESTAMP);

SELECT CURRENT_TIMESTAMP(),
DATEADD('DAY',-2,CURRENT_TIMESTAMP);

SELECT CURRENT_TIMESTAMP(),
DATEADD('MONTH',2,CURRENT_TIMESTAMP);

SELECT CURRENT_TIMESTAMP(),
DATEADD('YEAR',2,CURRENT_TIMESTAMP);

SELECT CURRENT_TIMESTAMP(),
DATEDIFF('HOUR',CURRENT_TIMESTAMP,DATEADD('HOUR',2,CURRENT_TIMESTAMP));

SELECT CURRENT_TIMESTAMP(),DATEDIFF(MONTH,'2025-06-09'::DATE,'2025-07-
09'::DATE);

SELECT CURRENT_TIMESTAMP(), ADD_MONTHS('2025-07-09'::TIMESTAMP,3);

SELECT CURRENT_ROLE();

SELECT CURRENT_REGION();

SELECT CURRENT_DATABASE(),CURRENT_SCHEMA();

OPERATORS:

LOGICAL OPERATORS & SET OPERATORS

SET OPERATORS:

2 TABLES --1 OUTPUT

HERE WE ARE NOT USING ANY CONDITIONS

WHICH ALLOWS US TO GET SINGLE RESULT FROM MULTIPLE QUERIES

TAB_1,TABL_2 --1 OUTPUT

1 1
2 2
3 3
3 4
4 5

UNION -- IT WILL ELIMINATE DUPLICATE VALUES

UNION ALL -- IT WILL GIVE ALL ENTITIES FROM BOTH THE TABLES EVEN WE HAVE DUPLICATES
MINUS --
INTERSECT -- IT WILLGIVE THE COMMON VALUES

SELECT * FROM TAB_1 MINUS SELECT * FROM TAB_2

RULES:

1. NUMBER OF COLUMN SHOULD MATCH

SELECT * FROM TB1

UNION
SELECT COL1,COL2 FROM TB2

2. COLUMNS SEQ SHOULD MATCH

SELECT COL1,COL2 FROM TB1

MINUS
SELECT COL2,COL1 FROM TB2;

3 DATA TYPES SHOULD MATCH

=====================================
SELECT CURRENT_TIMESTAMP(),
DATEADD('HOUR',2,CURRENT_TIMESTAMP);

SELECT CURRENT_TIMESTAMP(),
DATEADD('MINUTES',2,CURRENT_TIMESTAMP);
 SELECT CURRENT_TIMESTAMP(),
DATEADD('DAY',-2,CURRENT_TIMESTAMP);

SELECT CURRENT_TIMESTAMP(),
DATEADD('MONTH',2,CURRENT_TIMESTAMP);

SELECT CURRENT_TIMESTAMP(),
DATEADD('YEAR',2,CURRENT_TIMESTAMP);

SELECT CURRENT_TIMESTAMP(),
DATEDIFF('HOUR',CURRENT_TIMESTAMP,DATEADD('HOUR',2,CURRENT_TIMESTAMP));

SELECT CURRENT_TIMESTAMP(),DATEDIFF(MONTH,'2025-06-09'::DATE,'2025-07-
09'::DATE);

SELECT CURRENT_TIMESTAMP(), ADD_MONTHS('2025-07-09'::TIMESTAMP,3);

SELECT CURRENT_ROLE();

SELECT CURRENT_REGION();

SELECT CURRENT_DATABASE(),CURRENT_SCHEMA();

=============================================================
SET OPERATORS:

MULTIPLE TABLES -- SINGLE OUTPUT

NO CONDITIONS

UNION-- IT ELIMINATES DUPLICATES AND GIVES DISTINCT VALUES

UNION ALL -- IT WILL DISPLAY ALL VALUES EVEN WE HAVE DUPLICATE
MINUS -- ELIMINATES COMMON VALUES AND GIVES RESULT FIRST TABLE
INTERSECT -- GIVE US COMMON VALUES

CREATE TABLE TB2(

ID NUMBER,
NAME VARCHAR,
AGE NUMBER
);

INSERT INTO TB VALUES (1,'SAI',23),(2,'DEEPU',22),(3,'HARI',34),(4,'RAVI',21);

INSERT INTO TB2 VALUES (2,'DEEPU',22),(5,'ANJU',35),(6,'PRASAD',45),(7,'SASI',32);

SELECT * FROM TB;

SELECT * FROM TB2;

--UNION
SELECT * FROM TB
UNION
SELECT * FROM TB2;

--UNION ALL

SELECT * FROM TB
UNION ALL
SELECT * FROM TB2;

--MINUS

SELECT * FROM TB2

MINUS
SELECT * FROM TB;

--INTERSECT

SELECT * FROM TB
INTERSECT
SELECT * FROM TB2;

-- UNION VS UNION ALL

--UNION ALL HAS BETTER PERFORMANCE THAN UNION WHEN WE DONT HAVE DUPLICATE VALUES

--3 RULES
--1. COLUMN COUNT SHOULD MATCH
--2. COLUMN SEQ SHOULD MATHC WHILE WRITING THE STATEMENTS
--3. DATA TYPES SHOULD MATCH

SELECT ID, NAME FROM TB

UNION
SELECT NAME, ID FROM TB2;

=======================
LOGICAL OPERATORS:

LOGIC & GETTING THE OUTPUT

WHERE CONDITION

2 DATES FROM TO

AND,IN,BETWEEN,OR, LIKE

SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF100.CUSTOMER LIMIT 25;

SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF100.CUSTOMER WHERE C_NATIONKEY NOT IN

(5,20) LIMIT 25;

SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF100.CUSTOMER WHERE C_NATIONKEY BETWEEN

14 AND 23 LIMIT 25;

SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF100.CUSTOMER WHERE C_NATIONKEY = 14 AND

C_MKTSEGMENT = 'BUILDING' LIMIT 25;

SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF100.CUSTOMER WHERE C_NATIONKEY = 14 OR

C_MKTSEGMENT = 'AUTOMOBILE' LIMIT 25;

============================================
JOINS:

3 TABLES -- COMMON COLUMN

EMP TABLE
DEP TB
HR TAB

5 TYPES OF JOINS:

1. INNER JOINS -- MATCHED RECORDS FROM BOTH THE TABLES

2. LEFT (OUTER) JOINS -- MATCHED RECORDS + REMAINING FROM LEFT TABLE
3. RIGHT (OUTER) JOIN-- MATCHED RECORDS + REMAINING FROM RIGHT TABLE
4. FULL JOIN -- MATCHED RECORDS + REMAINING FROM LEFT TABLE + REMAINING FROM RIGHT
TABLE
5. CROSS JOIN -- TAB_a * TAB_b

SELF JOIN -- JOIN BY ITSELF

CREATE TABLE T_C2( ID NUMBER);

INSERT INTO T_C2 VALUES (1),(1),(1),(3),(3);

SELECT COUNT(*) FROM T_C1

INNER JOIN T_C2 WHERE T_C1.ID = T_C2.ID; --8

SELECT COUNT(*) FROM T_C1

LEFT JOIN T_C2 ON T_C1.ID = T_C2.ID; --11

SELECT COUNT(*) FROM T_C1

RIGHT JOIN T_C2 ON T_C1.ID = T_C2.ID;

SELECT COUNT(*) FROM T_C1

FULL JOIN T_C2 ON T_C1.ID = T_C2.ID; --11

SELECT COUNT(*) FROM T_C1

CROSS JOIN T_C2 ;

NULL IS A BLANK

SELECT * FROM T_C2;

INSERT INTO T_C2 VALUES (NULL),(NULL);

SELECT COUNT(*) FROM T_C1

RIGHT JOIN T_C2 ON T_C1.ID = T_C2.ID; --10

SELECT COUNT(*) FROM T_C1

FULL JOIN T_C2 ON T_C1.ID = T_C2.ID; --14

SELECT COUNT(*) FROM T_C1

CROSS JOIN T_C2 ; --49

-- FOR ONLY INNER JOIN NULL IS NOT CONSIDERED

-- NULL WILL NOT BE MATCHED TO ANOTHER NULL

-- FOR CROSS JOIN THERE WONT BE ANY CONDITION

CREATE TABLE ALPHA( C1 VARCHAR);

 CREATE TABLE BETA(C1 VARCHAR);

INSERT INTO ALPHA VALUES ('A'),('A'),('a'),('B'),('C');

INSERT INTO BETA VALUES ('A'),('B'),('b'),('a'),('a');

-- INNER JOIN

SELECT * FROM ALPHA AS X

JOIN BETA Y WHERE X.C1=Y.C1; --5

-- UPPER CASE WILL MATCH WITH UPPER CASE

-- LOWER CASE WITH MATCH LOWER CASE

SELECT COUNT(*) FROM ALPHA AS X

LEFT JOIN BETA Y ON X.C1=Y.C1; --6

SELECT COUNT(*) FROM ALPHA AS X

RIGHT JOIN BETA Y ON X.C1=Y.C1; --6

SELECT COUNT(*) FROM ALPHA AS X

FULL JOIN BETA Y ON X.C1=Y.C1; --7

SELECT COUNT(*) FROM ALPHA AS X

CROSS JOIN BETA Y ; -- 25

-- BY DEFAULT JOIN THAT WILL BE CONSIDERED AS INNER JOIN

SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF100.CUSTOMER;

SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF100.NATION;

SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF100.REGION;

SELECT C.C_CUSTKEY,N.N_NAME FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF100.CUSTOMER C

JOIN SNOWFLAKE_SAMPLE_DATA.TPCH_SF100.NATION N WHERE C.C_NATIONKEY = N.N_NATIONKEY;

--EMP TABLE, DEPARTMENT TABLE

--EMP TABLE-- EMPID,EMPNAME,EMPLOC,DEPTID
--DEPT TBL --DEPTID,DEPTNAME

CREATE OR REPLACE TABLE EMP(

E_ID NUMBER,
E_NAME VARCHAR,
E_SAL NUMBER,
D_ID NUMBER
);

INSERT INTO EMP VALUES (1,'SARITHA',2356,101),(2,'MANJU',3456,102),

(3,'KIRAN',1000,101);

CREATE TABLE DEPT(

D_ID NUMBER,
D_NAME VARCHAR
);

INSERT INTO DEPT VALUES (101,'HR'),(102,'IT');

SELECT * FROM EMP;

SELECT * FROM DEPT;

SELECT E.E_ID,E.E_NAME,D_NAME,D.D_ID,E.E_SAL FROM EMP E

JOIN DEPT D WHERE E.D_ID =D.D_ID;

============================================================
CASE STATEMENT:

0 -- 1 --REPLACE
1 --0 --SWAPING
0 --1

C1,C2-- C3

BASED UPON A CONDITION WE ARE DOING SWAP/REPLACE OR GETTING NEW COLUMN WITH
RESULT
THIS WILL WORK AS IF-THEN-ELSE LOGIC

SYNTAX:

SELECT
CASE
WHEN C1=C2 THEN C3 END
WHEN C1>C2 THEN C3 END
WHEN C1<C2 THEN C3 END
....

N COND

use database sq_db;

use schema sq_sc;

create table bus(

seat_no integer,
total_seats int,
seats_sold int
);

insert into bus values (1234,200,200),(1235,150,140),(1236,100,120),(1237,200,200),

(1238,160,130);

select * from bus;

select *,
case
when total_seats=seats_sold then 'Bus is full'
when total_seats>seats_sold then 'Seats available'
when total_seats<seats_sold then 'over booked'
else 'none'
end status
from bus;
 create or replace table abc(
name varchar,
gender varchar
);

insert into abc values ('a','m'),('b','f'),('c','m'),('d',null);

select * from abc;

select name,
case
when gender = 'm' then '1'
when gender = 'f' then '0'
else null
end gender
from abc;

-- stud >=90 a , >=80 b, >=70 c, >=60 d fail

-- stud_name,marks

============================
DECODE:

IF-ELSE CONDITION
WE WILL COMPARE THE VALUES IN THE SAME COLUMNS AND GETTING THE RESULT

EMP

EMPNM,EMPAGE,EMPLOC,SAL

23 YEARS

=23 YOUNG
=35 MIDDLE_AGE
==50

>50000 LOWER
>=75K MEDIUM
>=90K HIGH

SELECT
DECODE(COLNM, SEARCH_VALUE, RESULT
COLNM2,SEARCH_VALUES,RESULT
.
.
.
COLNMN,SERCA_VALUE,RESULT)
FROM TBNM;

SHOW TABLES;

CREATE OR REPLACE TABLE EMPLOYEE(

EMP_ID NUMBER,
NAME VARCHAR,
SAL INTEGER
);

INSERT INTO EMPLOYEE VALUES (1,'RAVI',50000),(2,'NEHA',70000),(3,'AMIT',55000),

(4,'PRIYA',90000),(5,'SAILESH',45000);

SELECT * FROM EMPLOYEE;

SELECT
NAME,SAL,
DECODE(SAL,50000,'LOW',
70000,'MEDIUM',
90000,'HIGH',
'UNKNOWN') AS SALARY_STATUS
FROM EMPLOYEE;

SELECT *,
CASE
WHEN SAL <=50000 THEN 'LOW'
WHEN SAL >=50000 AND SAL<=70000 THEN 'MEDIUM'
WHEN SAL <= 90000 THEN 'HIGH'
ELSE 'UNKNOWN'
END AS SAL_STATUS
FROM EMPLOYEE;

INSERT INTO EMPLOYEE VALUES (5,'KARAN',100000);

=============================================================
AGGREGATE FUNCTION:

USED FOR CALCULATION ON SET OF ROWS/RECORDS TO RETURN SINGLE VALUE

SUMMARISE/ANALYSIS
GROUP BY, HAVING & WHERE CLAUSE

TOTAL --600
STUDENT MARKS: (A+B+C+D+E+F) MARKS -- SUM(MARKS) -- SUM(A+B+C+D+E+F)
==550

AVG(),SUM(),MIN(),MAX(),COUNT()

SELECT COL1,COL2,COUNT(COL1)
FROM TBNM GROUP BY COL1,COL2;

CREATE TABLE PRODUCT (

PRODUCTNAME VARCHAR,
PRICE NUMBER
);

INSERT INTO PRODUCT (PRODUCTNAME, PRICE) VALUES

('Mobile', 10000),
('Laptop', 45000),
('Mobile', 12000),
('Tablet', 15000),
('Laptop', 47000),
('Headphones', 2000),
('Tablet', 16000),
('Headphones', 2500),
('Mouse', 1000);
SELECT * FROM PRODUCT;

SELECT COUNT(*) FROM PRODUCT;

SELECT PRODUCTNAME,COUNT(PRODUCTNAME) FROM PRODUCT

GROUP BY PRODUCTNAME;

SELECT SUM(PRICE) FROM PRODUCT;

SELECT AVG(PRICE) FROM PRODUCT;

SELECT MIN(PRICE) FROM PRODUCT;

SELECT MAX(PRICE) FROM PRODUCT;

SELECT * FROM PRODUCT;

SELECT PRODUCTNAME,COUNT(PRODUCTNAME) AS TOTAL_COUNT FROM PRODUCT

GROUP BY PRODUCTNAME
HAVING TOTAL_COUNT>1;

-- FOR CALCULATION WE ARE USING GROUP BY CLAUSE

-- FOR FILTERING WE HAVE USED HAVING CLAUSE

SELECT PRODUCTNAME,SUM(PRICE),COUNT(PRODUCTNAME)
FROM PRODUCT
WHERE COUNT(PRODUCTNAME)>1
GROUP BY PRODUCTNAME;

SELECT * FROM PRODUCT;

CREATE TABLE SAL_EMP(

ID NUMBER,
NAME VARCHAR,
SAL NUMBER,
DEPT NUMBER
);

INSERT INTO SAL_EMP VALUES(1,'A',1000,23),(2,'B',1500,24),(3,'C',2000,24),

(4,'D',2000,25),(5,'E',4000,26),(6,'F',3500,23);

SELECT * FROM SAL_EMP;

SELECT DEPT, SUM(SAL),COUNT(DEPT)

FROM SAL_EMP
GROUP BY DEPT;

===================================================
SUB QUERIES:

QUERY WITH IN THE QUERY IS CALLED SUB QUERY

NESTED QUERY/INNER QUERY

SELECT * FROM XYZ WHERE(SELECT MAX(*) FROM XYZ)

OUTPUT OF INNER QUERY WILL BE INPUT TO OUTER QUERY

FILTERING & CALCULATION

 WHERE, HAVING, UPDATE & DELETE

DELETE FROM TB WHERE ID NOT IN(SELECT DISTINCT(*) FROM TB);

1
1
2 1
3 2
3
4 4
4 5
5 6
5
6

SELECT * FROM EMP

WHERE SAL>(SELECT AVG(SAL) FROM EMP);

SELECT * FROM SAL_EMP;

SELECT AVG(SAL) FROM SAL_EMP; --2333

SELECT ID,NAME,SAL
FROM SAL_EMP
WHERE SAL>(SELECT AVG(SAL) FROM SAL_EMP);

-- WRITE A SQL QUERY TO GET LIST OF EMPL DETAILS WHOSE SALARY IS MORE THAN AVG
SAL
COMMON TABLE EXPRESSION(CTE):

USED FOR TEMPORARILY STORING RESULT SET

1000 RECORDS -- 100 RECORDS -- CTE
CTE WONT HAVE PHYSICAL STORAGE

100 RECORDS--100 RECORD

BREAK DOWN THE COMPLEX QUERIES INTO SMALL REUSABLE CODE

STARTS WITH CLAUSE

SYTAX:

WITH CTENM AS(

SQL STMT

) SELECT * FROM CTENM;

THIS CTE CAN BE USED MULTIPLE TIMES

WWE CAN WRITE MULTIPLE CTES ALSO

WITH CTE AS(

 SQL STMT
),
CTE2 AS(
SQL STMT )
SELECT * FROM CTE2;

10 COLUMNS
10 COLUMNS

10 COLUMNS

4 COLUMNS

WITH NAME AS(

SLECT(FIRSTNM,LASTNAM,MIDDLENM )),
CTE2(
SELECT
FROM
NAME ) SELECT * FROM CTE2;

recursive cte:

snowflake ---
s
n
o
w
f
l
a
k
e

to process hirerical data

1
2
3
4
10

with recursive letters as(

select 1 as pos,
substr('snowflake',1,1) as let
union all
select pos+1, substr('snowflake'pos+1,1)
from letters
where pos< 9)
select let from letters;

USE DATABASE TT_DB;

USE SCHEMA TT_SC;

CREATE OR REPLACE TABLE departments (

dept_id INT ,
dept_name STRING
);
-- Employee Table
CREATE OR REPLACE TABLE employees (
emp_id INT ,
emp_name STRING,
salary NUMBER,
dept_id INT

);

-- Insert Departments
INSERT INTO departments (dept_id, dept_name) VALUES
(1, 'HR'),
(2, 'Finance'),
(3, 'IT'),
(4, 'Marketing');

-- Insert Employees
INSERT INTO employees (emp_id, emp_name, salary, dept_id) VALUES
(101, 'Alice', 6000, 1),
(102, 'Bob', 7000, 2),
(103, 'Charlie', 5500, 1),
(104, 'David', 8000, 3),
(105, 'Eva', 6500, 2),
(106, 'Frank', 9000, 3),
(107, 'Grace', 5000, 4);

SELECT * FROM DEPARTMENTS;

SELECT * FROM EMPLOYEES;

SELECT * FROM EMPLOYEES

WHERE SALARY>6000;

WITH CTE AS (
SELECT * FROM EMPLOYEES
WHERE SALARY>6000
) SELECT * FROM CTE;

WITH EmpDept AS (
SELECT e.emp_name, d.dept_name
FROM employees e
INNER JOIN departments d ON e.dept_id = d.dept_id
)
SELECT * FROM EmpDept;

WITH DeptSalary AS (
SELECT dept_id, AVG(salary) AS avg_salary
FROM employees
GROUP BY dept_id
)
SELECT d.dept_name, ds.avg_salary
FROM DeptSalary ds
JOIN departments d ON ds.dept_id = d.dept_id;

WITH HighEarners AS (
 SELECT emp_id, emp_name, salary, dept_id
FROM employees
WHERE salary > 6000
),
EmpDept AS (
SELECT h.emp_name, h.salary, d.dept_name
FROM HighEarners h
JOIN departments d ON h.dept_id = d.dept_id
)
SELECT * FROM EmpDept;

with recursive cte as(

select 1 as a,
substr('snowflake',1,1) as let
union all
select a+1, substr('snowflake',a+1,1)
from letters
where a< 9)
select let from letters;

--snowflake

with recursive number as(

select 1 as x
union all
select x+1 from number
where x< 10
) select x from number;
);
===========================================================
Analytical/WINDOWS functions:

CRUTIAL WHEN WE R DOING DATA ANALYSIS

WE WILL GET THE RESULT BASED UPON DATA PARTITION

ELECTRONICS:

FRIDGE --10 MODEL IS IN TOP POSITION

WASHING MACHINE --10 -- MODEL IS IN TOP POSITION
TELEVISIONS--5 MODEL IS IN TOP POSITION
SPEAKERS--3 MODEL IS IN TOP POSITION

5 TYPES:

1. ROW_NUMBER() -- IT WILL ASSIGN UNIQUE NUMBERS IN SEQUENCE EVEN IF WE HAVE

DUPLICATES
2. RANK()
3. DENSE_RANK()
4. LEAD()
5. LAG()

SHOULD OVER(),ORDER BY(), PARTITION BY()

ASCENDING ORDER & DESCENDING ORDER

 BY DEFAULT IT WILL TAKE ASCENDING ORDER
PARTITION BY WILL GROUP THE RECORDS

RANK() VS DENSE_RANK()

RANK WILL SKIP THE SEQUENCE IF WE HAVE IDENTICAL VALUES AND DENSE RANK WILL NOT
SKIP THE SEQUENCE EVEN WE HAVE IDENTICAL VALUES

2ND HIGHEST SAL

create database wf_db;

create schema wf_sc;

CREATE TABLE ABC(ID VARCHAR);

INSERT INTO ABC VALUES ('A'),('A'),('B'),('C'),('D'),('D'),('D'),('D'),('E'),('E'),

('E'),('F');

SELECT * FROM ABC;

SELECT *,
ROW_NUMBER() OVER (ORDER BY ID) AS RN,
RANK() OVER (ORDER BY ID) AS RK,
DENSE_RANK() OVER (ORDER BY ID) AS DR
FROM ABC;

CREATE OR REPLACE TABLE ABC(ID NUMBER);

SELECT * FROM ABC;

INSERT INTO ABC VALUES (1),(2),(5),(6),(3),(4);

SELECT * FROM ABC;

SELECT *,
ROW_NUMBER() OVER (ORDER BY ID DESC) AS RN
FROM ABC;

create table emp(

empid integer,
empname varchar,
sal integer,
deptnm varchar
);

INSERT INTO emp (empid, empname, sal, deptnm) VALUES

(101, 'Alice', 50000, 'HR'),
(102, 'Bob', 60000, 'Finance'),
(103, 'Charlie', 55000, 'IT'),
(104, 'David', 70000, 'Marketing'),
(105, 'Eva', 65000, 'HR'),
(106,'ramu',50000,'Finance'),
(107,'arjun',45000,'HR');

INSERT INTO EMP VALUES (108,'SMITH',50000,'Finance');

SELECT * FROM EMP;

SELECT *,
ROW_NUMBER() OVER (PARTITION BY DEPTNM ORDER BY SAL) As rn,
RANK() OVER (PARTITION BY DEPTNM ORDER BY SAL) AS RK,
DENSE_RANK() OVER (PARTITION BY DEPTNM ORDER BY SAL) AS DR
FROM EMP;

--2ND HIGHEST SLARY DEPT WISE

SELECT *,
--ROW_NUMBER() OVER (PARTITION BY DEPTNM ORDER BY SAL DESC) AS RN
DENSE_RANK() OVER (PARTITION BY DEPTNM ORDER BY SAL DESC) AS DR
FROM EMP
--QUALIFY DR=2;

INSERT INTO TB(NAME) VALUES ('SNOWFLAKE');

SELECT * FROM TB;

LEAD():TO GET NEXT VALUES/CUMMULATIVE SUM IN A TABLE WE WILL USE LEAD()

A B
B C
C D
D NULL

LAG(): TO GET PREVIOUS VALUES IN A TABLE

A NULL
B A
C B
D C

OVER
ORDER BY
PARTITION BY
WHERE/QUALIFY

MOBILE:

21/07 -- 20 MOBILE -- 40K 7K

22/07 -- 15 MOBILE -- 33K
23/07 --25 --50K

CREATE TABLE TB(

NAME VARCHAR,
AGE NUMBER
);
INSERT INTO TB(NAME) VALUES('RAM',23),('SARITHA',35),('PUSPHA',26),('MANJUSH',34),
('DEVI',29);

SELECT * FROM TB;

SELECT *,
COALESCE(LEAD(AGE) OVER(ORDER BY AGE),0) LD,
COALESCE(LAG(AGE) OVER(ORDER BY AGE),0) LG
FROM TB;

=======================================
NULL HANDLINGS

--NULL HANDLING IS ONE TRANFORMATION

-- NULL MISSING VALUE OR A BLANK

--FN MN LN NAME
--ABC BXC
-- NULL HNJ NULL
--1234 NUL NULL

--NULL HANDLING METHODS

--NVL
--NVL2
--COALESCE

--NVL(CLO1,COL2) IF COL1 IS NULL THEN IT RETURNS COL2 ELSE COL1

--NVL2(COL1,COL2,COL3) IF COL1 IS NULL THEN RETURNS COL2
--COALESCE(COL1,COL2,COL3,....COLN)

CREATE TABLE EMP1( ID NUMBER,

FIRSTNAME VARCHAR,
MIDDLENAME VARCHAR,
LASTNAME VARCHAR);

INSERT INTO EMP1 VALUES(1,'RISHI','KUMAR',NULL),(2,'BINDU',NULL,'REDDY'),

(3,NULL,'KRISHNA',NULL);

SELECT * FROM EMP1;

--IFNULL

SELECT ID,

(FIRSTNAME,'' )||' '|| IFNULL(MIDDLENAME,' ')||' '|| IFNULL(LASTNAME,'') AS NAME

FROM EMP1;

SELECT ID, FIRSTNAME||' '||MIDDLENAME||' '||LASTNAME AS NAME FROM EMP1;

SELECT ID,
NVL(NVL(FIRSTNAME,MIDDLENAME),LASTNAME) AS NAME
FROM EMP1;

SELECT ID,
COALESCE(FIRSTNAME,MIDDLENAME,LASTNAME) AS NAME
FROM EMP1;

create or replace table empl(

 empid number,
firstname varchar,
middlename varchar,
lastname varchar,
age number,
salary number);

insert into empl values (101,'arun','kumar','reddy',28,30000),

(102,'bharat',null,'varma',23,13000),
(103,null,'uma','devi',25,26000),
(104,'suman','kumar',null,30,45000),
(105,'varun',null,null,26,34000);
INSERT INTO EMPL VALUES(107,'KITTU','RAM',NULL,35,NULL);

SELECT * FROM EMPL;

SELECT EMPID,
IFNULL(FIRSTNAME,' ')||' '|| IFNULL(MIDDLENAME,' ')||' '||
IFNULL(LASTNAME,' ') AS NAME,
AGE, SALARY FROM EMPL;

SELECT EMPID, NVL(SALARY,0) AS SALARY FROM EMPL;

SELECT * FROM EMPL;

SELECT EMPID,IFNULL(SALARY,0) AS SALARY FROM EMPL;

-- ISNULL IS WHEN WE ARE WRITING CONDITION

SELECT * FROM EMPL

WHERE FIRSTNAME IS NOT NULL;

CREATE OR REPLACE TABLE T21(

NUMBER NOT NULL ,
NAME VARCHAR
);

INSERT INTO T21 VALUES (1,'SNOWFLAKE'),(2,'SESSION'),(3,'EVENING'),

(1,'AMMU');

--SNOWFLAKE ENFORCES/SUPPORTS ONLY NOT NULL CONSTRANT

-- WILL NOT ENFORCE OTHER CONSTRANTS EXCEPT NOT NULL

================================================
SNOWFLAKE:

SNOWFLAKE IS A CLOUD BASED DATA-WAREHOUSE

SAAS(SOFTWARE AS A SERVICE) MODEL
DATA PROCESSING,DATA STORING, DATA ANALYSIS
 SOURCE(SAP/SQL SERVER(ANY ON-PREMISIS SYSTEMS))--AWS S3(STORAGE) ---
SNOWFLAKE(STAGING LAYER) -- TARGET SYSTEM(CLOUD)(FINAL DATA)

DATA COME IN THE FORM OF FILES(CSV,JSON,AVRO,PARQUET) -- SEMI STRUCTUREE DATA

TIMETRAVEL
CLONE
STAGES
VIEWS
TASKS
SNOWPIPE
DATALOADING HAPPENS FROM CLOUD TO SNOWFLAKE
VALIDATE --
COPY INTO
CACHE

LARGE VOLUMES OF DATA -- 1M RECORDS-- STORAGE COST --COMPUTE COST

DATABASE-- SCHEMA--

ECOMMERSE WEBSITE--AMAZON OR FLIPKART

ELECTRONIC

TV
REFRI
MOBILE
ACCESS
=====================================================
snowflake:

snowflake is cloud based datawarehose which is use dto store data,process and
analysis
olap(online analitical process)-- it will store both current + historical data

features of snowflake:

1. sql supports
2. supports semi structured data like json,avro,orc,xml
3. unlimited storage
4. time-travel
5. clone
6. zero-maintance
7. data share(read-only)
8. security
9. on demand pricing(pay as u use)

==================================
snowflake architecture:
=================================

combination of shared-disk architecture &

shared-nothing architecture
massive parallel process(MPP) happens in snowflake
3 layers:

cloud service layers: optimizer,infrastructure

manage,metadatamanager,security,authentication & access control-- brain of the
snowflake
query processing layers: virtual warehouses -- muscle of the snowflake --run the
queries
database storage layer: disks-- tables,query result-- data will be stored in
columnar format(micropartition)--data will be accessible by onlu sql queries

================================

VIRTUAL WAREHOUSE:

VIRTUAL SCALING: INCREAING THE VWH SIZE

HORIZONTAL SCALING:

CREATE DATABASE VWH_DB; --DDL

SELECT * FROM SQ_DB.SQ_SC.ABC; --DQL

USE WAREHOUSE COMPUTE_WH;

SELECT * FROM SQ_DB.SQ_SC.BUS;

-- RESOURCES LIKE CPU,MEMORY & TEMPORARY STORAGE

--NOT ALL SELECT STMTS NEED VWH
--FOR PERFORMING DMLS LIKE INSERT, UPDATE & DELETE
--DDLS DOESNT REQUIRE WAREHOUSE
--BY DEFAULT SYSADMIN,ACCOUNTADMIN CAN BE ABLE TO CREATE THIS VWH

CREATE TABLE ABC(ID NUMBER);

SELECT * FROM ABC;

INSERT INTO ABC VALUES (1),(2); --DML

CREATE WAREHOUSE PRAC_WH;

DESC WAREHOUSE PRAC_WH;

SHOW WAREHOUSES;

DROP WAREHOUSE PRAC_WH;

CREATE WAREHOUSE PRAC_WH2

WAREHOUSE_SIZE = MEDIUM
AUTO_SUSPEND = 300
;

SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.CUSTOMER;

--100 LINES QUERY RUNNING -- 10MINUTS --1MIN

--INCREASE THE VWH
--NO
VWH IS A COMBINATION OF CPU & MEMORY
CPU & MEMORY ARE CALLED COMPUTE RESOURCES

TO RUN OUR SQL QUERIES WE USE VWH

DDLS DOEST VWH

FEW SELECT STMTS REQUIRE VWH

ALL DMLS NEED VWH

DMLS-

INSERT,DELETE & UPDATE

=============================================
ETL PROCESS

EXTRACTING DATA FROM SOURCES---LANDED IN SNOWFLAKE(RAW DATA)--TRANSIENT

TABLE(STAGING LAYER)--WE APPLY OUR TRANSFORMATION-- LOAD INTO PERMANENT TABLE(PROD
AREAS)

CREATE DATABASE TTYPE_DB;

CREATE SCHEMA TTPYE_SC;

SHOW TABLES;

CREATE TABLE ABC(ID NUMBER); --PERMANENT TABLE

--BY DEFAULT TABLE WILL PERMANENET TABLE

--TIME-TRAVEL & FAIL-SAFE
--MIN 1 DAY & MAX 90(UPTO 90 DAYS)
--7 DAYS FAIL-SAFE PERIOD
--U NEED TO DROP THIS EXPLICITLY

--TRANSIENT TABLE

CREATE TRANSIENT TABLE EMP(ID NUMBER,NAME VARCHAR);

-- BY CHECKING SHOW TABLES-- KIND-TRANSIENT

--1 DAY TIME-TRAVEL
--0 FAIL-SAFE
-- WE NEED TO DROP EXPLICITLY

--TEMPORARY TABLE

-- UNIT TEST
--SESSION SPECFIC
--TIME-TRAVEL 1 DAYS
--0 FAIL SAFE
--IF SESSION ENDS TABLE WILL BE DELELTED

CREATE TEMPORARY TABLE DEPT( ID NUMBER,NAME VARCHAR);

SELECT * FROM DEPT;
SHOW TABLES;

WE CAN'T CONVERT ANY TABLE TO OTHER TABLES

==================================================
TYPES OF TABLES:

PERMANENT
TRANSIENT
TEMPORARY

TIME-TRAVEL:

SQ_DB--DATABASE
--50 TABLES
HE MODIFIED

DBA --BACKUP --RESTORE

TIME-TRAVEL IS A FEATURE IN SNOWFLAKE TO ACCESS/RETRIEVE THE DATA THAT IS

MODIFIED OR DELETED
ACCIDENTALLY THAT TOO WITH IN A SPECIFIC PERIOD OF TIME

3 WAYS:

1. QUERY ID
2. OFFSET
3.TIMESTAMP

2 KEY WORDS

AT/BEFORE

USE DATABASE VWH_DB;

CREATE SCHEMA VWH_SC;

CREATE TABLE EMPDATA( ID NUMBER, NAME VARCHAR,LOC VARCHAR);

INSERT INTO EMPDATA VALUES (1, 'SEKHAR','HYD'),(2,'RAJI','COC'),(3,'KUMAR','BNG');

--01be035d-3201-d2a6-000d-edb2000a69ce

SELECT * FROM EMPDATA; --01be035e-3201-d21b-000d-edb2000a3c96

--01be0360-3201-d20e-000d-edb2000a8422

UPDATE EMPDATA SET LOC= 'DEL'; --01be035e-3201-d21b-000d-edb2000a3c96

--QUERYID
CREATE OR REPLACE TABLE EMPDATA
AS
SELECT * FROM EMPDATA BEFORE(STATEMENT=>'01be035d-3201-d21b-000d-edb2000a3c8a');

SELECT * FROM EMPDATA;

--OFFSET
SELECT * FROM EMPDATA AT(OFFSET=>-300);

SELECT CURRENT_TIMESTAMP();
--TIMESTAMP:

SELECT * FROM EMPDATA AT(TIMESTAMP=>'TUE 2025-07-29 06:33:14.081 -0700

TIMESTAMP::TZ');

SELECT * FROM EMPDATA;

RETENTION PERIOD -- SPECIFIC PERIOD

SHOW TABLES;

--TRANSIENT -1 DAY
--TEMPORAY -1 DAY
--PERMANENT - UPTO 90 DAYS

--TO INCREASE RETENTION PERIOD

ALTER TABLE EMPDATA SET
DATA_RETENTION_TIME_IN_DAYS =5;

SHOW TABLES;

CREATE TABLE T1(ID NUMBER)

DATA_RETENTION_TIME_IN_DAYS =15;

--BY DEFAULT THE RETENTION PERION WILL 1 DAY

CREATE OR REPLACE TRANSIENT TABLE T123(NAME VARCHAR);

ALTER TABLE T123 SET DATA_RETENTION_TIME_IN_DAYS = 0;

SHOW TABLES;

CREATE TEMPORARY TABLE T23(ID NUMBER)

DATA_RETENTION_TIME_IN_DAYS = 5;

========================================================

SHOW TABLES;

DROP DATABASE TTYPE_DB;

--UNDROP

USE DATABASE TTYPE_DB;

UNDROP DATABASE TTYPE_DB;

==============================
CLONE:
================================

PROD -50 TABLES--2GB

DEV -- 50 TABLES --INGESTION / TRANSFORMATION
TEST -- 50 TABLES

CLONE IS NOTHING BUT TAKING SNAPSHOT/BACKUP OF SOURCE DATA FROM BASE TABLE WITHOUT
HAVING PHYSICAL STORAGE
TABL_A--8 RECORDS -- TABLE_A_CLONE -- 8 RECORDS --

SELECT * FROM TABLE_A_CLONE;

ZERO-COPY CLONING

EACH TABLE IS INDEPENDENT TO EACH OTHER

IF WE DO ANY CHANGES ON BASE TABLE THAT WILL NOT IMPACT CLONE TABLE

--ORIGINAL TABLE DDL

create or replace TABLE STUD (

ID NUMBER(38,0) NOT NULL,
NAME VARCHAR(16777216),
MARK NUMBER(38,0)
);

---CTAS DDL

CTAS: DATA+DEFINITION+NO CONSTRAINT

create or replace TABLE STUD_CTAS (

ID NUMBER(38,0),
NAME VARCHAR(16777216),
MARK NUMBER(38,0)
);

--LIKE DDL

create or replace TABLE STUD_LIKE (

ID NUMBER(38,0) NOT NULL,
NAME VARCHAR(16777216),
MARK NUMBER(38,0)
);

LIKE: NO DATA+DDL+CONSTARINT

---CLONE

create or replace TABLE STUD_CLONE (

ID NUMBER(38,0) NOT NULL,
NAME VARCHAR(16777216),
MARK NUMBER(38,0)
);

CLONE: DATA+DDL+CONSTRAINT

CREATE TABLE XYZ(ID NUMBER);

INSERT INTO XYZ VALUES (1),(2),(3),(4);

SELECT * FROM XYZ;

SHOW TABLES;
CREATE TABLE XYZ_C CLONE XYZ

--SYTANX:

--CREATE TABLE NEW_CLONE_TABLE CLONE SOURCE_TABLE;

IN SQL
CTAS
LIKE
CLONE

CREATE TABLE STUD(

ID NUMBER NOT NULL,
NAME VARCHAR,
MARK NUMBER
);

SELECT * FROM STUD;

SELECT GET_DDL('TABLE','STUD');

--CTAS -CREATE TABLE AS SELECT

CREATE OR REPLACE TABLE STUD_CTAS

AS
SELECT * FROM STUD;

SELECT * FROM STUD_CTAS;

SELECT GET_DDL('TABLE','STUD_CTAS');

INSERT INTO STUD VALUES (1,'PREM',12),(2,'SANGEETHA',34);

SELECT * FROM STUD_CTAS;

CREATE TABLE STUD_LIKE LIKE STUD;

SELECT * FROM STUD_LIKE;

SELECT GET_DDL('TABLE','STUD_LIKE');

--CLONE

CREATE TABLE STUD_CLONE CLONE STUD;

SELECT * FROM STUD_CLONE;

SELECT GET_DDL('TABLE','STUD_CLONE');

SHOW TABLES;

--STUD_TEST
--STUD_DEV

SELECT * FROM INFORMATION_SCHEMA.TABLE_STORAGE_METRICS

WHERE TABLE_CATALOG = 'TTYPE_DB'
 AND TABLE_SCHEMA = 'PUBLIC';

-- FOR CLONE TABLE ID IS NOT EQUAL CLONE GROUP ID

=============================================
CLONE:

CLONE IS NOTHING BUT TAKING BACKUP OF DATA FROM SOURCE TABLE WITHOUT HAVING
PHYSICAL STORAGE
CLONE ID != GROUP ID
FOR BASE TABLE ID=GROUP_ID

ZERO-COPY CLONING: IT WILL POINTS TO MICROPARTIONS OF BASE TABLE AND GET THE DATA
FROM THERE

CREATE TABLE WF_DB.WF_SC.EMPLOYEE(

ID NUMBER,
NAME VARCHAR,
LOC VARCHAR
);

INSERT INTO WF_DB.WF_SC.EMPLOYEE VALUES(1,'PRAVEEN','HYD'),(2,'SAI','PUN'),

(3,'KIRAN','DEL'),(4,'PRACHI','COC');

SELECT * FROM WF_DB.WF_SC.EMPLOYEE; --BASE/SOURCE TABLE

CREATE TABLE WF_DB.WF_SC.EMPLOYEE_CLONE CLONE WF_DB.WF_SC.EMPLOYEE;

SELECT * FROM WF_DB.WF_SC.EMPLOYEE_CLONE; --CLONE TABLE

SELECT * FROM INFORMATION_SCHEMA.TABLE_STORAGE_METRICS

WHERE TABLE_CATALOG = 'WF_DB'
AND TABLE_SCHEMA ='WF_SC';

INSERT INTO EMPLOYEE_CLONE VALUES (6,'RAJU','HYD');

SELECT * FROM EMPLOYEE; --5

SELECT * FROM EMPLOYEE_CLONE; --5

--BOTH THE TABLES ARE INDEPENDENT TO EACH OTHER

-- IT WILL OCCUPY SPACE WHEN WE INSERT NEW DATA

-----------------------------------------------------------
MICRO-PARTITONS:

MICRO-PARTITONS ARE IMMUTABLE

DATA IS STORED IN SMALL CHUNKS/BLOCKS IN THE FORM OF COLUMNAR FORMAT