uma função analítica calcula valores sobre um grupo de linhas e retorna como resultado único para cada linha. Isto é diferente de uma função agregada,que retorna um único resultado para um grupo de linhas.

uma função analítica inclui uma cláusulaOVER, que define uma janela de linhas em torno da linha a ser avaliada. Para cada linha, o resultado da função analítica é calculado usando a janela selecionada de linhas como entrada, possível agregação.

com funções analíticas você pode calcular médias móveis, itens rank, somas de cálculo e realizar outras análises.

As seguintes funções podem ser utilizadas como funções analíticas:funções de navegação,funções de numeração e funções analíticas agregadas

sintaxe da função analítica

analytic_function_name ( ) OVER over_clauseover_clause: { named_window | ( ) }window_specification: ] ] window_frame_clause: { rows_range } { frame_start | frame_between }rows_range: { ROWS | RANGE }

regras de notação

• parêntesis rectos “” indicam cláusulas opcionais.
• parênteses “() ” indicam parênteses literais.
• a barra vertical ” / ” indica um ou lógico.
• Chavetas “{ } ” enclausuram um conjunto de opções.
• uma vírgula seguida de uma elipse entre parênteses rectos “” indica que o item anterior pode repetir-se numa lista separada por vírgulas.

Descrição

uma função analítica calcula os resultados ao longo de um grupo de linhas. Você pode usar a seguinte sintaxe para construir uma função analítica:

• analytic_function_name: a função que executa uma operação analítica.Por exemplo, a função de numeração RANK() pode ser usada aqui.
• argument_list: argumentos que são específicos para a função analítica.Algumas funções têm-nas, outras não.
• OVER: Keyword required in the analytic function syntax preceding the OVER clause.
• over_clause: referências a janela que define um grupo de linhas numa tabela sobre a qual usar uma função analítica.
• window_specification: define as especificações para a janela.
• : define a janela para a janela.
• rows_range: define as linhas físicas ou o intervalo alógico para uma janela.

Notas

Uma função analítica pode aparecer como um escalar expressão operando intwo lugares na consulta:

• SELECT lista. Se a função analítica aparecer na lista SELECT, a sua lista de argumentos e OVER cláusula não pode referir-se aos pseudónimos introduzidos na mesma lista de selecção.
• a cláusulaORDER BY. If the analytic function appears in the ORDER BY clause of the query, its argument list can refer to SELECT list aliases.

uma função analítica não pode referir-se a outra função analítica na sua lista de documentos ou na sua OVER cláusula, mesmo indirectamente através de um pseudónimo.

uma função analítica é avaliada após agregação. Por exemplo, a cláusulaGROUP BY e as funções agregadas não analíticas são avaliadas em primeiro lugar.Como funções agregadas são avaliadas antes de funções analíticas, funções agregadas podem ser usadas como operandos de entrada para funções analíticas.

Devolve

um único resultado para cada linha na entrada.

Definindo a cláusula

analytic_function_name ( ) OVER over_clauseover_clause: { named_window | ( ) }

Descrição

OVER cláusula referências de uma janela que define um grupo de linhas em uma tableupon que usar uma função analítica. Você pode fornecer um named_window que é definido em sua consulta, ou você pode definir as especificações para uma nova janela.

notas

Se não for fornecida qualquer especificação de janela ou janela, as linhas de produção estão incluídas na janela para cada linha.

Exemplos usando o OVER cláusula

Estas consultas usar a janela especificações:

• Calcular um total geral
• Calcule o subtotal
• Calcule a soma cumulativa
• Calcular uma média móvel
• Calcule o número de itens dentro de um intervalo
• Obter mais populares item em cada categoria
• Obter o último valor em um intervalo
• Calcule rank

Estas consultas usar um nome de janela:

• obtém o último valor num intervalo
• Use uma janela com nome numa cláusula da janela

definindo a especificação da janela

window_specification: ] ] 

descrição

