2.tech Mahindra Placement Paper

2/28/2016 Oracle Analytic Functions
PSOUG Home Code Snippets Oracle Lookup Oracle Reference Oracle Error Codes Oracle Functions PSOUG Forum
CODE JOBS FORUM

Oracle Code Library Find Or Post Oracle Jobs Oracle Discussion & Chat
PSOUG Home Code Snippets Oracle Reference Oracle Functions PSOUG Forum Oracle Blogs

10 Search the Reference Library pages:
Search
Oracle Analytic Functions
Version 11.1

Have you seen our new Functions page? If not ... Click Here ... for instant access to all Oracle functions

AVG
AVG( DISTINCT | ALL <expression>) OVER (analytic clause)
Returns a running average
CREATE TABLE vote_count (
submit_date DATE NOT NULL,
num_votes NUMBER NOT NULL);
INSERT INTO vote_count VALUES (TRUNC(SYSDATE)4, 100);
COMMIT;
SELECT * FROM vote_count;
SELECT submit_date, num_votes, TRUNC(AVG(num_votes)
OVER(ORDER BY submit_date ROWS UNBOUNDED PRECEDING))
AVG_VOTE_PER_DAY
FROM vote_count
ORDER BY submit_date;
SELECT submit_date, num_votes, TRUNC(AVG(num_votes)
OVER(PARTITION BY submit_date ORDER BY submit_date ROWS
UNBOUNDED PRECEDING)) AVG_VOTE_PER_DAY
FROM vote_count
Free
Oracle CORR
Magazine
Subscriptions CORR(<expression1>, <expression2>) OVER (<analytic clause>)
and Oracle Returns the coefficient of conn sh/sh
White Papers correlation of a set of number
pairs
SELECT t.calendar_month_number,
CORR (SUM(s.amount_sold), SUM(s.quantity_sold))
OVER (ORDER BY t.calendar_month_number) AS CUM_CORR
FROM sales s, times t
WHERE s.time_id = t.time_id AND calendar_year = 1998
GROUP BY t.calendar_month_number;

COUNT
COUNT(<*, [ DISTINCT | ALL] <expression>>) OVER (<analytic
Returns a running count of all clause>)
records or by partition
SELECT submit_date, num_votes, TRUNC(COUNT(num_votes)
OVER(ORDER BY submit_date ROWS UNBOUNDED PRECEDING)) AS
http://psoug.org/reference/analytic_functions.html 1/10
REPLAY DAY_COUNT
FROM vote_count
SELECT submit_date, COUNT(*)
OVER(PARTITION BY submit_date ORDER BY submit_date
ROWS UNBOUNDED PRECEDING) NUM_RECS
FROM vote_count;
PLAY CREATE TABLE myprods (
RUMMY Return a frequency distribution prod1 NUMBER(3),
prod2 NUMBER(3),
WIN CASH prod3 NUMBER(3));
INSERT INTO myprods VALUES (34,23,45);
SELECT prod1, COUNT(prod1) OVER (PARTITION BY prod1) freq1,
prod2, COUNT(prod2) OVER (PARTITION BY prod2) freq2,
"REAL TIME prod3, COUNT(prod3) OVER (PARTITION BY prod3) freq3
ENTERTAINMENT" FROM myprods;

COVAR_POP
COVAR_POP(<expression1>, <expression2>) OVER (<analytic
Returns the population covariance clause>)
of a set of number pairs
conn hr/hr
Mr. Shameer Basha,
Facility Manager, SELECT job_id,
Bangalore COVAR_POP(SYSDATEhire_date, salary) AS covar_pop,
COVAR_SAMP(SYSDATEhire_date, salary) AS covar_samp
FROM employees
WHERE department_id in (50, 80)
GROUP BY job_id;

COVAR_SAMP
COVAR_SAMP(<expression1>, <expression2>) OVER (<analytic
Returns the sample covariance of clause>)
a set of number pairs
See COVAR_POP Demo above

CUME_DIST
CUME_DIST(<value>) OVER (<partition_clause> <order by clause>)
Returns the cumulative
distribution of a value in a group conn hr/hr
of values
SELECT job_id, last_name, salary, CUME_DIST()
OVER (PARTITION BY job_id ORDER BY salary) AS cume_dist
FROM employees
WHERE job_id LIKE 'PU%';

DENSE_RANK
DENSE_RANK() OVER (<query_partition_clause> <order_by_clause>)
Ranks items in a group leaving no
gaps in ranking sequence when conn hr/hr
there are ties
SELECT d.department_name, e.last_name, e.salary, DENSE_RANK()
OVER (PARTITION BY e.department_id ORDER BY e.salary) AS
DENSE_RANK
FROM employees e, departments d
WHERE e.department_id = d.department_id
AND d.department_id IN (30, 60);

