PIVOT and UNPIVOT

---------------------------------------------------------------PIVOT and
UNPIVOT----------------------------------------------------------------------
1. PIVOT
The PIVOT operator takes data in separate rows, aggregates it and converts it into
columns. To see the PIVOT operator in action we need to create a test table.
CREATE TABLE pivot_test (

id NUMBER,
customer_id NUMBER,
product_code VARCHAR2(5),
quantity NUMBER
);
INSERT INTO pivot_test VALUES (1, 1, 'A', 10);

INSERT INTO pivot_test VALUES (2, 1, 'B', 20);
INSERT INTO pivot_test VALUES (3, 1, 'C', 30);
INSERT INTO pivot_test VALUES (7, 3, 'B', 70);
INSERT INTO pivot_test VALUES (9, 3, 'D', 90);
COMMIT;
SELECT * FROM pivot_test
SELECT *
FROM (SELECT product_code, quantity
FROM pivot_test)
PIVOT (SUM(quantity) AS sum_quantity FOR (product_code) IN ('A' , 'B' , 'C' ));
SELECT * FROM (SELECT SALARY,JOB_ID

FROM hr.employees)
PIVOT (SUM(SALARY) as total_salary FOR (JOB_ID)
IN('IT_PROG','FI_ACCOUNT','PU_CLERK'))
SELECT * FROM (SELECT SALARY,department_id

FROM hr.employees)
PIVOT (SUM(SALARY) as total_salary FOR (department_id)
IN(10,20,30,40,50,60,70,80,90))
SELECT SUM(DECODE(product_code, 'A', quantity, 0)) AS a_sum_quantity,

SUM(DECODE(product_code, 'B', quantity, 0)) AS b_sum_quantity,
SUM(DECODE(product_code, 'C', quantity, 0)) AS c_sum_quantity
FROM pivot_test
ORDER BY customer_id;
SELECT SUM(DECODE(department_id, 10, SALARY, 0)) AS dept10_total_salary,

SUM(DECODE(department_id, 20, SALARY, 0)) AS dept20_total_salary,
SUM(DECODE(department_id, 30, SALARY, 0)) AS dept30_total_salary
FROM hr.employees
ORDER BY department_id;
2. UNPIVOT
The UNPIVOT operator converts column-based data into separate rows. To see the
UNPIVOT operator in action we need to create a test table.
CREATE TABLE unpivot_test (
id NUMBER,
customer_id NUMBER,
product_code_a NUMBER,
product_code_b NUMBER,
product_code_c NUMBER,
product_code_d NUMBER
);
INSERT INTO unpivot_test VALUES (1, 101, 10, 20, 30, NULL);
INSERT INTO unpivot_test VALUES (2, 102, 40, NULL, 50, NULL);
INSERT INTO unpivot_test VALUES (3, 103, 60, 70, 80, 90);
INSERT INTO unpivot_test VALUES (4, 104, 100, NULL, NULL, NULL);
COMMIT;
SELECT * FROM unpivot_test;
SELECT *
FROM unpivot_test
UNPIVOT (quantity FOR product_code IN (product_code_a AS 'A', product_code_b AS
'B', product_code_c AS 'C', product_code_d AS 'D'));
-----------------------------------------------------------------------------------
------------
LISTAGG()--------------------------------------------------------------------------
------------------------
The Oracle LISTAGG() function is an aggregation function that transforms data from
multiple rows into a single list of values separated by a specified delimiter.
The Oracle LISTAGG() function is typically used to denormalize values from multiple
rows into a single value which can be a list of comma-seprated values or other
human readable format for the reporting purpose.
SELECT
job_id,
LISTAGG(
first_name,
','
) WITHIN GROUP(
ORDER BY
first_name
) AS employees
FROM
hr.employees
GROUP BY
job_id
ORDER BY
job_id;
-----------------------------------------------------------------------------------
---LEAD and
LAG-------------------------------------------------------------------------------
LEAD and LAG
LEAD allows us to apply any computation on the next rows(rows after the current
row). The general syntax of LEAD function is:
LEAD(<expression>,<offset>,<default>) over(<analytic clause>)

Where
<expression> is the expression to apply on the leading row
<offset> is the number of the leading row relative to the current row(can be
1,2…..)
<default> is the value to be returned if the <offset> points to a row outside the
partition range
CREATE TABLE basic_pays (

employee_id int,
fiscal_year INT,
salary DECIMAL(10 , 2 ),
PRIMARY KEY (employee_id, fiscal_year)
);
INSERT INTO basic_pays(employee_id, fiscal_year,salary) VALUES(100,2017,24000);

INSERT INTO basic_pays(employee_id, fiscal_year,salary) VALUES(100,2020,26179.2);
SELECT
employee_id,
fiscal_year,
salary,
LAG(salary) OVER (
PARTITION BY employee_id
ORDER BY fiscal_year) previous_salary
FROM
basic_pays;
In this example:
First, the PARTITION BY clause divided the result set into groups by employee ID.
Second, for each group, the ORDER BY clause sorted the rows by fiscal year in
ascending order.
Third, LAG() function applied to the row of each group independently. The first row
in each group was NULL because there was no previous year’s salary. The second and
third row gots the salary from the first and second row and populated them into the
previous_salary column.
find the YoY salary increment by using the following query:
SELECT
employee_id,
fiscal_year,
salary,
previous_salary,
CONCAT(ROUND(( salary - previous_salary ) * 100 / previous_salary,0),'%') YoY
FROM
( SELECT
employee_id,
fiscal_year,
salary,
LAG(salary,1,0) OVER (
PARTITION BY employee_id
ORDER BY fiscal_year) previous_salary
FROM
basic_pays
) t;

PIVOT and UNPIVOT

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

PIVOT and UNPIVOT

Uploaded by

Copyright:

Available Formats

---------------------------------------------------------------PIVOT and

CREATE TABLE pivot_test (

INSERT INTO pivot_test VALUES (1, 1, 'A', 10);

SELECT * FROM pivot_test

SELECT * FROM (SELECT SALARY,JOB_ID

SELECT * FROM (SELECT SALARY,department_id

SELECT SUM(DECODE(product_code, 'A', quantity, 0)) AS a_sum_quantity,

SELECT SUM(DECODE(department_id, 10, SALARY, 0)) AS dept10_total_salary,

SELECT * FROM unpivot_test;

LEAD(<expression>,<offset>,<default>) over(<analytic clause>)

<expression> is the expression to apply on the leading row

CREATE TABLE basic_pays (

INSERT INTO basic_pays(employee_id, fiscal_year,salary) VALUES(100,2017,24000);

find the YoY salary increment by using the following query:

You might also like