define as especificações da janela.

• named_window: O nome de uma janela existente que wasdefined com um WINDOW cláusula.

• PARTITION BY: divide as linhas de entrada em partições separadas, sobre as quais a função analítica é avaliada independentemente.
  • várias expressões de partição são permitidas na cláusula PARTITION BY.
  • uma expressão não pode conter tipos de vírgula flutuante, tipos não agrupáveis,constantes ou funções analíticas.
  • Se esta cláusula opcional não for utilizada, todas as linhas da tabela de entrada imprimem uma única partição.
• ORDER BY: define como as linhas são ordenadas dentro de uma partição.Esta cláusula é opcional na maioria das situações, mas é necessária em alguns casos para funções de navegação.
• : Para funções analíticas agregadas, define a janela dentro da partição atual.A moldura da janela determina o que incluir na janela.Se esta cláusula for utilizada, ORDER BY é necessária excepto para Janelas fundidas por completo.

Notes

If neither the ORDER BY clause nor window frame clause are present,the window frame includes all rows in that partition.

para funções analíticas agregadas, se a cláusula ORDER BY estiver presente mas a cláusula da janela não estiver, a seguinte cláusula da janela é utilizada por omissão:

RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

Por exemplo, as consultas a seguir são equivalentes:

SELECT book, LAST_VALUE(item) OVER (ORDER BY year)FROM Library

SELECT book, LAST_VALUE(item) OVER ( ORDER BY year RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)FROM Library

as Regras para o uso de um nome de janela em janela de especificação

Se você usar um nome de janela em janela especificações, estas regras se aplicam:

• As especificações na janela com o nome pode ser extendedwith novas especificações que definem a janela de especificação cláusula.não pode ter definições redundantes. Se você tem um ORDER BY Claus na janela nomeada e na cláusula de especificação da janela, anerror é lançado.a ordem das cláusulas é importante. PARTITION BY must come first, followed by ORDER BY and . Se você adicionar uma janela com nome, suas especificações da janela são processadas primeiro.

  --this works:SELECT item, purchases, LAST_VALUE(item) OVER (item_window ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS most_popularFROM ProduceWINDOW item_window AS (ORDER BY purchases)--this does not work:SELECT item, purchases, LAST_VALUE(item) OVER (item_window ORDER BY purchases) AS most_popularFROM ProduceWINDOW item_window AS (ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING)

• uma janela com nome e PARTITION BY não pode aparecer em conjunto na especificação da janela. Se precisar de PARTITION BY, adicione-o à janela com nome.

• Você não pode se referir a uma janela nomeada em um ORDER BY cláusula, uma consulta externa,ou qualquer subquery.

Exemplos usando a janela de especificação

Estas consultas definir partições em uma função analítica:

• Calcule o subtotal
• Calcule a soma cumulativa
• Obter mais populares item em cada categoria
• Obter o último valor em um intervalo
• Calcule rank
• Use um nome de janela em janela de moldura cláusula

Estas consultas incluem um chamado de janela em janela de especificação:

• obtenha o último valor num intervalo
• Use uma janela com nome numa cláusula de janela

estas consultas definem como as linhas são ordenadas numa partição:

• Calcule o subtotal
• Calcule a soma cumulativa
• Calcular uma média móvel
• Calcule o número de itens dentro de um intervalo
• Obter mais populares item em cada categoria
• Obter o último valor em um intervalo
• Calcule rank
• Usar um nome de janela em janela de moldura cláusula

Definir a moldura da janela cláusula

window_frame_clause: { rows_range } { frame_start | frame_between }rows_range: { ROWS | RANGE }frame_between: { BETWEEN unbounded_preceding AND frame_end_a | BETWEEN numeric_preceding AND frame_end_a | BETWEEN current_row AND frame_end_b | BETWEEN numeric_following AND frame_end_c }frame_start: { unbounded_preceding | numeric_preceding | }frame_end_a: { numeric_preceding | current_row | numeric_following | unbounded_following }frame_end_b: { current_row | numeric_following | unbounded_following }frame_end_c: { numeric_following | unbounded_following }unbounded_preceding: UNBOUNDED PRECEDINGnumeric_preceding: numeric_expression PRECEDINGunbounded_following: UNBOUNDED FOLLOWINGnumeric_following: numeric_expression FOLLOWINGcurrent_row: CURRENT ROW

A moldura da janela cláusula define a janela de moldura em torno da linha atual withina partição, sobre o qual a função analítica é avaliada.Somente as funções analíticas agregadas podem usar uma cláusula de frame da janela.

• rows_range: uma cláusula que define uma janela com linha física ou uma gama lógica.

  • ROWS: calcula a moldura da janela com base em compensações físicas da linha corrente. Por exemplo, você pode incluir duas linhas antes e depois da linha atual.
  • RANGE: calcula a moldura da janela com base num intervalo lógico de linhas em torno da linha actual, com base na linha actual ORDER BY valor-chave.O valor do intervalo fornecido é adicionado ou subtraído ao valor-chave da linha actual para definir um limite de intervalo inicial ou final para a janela da janela. Numa janela baseada em intervalo, deve haver exatamente uma compressão no ORDER BY cláusula, e a expressão deve ter um tipo anumérico.

  Dica: Se você quiser usar um intervalo com uma data, use ORDER BY com a funçãoUNIX_DATE(). Se você quiser usar um intervalo com um carimbo de data / hora,use o UNIX_SECONDS()UNIX_MILLIS(), ou UNIX_MICROS() função.

• frame_between: cria uma janela com um limite inferior e superior.O primeiro limite representa o limite inferior. O segundo limite representa o limite superior. Apenas algumas combinações de limites podem ser usadas, como mostra na sintaxe anterior.

  • Definir o início da moldura da janela com unbounded_precedingnumeric_precedingnumeric_following, ou current_row.
    • unbounded_preceding: a janela começa no início da partição.
    • numeric_precedingounumeric_following: o início da janela é relativo à linha corrente.
    • current_row: a janela começa na linha actual.
  • Definir o fim da moldura da janela com numeric_precedingnumeric_followingcurrent_row, ou unbounded_following.
    • numeric_precedingounumeric_following: o fim da janela é relativo à linha actual.
    • current_row: A moldura da janela termina na linha actual.
    • unbounded_following: o quadro da janela termina no final dapartição.

• frame_start: cria uma janela com um limite inferior.A moldura da janela termina na linha actual.

  • unbounded_preceding: a janela começa no início da partição.
  • numeric_preceding: o início da janela é relativo à linha corrente.
  • current_row: a janela começa na linha actual.

• numeric_expression: Uma expressão que representa um tipo numérico.A expressão numérica deve ser um parâmetro integrador constante, não-negativo.

notas

Se um limite se estende para além do início ou fim de uma partição,a moldura da janela só irá incluir linhas dentro dessa partição.

não pode usar uma cláusula de janela com funções de navegação e funções de numeração, tais como RANK().estas consultas calculam valores com ROWS:

• Calcule a soma cumulativa
• Calcular uma média móvel
• Obter mais populares item em cada categoria
• Obter o último valor em um intervalo
• Use um nome de janela em janela de moldura cláusula

Estas consultas calcular os valores com RANGE:

• Calcule o número de itens dentro de um intervalo

Estas consultas calcular os valores com um parcial ou totalmente independente janela:

• Calcular um total geral
• Calcule o subtotal
• Calcule a soma cumulativa
• Obter mais populares item em cada categoria
• Calcule rank

Estas consultas calcular os valores numéricos de limites:

• Calcule a soma cumulativa
• Calcular uma média móvel
• Calcule o número de itens dentro de um intervalo
• Obter o último valor em um intervalo
• Use um nome de janela em janela de moldura cláusula

Estas consultas calcular os valores com a linha atual como um limite:

• Compute a grand total
• Compute a subtotal
• Compute a cumulative sum

Referencing a named window

SELECT query_expr, analytic_function_name ( ) OVER over_clauseFROM from_itemWINDOW named_window_expression over_clause: { named_window | ( ) }window_specification: ] ] named_window_expression: named_window AS { named_window | ( ) }