FIRST
SELECT <aggregate_function(column_name)> KEEP
Returns the row ranked first using (DENSE_RANK FIRST ORDER BY <column_name> [<ASC|DESC> NULLS
DENSE_RANK
<FIRST|LAST>)
OVER (PARTITION BY <column_name>)
FROM <table_name>
GROUP BY <column_name>;
conn hr/hr
SELECT last_name, department_id, salary,
MIN(salary) KEEP (DENSE_RANK FIRST ORDER BY commission_pct)
OVER (PARTITION BY department_id) "Worst",
MAX(salary) KEEP (DENSE_RANK LAST ORDER BY commission_pct)
OVER (PARTITION BY department_id) "Best"
FROM employees
WHERE department_id IN (30, 60)
ORDER BY department_id, salary;

FIRST_VALUE
FIRST_VALUE(<expression> [IGNORE NULLS])
Returns the first value in an OVER (<analytic clause>)
ordered set of values. If the first
value in the set is null, then the
function returns NULL unless you conn hr/hr
specify IGNORE NULLS
SELECT last_name, salary, hire_date, FIRST_VALUE(hire_date)
OVER (ORDER BY salary ROWS BETWEEN UNBOUNDED PRECEDING AND
UNBOUNDED FOLLOWING) AS lv
FROM (SELECT * FROM employees WHERE department_id = 90
ORDER BY hire_date);

IGNORE NULLS
(<column_name> IGNORE NULLS)
The following is a minor
modification of a demo published
in the November/December 2006 CREATE TABLE t1 (
issue of Oracle Magazine by Tom row_num NUMBER(3),
Kyte col1 VARCHAR2(15),
col2 VARCHAR2(15));
INSERT INTO t1 VALUES (6, NULL, NULL);
INSERT INTO t1 VALUES (1, 'Category 1', 'Mango');
INSERT INTO t1 VALUES (4, NULL, 'Banana');
INSERT INTO t1 VALUES (7, 'Category 2', 'Vanilla');
INSERT INTO t1 VALUES (9, 'Category 3', 'Strawberry');
COMMIT;
SELECT * FROM t1;
SELECT row_num,
LAST_VALUE(col1 IGNORE NULLS) OVER (ORDER BY row_num) col1,
LAST_VALUE(col2 IGNORE NULLS) OVER (ORDER BY row_num) col2
FROM t1
ORDER BY row_num;

LAG
LAG(<value expression>, <offset>, <default>)
LAG provides access to more OVER ([<query partition clause>] <order_by_clause>)
than one row of a table at the
same time without a selfjoin. conn hr/hr
Given a series of rows returned
from a query and a position of the SELECT last_name, hire_date, salary,
cursor, LAG provides access to a
row at a given physical offset prior
LAG(salary, 1, 0) OVER (ORDER BY hire_date) AS PREV_SAL
to that position. FROM employees
WHERE job_id = 'PU_CLERK';

LAST
<aggregate function> KEEP (DENSE_RANK LAST ORDER BY
Returns the row ranked last using
DENSE_RANK (<expression> <ASC | DESC> NULLS <FIRST | LAST>)
See FIRST Demo above

LAST_VALUE
Returns the last value in an LAST_VALUE (<expression> IGNORE NULLS) OVER (<analytic clause>)
ordered set of values. If the last
value in the set is null, then the conn hr/hr
function returns NULL unless you
specify IGNORE NULLS. This
setting is useful for data SELECT last_name, salary, hire_date, LAST_VALUE(hire_date)
densification. If you specify OVER (ORDER BY salary ROWS BETWEEN UNBOUNDED PRECEDING AND
IGNORE NULLS, then UNBOUNDED FOLLOWING) AS lv
LAST_VALUE returns the first FROM (SELECT * FROM employees WHERE department_id = 90
nonnull value in the set, or NULL
ORDER BY hire_date);
if all values are null.

LEAD
LEAD(<expression, offset, default>)
LEAD provides access to a row at [(<query_partition_clause>)]
a given physical offset beyond
that position
OVER (<order_by_clause>)
SELECT submit_date, num_votes,
LEAD(num_votes, 1, 0) OVER (ORDER BY submit_date) AS NEXT_VAL
FROM vote_count;

MAX
MAX (< DISTINCT | ALL> expression) OVER (<analytic clause>)
Returns the maximum value by
partition conn hr/hr
SELECT manager_id, last_name, salary
FROM (
SELECT manager_id, last_name, salary,
MAX(salary) OVER (PARTITION BY manager_id) AS rmax_sal
FROM employees)
WHERE salary = rmax_sal;

MIN
MIN (< DISTINCT | ALL> expression) OVER (<analytic clause>)
Returns the minimum value by
partition conn hr/hr
SELECT manager_id, last_name, salary
FROM (
SELECT manager_id, last_name, salary,
MAX(salary) OVER (PARTITION BY manager_id) AS rmax_sal
FROM employees)
WHERE salary = rmax_sal;

NTILE
NTILE (<expression>) OVER ([query_partition_clause] <order by
Divides an ordered data set into a clause>)
number of buckets indicated by
expr and assigns the appropriate conn hr/hr
bucket number to each row. The
buckets are numbered 1 through SELECT last_name, salary,
expr. The expr value must resolve
to a positive constant for each
NTILE(4) OVER (ORDER BY salary DESC) AS quartile
partition. FROM employees
WHERE department_id = 100;

OVER PARTITION BY
NTILE (<expression>) OVER ([query_partition_clause] <order by
This demo returns employees that clause>)
are making above average salary
in their respective department conn hr/hr
col ename format a30
col department_name format a20
SELECT * FROM (
SELECT e.ffirst_name || ' ' || e.last_name ENAME,
d.department_name,
e.salary, TRUNC(e.salary avg(e.salary) OVER (PARTITION BY
e.department_id)) sal_dif
FROM employees e, departments d
WHERE e.department_id=d.department_id)
WHERE sal_dif > 0
ORDER BY 2,4 DESC;

PERCENT_RANK
PERCENT_RANK(<value>) OVER (<partition_clause>
<order_by_clause>)
For a row r, PERCENT_RANK conn hr/hr
calculates the rank of r minus 1,
divided by 1 less than the number
of rows being evaluated (the entire SELECT department_id, last_name, salary, PERCENT_RANK()
query result set or a partition). OVER (PARTITION BY department_id ORDER BY salary DESC) AS pr
FROM employees
ORDER BY pr, salary;

PERCENTILE_CONT
PERCENTILE_CONT(<value>) WITHIN GROUP (ORDER BY <expression>
Inverse distribution function that
[ASC | DESC]) OVER (<partition_clause>)
assumes a continuous distribution conn hr/hr
model. It takes a percentile value
and a sort specification, and
returns an interpolated value that SELECT last_name, salary, department_id,
would fall into that percentile PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY salary DESC)
value with respect to the sort OVER (PARTITION BY department_id) PCT_CONT, PERCENT_RANK()
specification. Nulls are ignored in OVER (PARTITION BY department_id ORDER BY salary DESC) PCT_RANK
the calculation. FROM employees
WHERE department_id IN (30, 60);

PERCENTILE_DISC
PERCENTILE_DISC(<expression>) WITHIN GROUP (ORDER BY
<order_by_clause>)
conn hr/hr
An inverse distribution function
that assumes a discrete col cume_dist format 9.999
distribution model. It takes a
percentile value and a sort SELECT last_name, salary, department_id,
specification and returns an PERCENTILE_DISC(0.5) WITHIN GROUP (ORDER BY salary DESC)
element from the set. Nulls are
ignored in the calculation. OVER (PARTITION BY department_id) PCT_DISC,
CUME_DIST() OVER (PARTITION BY department_id
ORDER BY salary DESC) CUME_DIST
FROM employees
WHERE department_id IN (30, 60);

RANK
RANK(<value>) OVER (<partition_clause> ORDER BY
Calculates the rank of a value in a <order_by_clause>)
group of values
conn hr/hr
SELECT department_id, last_name, salary, commission_pct,
RANK() OVER (PARTITION BY department_id
ORDER BY salary DESC, commission_pct) "Rank"
FROM employees
/* The following query finds the 5 topselling products for
each product subcategory where that product contributes more
than 20% of the sales within its product category. */
conn sh/sh
col categ format a15
col prod_subcategory format a20
SELECT SUBSTR(prod_category,1,8) AS CATEG, prod_subcategory,
prod_id, sales
FROM (
SELECT p.prod_category, p.prod_subcategory, p.prod_id,
SUM(amount_sold) as SALES, SUM(SUM(amount_sold))
OVER (PARTITION BY p.prod_category) AS CAT_SALES,
SUM(SUM(amount_sold))
OVER (PARTITION BY p.prod_subcategory) AS SUBCAT_SALES,
RANK() OVER (PARTITION BY p.prod_subcategory
ORDER BY SUM(amount_sold) ) AS RANK_IN_LINE
FROM sales s, customers c, countries co, products p
WHERE s.cust_id = c.cust_id
AND c.country_id = co.country_id
AND s.prod_id = p.prod_id
AND s.time_id = TO_DATE('11OCT2000')
GROUP BY p.prod_category, p.prod_subcategory, p.prod_id
ORDER BY prod_category, prod_subcategory)
WHERE SUBCAT_SALES > 0.2 * CAT_SALES
AND RANK_IN_LINE<=5;

RATIO_TO_REPORT
RATIO_TO_REPORT(<value>) OVER (<partition_clause>)
Computes the ratio of a value to conn hr/hr
the sum of a set of values. If expr
evaluates to null, then the ratioto SELECT last_name, salary, RATIO_TO_REPORT(salary) OVER () AS RR
report value also evaluates to null.
FROM employees
WHERE job_id = 'PU_CLERK';

REGR_ (Linear Regression) Functions
FUNCTION_NAME (<expression1>,<expression2>) OVER
Generic Syntax
(<analytic_clause>)
see REGR_AVGX Demo
REGR_AVGX
conn hr/hr
SELECT job_id, employee_id ID, salary,
REGR_SLOPE(SYSDATEhire_date, salary)
OVER (PARTITION BY job_id) slope,
REGR_INTERCEPT(SYSDATEhire_date, salary)
OVER (PARTITION BY job_id) intcpt,
REGR_R2(SYSDATEhire_date, salary)
OVER (PARTITION BY job_id) rsqr,
REGR_COUNT(SYSDATEhire_date, salary)
OVER (PARTITION BY job_id) count,
REGR_AVGX(SYSDATEhire_date, salary)
OVER (PARTITION BY job_id) avgx,
REGR_AVGY(SYSDATEhire_date, salary)
OVER (PARTITION BY job_id) avgy
FROM employees
ORDER BY job_id, employee_id;
see REGR_AVGX Demo
REGR_AVGY
conn hr/hr
SELECT job_id,
REGR_AVGY(SYSDATE hire_date, salary) avgy,
REGR_AVGX(SYSDATE hire_date, salary) avgx
FROM employees
GROUP BY job_id;
see REGR_AVGX Demo
REGR_COUNT
conn hr/hr
SELECT job_id,
REGR_COUNT(SYSDATEhire_date, salary) count
FROM employees
GROUP BY job_id;
see REGR_AVGX Demo
REGR_INTERCEPT
conn hr/hr
SELECT job_id,
REGR_SLOPE(SYSDATE hire_date, salary) slope,
REGR_INTERCEPT(SYSDATE hire_date, salary) intercept
FROM employees
WHERE department_id in (50,80)
GROUP BY job_id
ORDER BY job_id;
see REGR_AVGX Demo
REGR_R2
conn hr/hr
SELECT job_id, REGR_R2(SYSDATEhire_date, salary) Regr_R2
FROM employees
WHERE department_id IN (50, 80)
GROUP BY job_id;
See REGR_AVGX Demo
REGR_SLOPE
See REGR_INTERCEPT Demo
conn hr/hr
REGR_SXX
SELECT job_id,
REGR_SXY((SYSDATE hire_date, salary) regr_sxy,
REGR_SXX((SYSDATE hire_date, salary) regr_sxx,
REGR_SYY(SYSDATE hire_date, salary) regr_syy
FROM employees
GROUP BY job_id
ORDER BY job_id;
REGR_SXY See REGR_SXX Demo
REGR_SYY See REGR_SXX Demo

ROW_NUMBER
ROW_NUMBER(<value>) OVER (<partition_clause> ORDER BY
Assigns a unique number to each <order_by_clause>)
row to which it is applied (either
each row in the partition or each CREATE TABLE test (
row returned by the query), in the id NUMBER(1),
ordered sequence of rows degrees NUMBER(3));
specified in the order by clause,
beginning with 1.
INSERT INTO test VALUES (0,235);
COMMIT;
SELECT * FROM test;
choose the starting cell
SELECT id, degrees s
FROM (
SELECT id, degrees, (360 degrees) d360,
ROW_NUMBER() OVER(PARTITION BY id
ORDER BY CASE
WHEN( (degrees < 360 degrees) THEN( degrees
ELSE 360 degrees
END) rn
FROM test) t
WHERE rn = 1;
order the rest clockwise
SELECT *
FROM (
SELECT t.id, t.degrees,
ROW_NUMBER() OVER(PARTITION BY t.id
ORDER BY CASE
WHEN( (t.degrees < starting_cell.degrees) THEN( t.degrees +
360
ELSE t.degrees
END) rn
FROM test t
JOIN (
SELECT id, degrees, (360 degrees) d360,
ROW_NUMBER() OVER(PARTITION BY id
ORDER BY CASE
WHEN( (degrees < 360 degrees) THEN( degrees
ELSE 360 degrees
END) rn
FROM test) starting_cell
ON t.id = starting_cell.id
WHERE starting_cell.rn=1)t
ORDER BY id, rn;

STDDEV
STDDEV([ DISTINCT | ALL] <expression>) OVER (<analytic_clause>)
Returns the sample standard
deviation of an expression conn hr/hr
col stddev format 99999.999
SELECT last_name, salary,
STDDEV(salary) OVER (ORDER BY hire_date) "StdDev"
FROM employees

STDDEV_POP
STDDEV_POP(<expression>) OVER (<analytic_clause>)
conn hr/hr
Computes the population standard
deviation and returns the square
root of the population variance SELECT department_id, last_name, salary,
STDDEV_POP(salary) OVER (PARTITION BY department_id) AS pop_std
FROM employees;

STDDEV_SAMP
STDDEV_SAMP(<expression>) OVER (<analytic_clause>)
Computes the cumulative sample
standard deviation and returns the conn hr/hr
square root of the sample
variance. SELECT department_id, last_name, hire_date, salary,
STDDEV_SAMP(salary) OVER (PARTITION BY department_id
ORDER BY hire_date
ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cum_sdev
FROM employees;

SUM

Computes the cumulative sample
running sum CREATE TABLE vote_count (
submit_date DATE NOT NULL,
Corrected thanks to a note from Mette
Stephansen in Denmark.
num_votes NUMBER NOT NULL);
COMMIT;
SELECT * FROM vote_count;
SELECT submit_date, num_votes, SUM(num_votes)
OVER(ORDER BY submit_date ROWS UNBOUNDED PRECEDING) TOT_VOTE
FROM vote_count

VAR_POP
VAR_POP(<value>) OVER (<analytic_clause>)
Returns the population variance of
a set of numbers conn sh/sh
SELECT t.calendar_month_desc, VAR_POP(SUM(s.amount_sold))
OVER (ORDER BY t.calendar_month_desc) "Var_Pop",
VAR_SAMP(SUM(s.amount_sold))
OVER (ORDER BY t.calendar_month_desc) "Var_Samp"
FROM sales s, times t
WHERE s.time_id = t.time_id AND t.calendar_year = 2001
GROUP BY t.calendar_month_desc;

VAR_SAMP
Returns the sample variance of a VAR_SAMP(<value>) OVER (<analytic_clause>)
set of numbers See VAR_POP Demo above

VARIANCE
VARIANCE([ DISTINCT | ALL] <value>) OVER (<analytic_clause>)
Returns the variance of an
expression conn hr/hr
SELECT last_name, salary,
VARIANCE(salary) OVER (ORDER BY hire_date) AS VARIANCE
FROM employees

Additional Demos
CREATE TABLE test (id, quality, weight) AS
SELECT 1,'A',10 FROM DUAL UNION ALL
SELECT 4,'B',11 FROM DUAL UNION ALL
SELECT 5,'B',19 FROM DUAL UNION ALL
SELECT 8,'C',4 FROM DUAL UNION ALL
SELECT 9,'C',7 FROM DUAL;
Another example: SELECT *
FROM test;
This one written by Maxim
Demenko
SELECT MAX(id) ID, MAX(quality) QUALITY, SUM(weight) WEIGHT
FROM (
SELECT id, quality, weight, SUM(new_seq) OVER (ORDER BY id)
new_grp
FROM (
SELECT id, quality, weight, DECODE((LAG(quality) OVER
(ORDER BY id),
quality, 0, id) new_seq
FROM test))
GROUP BY new_grp
ORDER BY 1;

Related Topics
Date Functions
Numeric Functions
Rank
String Functions

Home : Code Library : Sponsors : Privacy : Terms of Use : Contact Us [58 users online] © 2010 psoug.org

2.tech Mahindra Placement Paper

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

2.tech Mahindra Placement Paper

Diunggah oleh

Hak Cipta:

Format Tersedia

2/28/2016 Oracle Analytic Functions

PSOUG Home Code Snippets Oracle Lookup Oracle Reference Oracle Error Codes Oracle Functions PSOUG Forum

CODE JOBS FORUM

PSOUG Home Code Snippets Oracle Reference Oracle Functions PSOUG Forum Oracle Blogs

Anda mungkin juga menyukai