a named window represents a group of rows in a table upon which to use ananalytic function. Um nome de janela é definida emWINDOW cláusula, e referenciado inan analítica da função OVER cláusula.Em um OVER cláusula, uma janela pode aparecer por si mesmo ou embeddedwithin uma janela de especificação.

Exemplos

• Obter o último valor em um intervalo
• Use um nome de janela em janela de moldura cláusula

a função de Navegação conceitos

funções de Navegação geralmente calcular a algumasvalue_expression sobre uma linha diferente na moldura da janela de thecurrent linha. The OVER clause syntax varies across navigation functions.

Requisitos para o OVER cláusula:

• PARTITION BY: Opcional.
• ORDER BY:
  1. Disallowed for PERCENTILE_CONT and PERCENTILE_DISC.
  2. Required for FIRST_VALUELAST_VALUENTH_VALUELEADand LAG.
• window_frame_clause:
  1. Disallowed for PERCENTILE_CONTPERCENTILE_DISCLEAD and LAG.
  2. Optional for FIRST_VALUELAST_VALUE, and NTH_VALUE.

Para todas as funções de navegação, o tipo de dados de resultado é o mesmo tipovalue_expression.

conceitos de função de numeração

funções de numeração atribuem valores inteiros a cada linha com base na sua posição dentro da janela especificada.

Exemplo de RANK()DENSE_RANK() e ROW_NUMBER():

WITH Numbers AS (SELECT 1 as x UNION ALL SELECT 2 UNION ALL SELECT 2 UNION ALL SELECT 5 UNION ALL SELECT 8 UNION ALL SELECT 10 UNION ALL SELECT 10)SELECT x, RANK() OVER (ORDER BY x ASC) AS rank, DENSE_RANK() OVER (ORDER BY x ASC) AS dense_rank, ROW_NUMBER() OVER (ORDER BY x) AS row_numFROM Numbers+---------------------------------------------------+| x | rank | dense_rank | row_num |+---------------------------------------------------+| 1 | 1 | 1 | 1 || 2 | 2 | 2 | 2 || 2 | 2 | 2 | 3 || 5 | 4 | 3 | 4 || 8 | 5 | 4 | 5 || 10 | 6 | 5 | 6 || 10 | 6 | 5 | 7 |+---------------------------------------------------+

• RANK(): Para x = 5, ranké 4, uma vez queRANK() incrementos pelo número de pares no grupo de ordenação de janelas anterior.
• DENSE_RANK(): Para x=5, dense_rank é 3, pois DENSE_RANK() alwaysincrements por 1, nunca perder o valor.
• ROW_NUMBER(): para x=5, is 4.

conceitos de função analítica agregada

uma função agregada é uma função que realiza um cálculo em aset de valores. A maioria das funções agregadas podem ser usadas na função ananalítica. Estas funções agregadas são chamadas Funções analíticas agregadas.

com funções analíticas agregadas, a cláusula OVER é anexada à chamada de função agregada; a sintaxe da chamada de função permanece inalterada.Como suas contrapartidas de função agregada, estas funções analíticas realizam agregações, mas especificamente sobre o frame de janela relevante para cada linha.Os tipos de dados de resultado destas funções analíticas são os mesmos que os seus homólogos da função theiraggregate.

exemplos de função analítica

nestes exemplos, o item seleccionado é a linha actual. Os boldeditems são as linhas que estão incluídas na análise.

tabelas Comuns usados nos exemplos

as tabelas A seguir são utilizados no subsequente agregação analyticquery exemplos: ProduceEmployeese Farm.alguns exemplos referenciam uma tabela chamada Produce:

WITH Produce AS (SELECT 'kale' as item, 23 as purchases, 'vegetable' as category UNION ALL SELECT 'orange', 2, 'fruit' UNION ALL SELECT 'cabbage', 9, 'vegetable' UNION ALL SELECT 'apple', 8, 'fruit' UNION ALL SELECT 'leek', 2, 'vegetable' UNION ALL SELECT 'lettuce', 10, 'vegetable')SELECT * FROM Produce+-------------------------------------+| item | category | purchases |+-------------------------------------+| kale | vegetable | 23 || orange | fruit | 2 || cabbage | vegetable | 9 || apple | fruit | 8 || leek | vegetable | 2 || lettuce | vegetable | 10 |+-------------------------------------+

tabela de Funcionários

Alguns exemplos de referência uma tabela chamada Employees:

WITH Employees AS (SELECT 'Isabella' as name, 2 as department, DATE(1997, 09, 28) as start_date UNION ALL SELECT 'Anthony', 1, DATE(1995, 11, 29) UNION ALL SELECT 'Daniel', 2, DATE(2004, 06, 24) UNION ALL SELECT 'Andrew', 1, DATE(1999, 01, 23) UNION ALL SELECT 'Jacob', 1, DATE(1990, 07, 11) UNION ALL SELECT 'Jose', 2, DATE(2013, 03, 17))SELECT * FROM Employees+-------------------------------------+| name | department | start_date |+-------------------------------------+| Isabella | 2 | 1997-09-28 || Anthony | 1 | 1995-11-29 || Daniel | 2 | 2004-06-24 || Andrew | 1 | 1999-01-23 || Jacob | 1 | 1990-07-11 || Jose | 2 | 2013-03-17 |+-------------------------------------+

Farm tabela

Alguns exemplos de referência uma tabela chamada Farm:

WITH Farm AS (SELECT 'cat' as animal, 23 as population, 'mammal' as category UNION ALL SELECT 'duck', 3, 'bird' UNION ALL SELECT 'dog', 2, 'mammal' UNION ALL SELECT 'goose', 1, 'bird' UNION ALL SELECT 'ox', 2, 'mammal' UNION ALL SELECT 'goat', 2, 'mammal')SELECT * FROM Farm+-------------------------------------+| animal | category | population |+-------------------------------------+| cat | mammal | 23 || duck | bird | 3 || dog | mammal | 2 || goose | bird | 1 || ox | mammal | 2 || goat | mammal | 2 |+-------------------------------------+

Calcular um total geral

Este calcula o valor total para todos os itensProduce tabela.

• (laranja, maçã, alho-porro, repolho, alface, couve) = 54 total de compras
• (laranja, maçã, alho-porro, repolho, alface, couve) = 54 total de compras
• (laranja, maçã, alho-porro, repolho, alface, couve) = 54 total de compras
• (laranja, maçã, alho-porro, repolho, alface, couve) = 54 total de compras
• (laranja, maçã, alho-porro, repolho, alface, couve) = 54 total de compras
• (laranja, maçã, alho-porro, repolho, alface, couve) = 54 total de compras

SELECT item, purchases, category, SUM(purchases) OVER () AS total_purchasesFROM Produce+-------------------------------------------------------+| item | purchases | category | total_purchases |+-------------------------------------------------------+| orange | 2 | fruit | 54 || leek | 2 | vegetable | 54 || apple | 8 | fruit | 54 || cabbage | 9 | vegetable | 54 || lettuce | 10 | vegetable | 54 || kale | 23 | vegetable | 54 |+-------------------------------------------------------+

Calcule o subtotal

Este calcula o subtotal para cada categoriaProduce table.

• frutas
  • (laranja, maçã) = 10 total de compras
  • (laranja, maçã) = 10 total de compras
• legumes
  • (alho-porro, repolho, alface, couve) = 44 total de compras
  • (alho-porro, repolho, alface, couve) = 44 total de compras
  • (alho-porro, repolho, alface, couve) = 44 total de compras
  • (alho-porro, repolho, alface, couve) = 44 total de compras

SELECT item, purchases, category, SUM(purchases) OVER ( PARTITION BY category ORDER BY purchases ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING ) AS total_purchasesFROM Produce+-------------------------------------------------------+| item | purchases | category | total_purchases |+-------------------------------------------------------+| orange | 2 | fruit | 10 || apple | 8 | fruit | 10 || leek | 2 | vegetable | 44 || cabbage | 9 | vegetable | 44 || lettuce | 10 | vegetable | 44 || kale | 23 | vegetable | 44 |+-------------------------------------------------------+

Calcule a soma cumulativa

Este calcula uma soma cumulativa para cada categoriaProduce tabela. A soma é calculada em relação ao teórico definido usando a cláusula ORDER BY.

• frutas
  • (laranja, maçã) = 2 total de compras
  • (laranja, maçã) = 10 total de compras
• legumes
  • (alho-porro, repolho, alface, couve) = 2 total de compras
  • (alho-porro, repolho, alface, couve) = 11 total de compras
  • (alho-porro, repolho, alface, couve) = 21 total de compras
  • (alho-porro, repolho, alface, couve) = 44 total de compras

SELECT item, purchases, category, SUM(purchases) OVER ( PARTITION BY category ORDER BY purchases ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW ) AS total_purchasesFROM Produce+-------------------------------------------------------+| item | purchases | category | total_purchases |+-------------------------------------------------------+| orange | 2 | fruit | 2 || apple | 8 | fruit | 10 || leek | 2 | vegetable | 2 || cabbage | 9 | vegetable | 11 || lettuce | 10 | vegetable | 21 || kale | 23 | vegetable | 44 |+-------------------------------------------------------+

Este faz a mesma coisa que o exemplo anterior. Você não tem que adicionar como um limite, a menos que você gostaria de ler.

SELECT item, purchases, category, SUM(purchases) OVER ( PARTITION BY category ORDER BY purchases ROWS UNBOUNDED PRECEDING ) AS total_purchasesFROM Produce

neste exemplo, todos os itens na tabelaProduce estão incluídos na partição. Apenas as linhas anteriores são analisadas. A análise inicia dois pontos antes da linha atual na partição.

• (laranja, alho-poró, maçã, couve, alface, couve) = NULL
• (laranja, alho-poró, maçã, couve, alface, couve) = NULL
• (laranja, alho-poró, maçã, couve, alface, couve) = 2
• (laranja, alho-poró, maçã, couve, alface, couve) = 4
• (laranja, alho-poró, maçã, couve, alface, couve) = 12
• (laranja, alho-poró, maçã, couve, alface, couve) = 21

SELECT item, purchases, category, SUM(purchases) OVER ( ORDER BY purchases ROWS BETWEEN UNBOUNDED PRECEDING AND 2 PRECEDING ) AS total_purchasesFROM Produce;+-------------------------------------------------------+| item | purchases | category | total_purchases |+-------------------------------------------------------+| orange | 2 | fruit | NULL || leek | 2 | vegetable | NULL || apple | 8 | fruit | 2 || cabbage | 9 | vegetable | 4 || lettuce | 10 | vegetable | 12 || kale | 23 | vegetable | 21 |+-------------------------------------------------------+

Calcular uma média móvel

Isto calcula-se uma média móvel Produce tabela.O limite inferior é 1 linha antes da linha corrente. O limite superior é uma linha a seguir à linha actual.

• (laranja, alho-poró, maçã, couve, alface, couve) = 2 média de compras
• (laranja, alho-poró, maçã, couve, alface, couve) = 4 média de compras
• (laranja, alho-poró, maçã, couve, alface, couve) = 6.3333 média de compras
• (laranja, alho-poró, maçã, couve, alface, couve) = 9 média de compras
• (laranja, alho-poró, maçã, couve, alface, couve) = 14 média de compras
• (laranja, alho-poró, maçã, couve, alface, couve) = 16.5 média de compras

SELECT item, purchases, category, AVG(purchases) OVER ( ORDER BY purchases ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) AS avg_purchasesFROM Produce+-------------------------------------------------------+| item | purchases | category | avg_purchases |+-------------------------------------------------------+| orange | 2 | fruit | 2 || leek | 2 | vegetable | 4 || apple | 8 | fruit | 6.33333 || cabbage | 9 | vegetable | 9 || lettuce | 10 | vegetable | 14 || kale | 23 | vegetable | 16.5 |+-------------------------------------------------------+

Calcule o número de itens dentro de um intervalo

Este exemplo obtém o número de animais que têm um semelhante populationcount Farm tabela.

• (ganso, cão, boi, cabra, pato, gato) = 4 animais entre 0-2.(ganso, cão, boi, cabra, pato, gato) = 5 animais entre a população varia entre 1-3.(ganso, cão, boi, cabra, pato, gato) = 5 animais entre a população varia entre 1-3.(ganso, cão, boi, cabra, pato, gato) = 5 animais entre a população varia entre 1-3.(ganso, cão, boi, cabra, pato, gato) = 4 animais entre a população varia entre 2-4.(ganso, cão, boi, cabra, pato, gato) = 1 animal entre 22-24 habitantes.

SELECT animal, population, category, COUNT(*) OVER ( ORDER BY population RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING ) AS similar_populationFROM Farm;+----------------------------------------------------------+| animal | population | category | similar_population |+----------------------------------------------------------+| goose | 1 | bird | 4 || dog | 2 | mammal | 5 || ox | 2 | mammal | 5 || goat | 2 | mammal | 5 || duck | 3 | bird | 4 || cat | 23 | mammal | 1 |+----------------------------------------------------------+

obter o item mais popular em cada categoria

este exemplo obtém o item mais popular em cada categoria. Ele define como as linhas em uma janela são particionadas e ordenadas em cada partição. A tabelaProduce é referenciada.

• frutas
  • (laranja, maçã) = a apple é mais populares
  • (laranja, maçã) = a apple é mais populares
• legumes
  • (alho-porro, repolho, alface, couve) = couve é mais populares
  • (alho-porro, repolho, alface, couve) = couve é mais populares
  • (alho-porro, repolho, alface, couve) = couve é mais populares
  • (alho-porro, repolho, alface, couve) = couve é mais populares

SELECT item, purchases, category, LAST_VALUE(item) OVER ( PARTITION BY category ORDER BY purchases ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING ) AS most_popularFROM Produce+----------------------------------------------------+| item | purchases | category | most_popular |+----------------------------------------------------+| orange | 2 | fruit | apple || apple | 8 | fruit | apple || leek | 2 | vegetable | kale || cabbage | 9 | vegetable | kale || lettuce | 10 | vegetable | kale || kale | 23 | vegetable | kale |+----------------------------------------------------+

Obter o último valor em um intervalo

Este exemplo obtém os mais populares item em uma janela específica de quadros, usingthe Produce tabela. A moldura da janela analisa até três de cada vez. Veja de perto a coluna demost_popular para os produtos hortícolas.Em vez de obter o item mais popular em uma categoria específica, ele recebe o item mais popular em uma faixa específica nessa categoria.

• frutas
  • (laranja, maçã) = a apple é mais populares
  • (laranja, maçã) = a apple é mais populares
• legumes
  • (alho-porro, repolho, alface, couve) = repolho é mais populares
  • (alho-porro, repolho, alface, couve) = alface é mais populares
  • (alho-porro, repolho, alface, couve) = couve é mais populares
  • (alho-porro, repolho, alface, couve) = couve é mais populares

SELECT item, purchases, category, LAST_VALUE(item) OVER ( PARTITION BY category ORDER BY purchases ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) AS most_popularFROM Produce+----------------------------------------------------+| item | purchases | category | most_popular |+----------------------------------------------------+| orange | 2 | fruit | apple || apple | 8 | fruit | apple || leek | 2 | vegetable | cabbage || cabbage | 9 | vegetable | lettuce || lettuce | 10 | vegetable | kale || kale | 23 | vegetable | kale |+----------------------------------------------------+

Este exemplo retorna os mesmos resultados como o exemplo anterior, mas includesa chamado de janela de chamada item_window. Algumas das especificações da janela são definidas diretamente na cláusula OVER e algumas são definidas na janela nomeada.

SELECT item, purchases, category, LAST_VALUE(item) OVER ( item_window ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) AS most_popularFROM ProduceWINDOW item_window AS ( PARTITION BY category ORDER BY purchases)

Compute rank

Este exemplo calcula a classificação de cada empregado dentro do seu departamento,com base na sua data de início. A especificação da janela é definida directamente na cláusula OVER. A tabela Employees é referenciada.

• departamento 1
  • (Jacob, Anthony Andrew) = Atribuir uma classificação de 1 a Jacó
  • (Jacob, Anthony Andrew) = Atribuir uma classificação 2 de Anthony
  • (Jacob, Anthony Andrew) = Atribuir uma classificação 3 Andrew
• departamento 2
  • (Isabella, Daniel, Jose) = Atribuir uma classificação de 1 a Isabella
  • (Isabella, Daniel, José) = Atribuir uma classificação de 2 a Daniel
  • (Isabella, Daniel, José) = Atribuir uma classificação 3 Jose

SELECT name, department, start_date, RANK() OVER (PARTITION BY department ORDER BY start_date) AS rankFROM Employees;+--------------------------------------------+| name | department | start_date | rank |+--------------------------------------------+| Jacob | 1 | 1990-07-11 | 1 || Anthony | 1 | 1995-11-29 | 2 || Andrew | 1 | 1999-01-23 | 3 || Isabella | 2 | 1997-09-28 | 1 || Daniel | 2 | 2004-06-24 | 2 || Jose | 2 | 2013-03-17 | 3 |+--------------------------------------------+

Use um nome de janela em janela de moldura cláusula

Você pode definir alguns de seus lógica em uma chamada de janela e algumas delas em uma cláusula de enquadramento da janela. Esta lógica é combinada. Aqui está um exemplo, usando a tabelaProduce.

SELECT item, purchases, category, LAST_VALUE(item) OVER (item_window) AS most_popularFROM ProduceWINDOW item_window AS ( PARTITION BY category ORDER BY purchases ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING)+-------------------------------------------------------+| item | purchases | category | most_popular |+-------------------------------------------------------+| orange | 2 | fruit | apple || apple | 8 | fruit | apple || leek | 2 | vegetable | lettuce || cabbage | 9 | vegetable | kale || lettuce | 10 | vegetable | kale || kale | 23 | vegetable | kale |+-------------------------------------------------------+

Você também pode obter os resultados anteriores com estes exemplos:

SELECT item, purchases, category, LAST_VALUE(item) OVER (item_window) AS most_popularFROM ProduceWINDOW a AS (PARTITION BY category), b AS (a ORDER BY purchases), c AS (b ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING), item_window AS (c)

SELECT item, purchases, category, LAST_VALUE(item) OVER (item_window ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS most_popularFROM ProduceWINDOW a AS (PARTITION BY category), b AS (a ORDER BY purchases), item_window AS (b)

O exemplo a seguir gera um erro devido a um quadro de janela cláusula beendefined duas vezes:

SELECT item, purchases, category, LAST_VALUE(item) OVER ( item_window ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) AS most_popularFROM ProduceWINDOW item_window AS ( ORDER BY purchases ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING)