Regola di analisi di aggregazione

InAWS Clean Rooms, una regola di analisi di aggregazione genera statistiche aggregate utilizzando le funzioni COUNT, SUM e/o AVG insieme a dimensioni opzionali. Quando la regola di analisi di aggregazione viene aggiunta a una tabella configurata, consente al membro che può eseguire query sulla tabella configurata.

La regola di analisi di aggregazione supporta casi d'uso come la pianificazione delle campagne, la copertura dei media, la misurazione della frequenza e l'attribuzione.

La struttura e la sintassi delle query supportate sono definite in. Struttura e sintassi delle interrogazioni di aggregazione

I parametri della regola di analisi, definita inRegola di analisi dell'aggregazione: controlli di interrogazione, includono i controlli di interrogazione e i controlli dei risultati delle query. I suoi controlli di interrogazione includono la possibilità di richiedere che una tabella configurata sia aggiunta ad almeno una tabella configurata di proprietà del membro che può eseguire query, direttamente o in modo transitivo. Questo requisito ti consente di garantire che la query venga eseguita sull'intersezione (INNERJOIN) della tua tabella e della loro.

Struttura e sintassi delle interrogazioni di aggregazione

Le query su tabelle che dispongono di una regola di analisi di aggregazione devono rispettare la sintassi seguente.

    --select_aggregate_function_expression
SELECT 
aggregation_function(column_name) [[AS] column_alias ] [, ...]

    --select_grouping_column_expression                        
  [, {column_name|scalar_function(arguments)} [[AS] column_alias ]][, ...]   

--table_expression
FROM table_name [[AS] table_alias ]
  [[INNER] JOIN table_name [[AS] table_alias] ON join_condition] [...]

--where_expression
[WHERE where_condition]          

--group_by_expression                          
[GROUP BY {column_name|scalar_function(arguments)}, ...]]                  

--having_expression
[HAVING having_condition]                               

--order_by_expression    
[ORDER BY {column_name|scalar_function(arguments)} [{ASC|DESC}]] [,...]]

Nella tabella seguente vengono illustrate tutte le espressioni elencate nella sintassi precedente.

Expression	Definizione	Esempi
select_aggregate_function_expression	Un elenco separato da virgole contenente le seguenti espressioni: select_aggregation_function_expression select_aggregate_expression Nota Deve essercene almeno una select_aggregation_function_expression in. select_aggregate_expression	SELECT SUM(PRICE), user_segment
select_aggregation_function_expression	Una o più funzioni di aggregazione supportate applicate a una o più colonne. Sono consentite solo le colonne come argomenti delle funzioni di aggregazione. Nota Deve essercene almeno uno select_aggregation_function_expression in. select_aggregate_expression	AVG(PRICE) COUNT(DISTINCT user_id)
select_grouping_column_expression	Un'espressione che può contenere qualsiasi espressione utilizzando quanto segue: Nomi di colonna delle tabelle Funzioni scalari supportate Stringhe letterali Letterali numerici Nota select_aggregate_expressionpuò assegnare un alias alle colonne con o senza il parametro. AS Per ulteriori informazioni, vedere AWS Clean RoomsSQL Reference.	TRUNC(timestampColumn) UPPER(campaignName)
table_expression	Una tabella, o unione di tabelle, che collega espressioni condizionali di join conjoin_condition. join_conditionrestituisce un valore booleano. I table_expression supporti: Un JOIN tipo specifico (INNERJOIN) La condizione di confronto dell'uguaglianza all'interno di a join_condition (=) Operatori logici (AND,OR).	FROM consumer_table INNER JOIN provider_table ON consumer_table.identifier1 = provider_table.identifier1 AND consumer_table.identifier2 = provider_table.identifier2
where_expression	Un'espressione condizionale che restituisce un valore booleano. Può essere composta dai seguenti elementi: Nomi di colonna delle tabelle Funzioni scalari supportate Operatori matematici Stringhe letterali Letterali numerici Le condizioni di confronto supportate sono ()=, >, <, <=, >=, <>, !=, NOT, IN, NOT IN, LIKE, IS NULL, IS NOT NULL. Gli operatori logici supportati sono (AND, OR). where_expressionÈ facoltativo.	WHERE where_condition WHERE price > 100 WHERE TRUNC(timestampColumn) = '1/1/2022' WHERE timestampColumn = timestampColumn2 - 14
group_by_expression	Un elenco di espressioni separate da virgole che soddisfano i requisiti per. select_grouping_column_expression	GROUP BY TRUNC(timestampColumn), UPPER(campaignName), segment
having_expression	Un'espressione condizionale che restituisce un valore booleano. Hanno una funzione di aggregazione supportata applicata a una singola colonna (ad esempioSUM(price)) e vengono confrontati con un valore letterale numerico. Le condizioni supportate sono (). =, >, <, <=, >=, <>, != Gli operatori logici supportati sono (AND, OR). having_expressionÈ facoltativo.	HAVING SUM(SALES) > 500
order_by_expression	Un elenco di espressioni separate da virgole compatibile con gli stessi requisiti definiti in select_aggregate_expression precedenza. È order_by_expression facoltativo. Nota order_by_expressionpermessi ASC e DESC parametri. Per ulteriori informazioni, vedere i parametri ASC DESC nel AWS Clean Rooms riferimento SQL.	ORDER BY SUM(SALES), UPPER(campaignName)

Per quanto riguarda la struttura e la sintassi delle query di aggregazione, tieni presente quanto segue:

• I comandi SQL diversi da quelli non SELECT sono supportati.

• Le sottoquery e le espressioni di tabella comuni (ad esempioWITH) non sono supportate.

• Gli operatori che combinano più interrogazioni (ad esempioUNION) non sono supportati.

• TOPLIMIT, e OFFSET i parametri non sono supportati.

Regola di analisi dell'aggregazione: controlli di interrogazione

Con i controlli di interrogazione di aggregazione, puoi controllare come le colonne della tabella vengono utilizzate per interrogare la tabella. Ad esempio, è possibile controllare quale colonna viene utilizzata per l'unione, quale colonna può essere contata o quale colonna può essere utilizzata nelle WHERE istruzioni.

Nelle sezioni seguenti viene illustrato ogni controllo.

Controlli di aggregazione

Utilizzando i controlli di aggregazione, è possibile definire quali funzioni di aggregazione consentire e a quali colonne devono essere applicate. Le funzioni di aggregazione possono essere utilizzate nelle espressioni SELECTHAVING, e. ORDER BY

Controllo	Definizione	Utilizzo
aggregateColumns	Colonne di colonne di tabella configurate che è possibile utilizzare all'interno delle funzioni di aggregazione.	aggregateColumnspuò essere utilizzato all'interno di una funzione di aggregazione nelle SELECT espressioniHAVING, e ORDERBY. Alcuni aggregateColumns possono anche essere classificati come joinColumn (definiti in seguito). aggregateColumnGiven non può anche essere classificato come dimensionColumn (definito in seguito).
function	Le funzioni COUNT, SUM e AVG consentite possono essere utilizzate in aggiunta a. aggregateColumns	functionpuò essere applicato a qualsiasi aggregateColumns oggetto ad esso associato.

Unisci i controlli

Una JOIN clausola viene utilizzata per combinare righe di due o più tabelle, in base a una colonna correlata tra di esse.

È possibile utilizzare i controlli Join per controllare il modo in cui la tabella può essere unita ad altre tabelle in. table_expression AWS Clean Roomssupporta solo INNERJOIN. INNERJOINle istruzioni possono utilizzare solo colonne che sono state classificate in modo esplicito come una delle regole di analisi, joinColumn in base ai controlli definiti dall'utente.

INNERJOINDevono operare su una joinColumn tabella configurata e su un'altra tabella configurata nella collaborazione. joinColumn Sei tu a decidere quali colonne della tabella possono essere utilizzate comejoinColumn.

Ogni condizione di corrispondenza all'interno della ON clausola è richiesta per utilizzare la condizione di confronto di uguaglianza (=) tra due colonne.

Le condizioni di corrispondenza multiple all'interno di una ON clausola possono essere:

• Combinato utilizzando l'operatore logico AND

• Separato utilizzando l'operatore OR logico

Nota

Tutte le JOIN condizioni di partita devono corrispondere a una riga su ciascun lato delJOIN. Anche tutti i condizionali collegati da un operatore logico OR o da un operatore AND logico devono rispettare questo requisito.

Di seguito è riportato un esempio di interrogazione con un operatore logicoAND.

SELECT some_col, other_col 
FROM table1 
    JOIN table2 
    ON table1.id = table2.id AND table1.name = table2.name

Di seguito è riportato un esempio di interrogazione con un operatore OR logico.

SELECT some_col, other_col 
FROM table1 
    JOIN table2 
    ON table1.id = table2.id OR table1.name = table2.name

Controllo	Definizione	Utilizzo
joinColumns	Le colonne (se presenti) che si desidera consentire al membro che può eseguire la query di utilizzare nell'INNERJOINistruzione.	Uno specifico joinColumn può anche essere classificato come aggregateColumn (vediControlli di aggregazione). La stessa colonna non può essere utilizzata sia come che come joinColumn dimensionColumns (vedi più avanti). A meno che non sia stata anche classificata come unaaggregateColumn, a non joinColumn può essere utilizzata in altre parti della query diverse da. INNER JOIN
joinRequired	Controlla se hai bisogno di un messaggio INNER JOIN con una tabella configurata dal membro che può eseguire la query.	Se si abilita questo parametro, INNER JOIN è necessario un. Se non abiliti questo parametro, an INNER JOIN è facoltativo. Supponendo che questo parametro sia abilitato, il membro che può eseguire la query deve includere una tabella di sua proprietà in. INNER JOIN Devono unire JOIN la propria tabella alla propria, direttamente o transitivamente (ossia, unire la propria tabella a un'altra tabella, che a sua volta è unita al tavolo dell'utente).

Di seguito è riportato un esempio di transitività.

ON 
my_table.identifer = third_party_table.identifier
....
ON
third_party_table.identifier = member_who_can_query_table.id

Nota

Il membro che può eseguire la query può anche utilizzare il joinRequired parametro. In tal caso, la query deve unire la propria tabella ad almeno un'altra tabella.

Controlli dimensionali

I controlli delle dimensioni controllano la colonna lungo la quale le colonne di aggregazione possono essere filtrate, raggruppate o aggregate.

Controllo	Definizione	Utilizzo
dimensionColumns	Le colonne (se presenti) che consenti al membro che può eseguire la query di utilizzare inSELECT,, WHERE e. GROUP BY ORDER BY	A dimensionColumn può essere usato in SELECT (select_grouping_column_expression)WHERE, GROUPBY, e ORDERBY. La stessa colonna non può essere sia a dimensionColumn che a joinColumn e/o anaggregateColumn.

Funzioni scalari

Le funzioni scalari controllano quali funzioni scalari possono essere utilizzate nelle colonne dimensionali.

Controllo	Definizione	Utilizzo
scalarFunctions	Le funzioni scalari che possono essere utilizzate dimensionColumns nella query.	Speciifica le funzioni scalari (se presenti) su cui è possibile applicare (ad esempioCAST). dimensionColumns Le funzioni scalari non possono essere utilizzate sopra altre funzioni o all'interno di altre funzioni. Gli argomenti delle funzioni scalari possono essere colonne, stringhe letterali o letterali numerici.

Sono supportate le seguenti funzioni scalari:

• Funzioni matematiche: ABS, CEILING, FLOOR, LOG, LN, ROUND, SQRT

• Funzioni di formattazione dei tipi di dati — CAST, CONVERT, TO_CHAR, TO_DATE, TO_NUMBER, TO_TIMESTAMP

• Funzioni di stringa: LOWER, UPPER, TRIM, RTRIM, SUBSTRING

  • Per RTRIM, i set di caratteri personalizzati da tagliare non sono consentiti.

• Espressioni condizionali — COALESCE

• Funzioni di data: EXTRACT, GETDATE, CURRENT_DATE, DATEADD

• Altre funzioni: TRUNC

Per maggiori dettagli, consulta AWS Clean RoomsSQL Reference.

Regola di analisi di aggregazione: controlli dei risultati delle query

Con i controlli dei risultati delle query di aggregazione, è possibile controllare quali risultati vengono restituiti specificando una o più condizioni che ogni riga di output deve soddisfare per poter essere restituita. AWS Clean Roomssupporta vincoli di aggregazione sotto forma di. COUNT (DISTINCT column) >= X Questo modulo richiede che ogni riga aggreghi almeno X valori distinti di una scelta dalla tabella configurata (ad esempio, un numero minimo di valori distinti). user_id Questa soglia minima viene applicata automaticamente, anche se la query inviata stessa non utilizza la colonna specificata. Vengono applicate collettivamente a ogni tabella configurata nell'interrogazione effettuata dalle tabelle configurate di ciascun membro della collaborazione.

Ogni tabella configurata deve avere almeno un vincolo di aggregazione nella regola di analisi. I proprietari delle tabelle configurate possono aggiungerne di più columnName e associarle minimum e vengono applicate collettivamente.

Vincoli di aggregazione

I vincoli di aggregazione controllano quali righe dei risultati della query vengono restituite. Per essere restituita, una riga deve soddisfare il numero minimo specificato di valori distinti in ogni colonna specificata nel vincolo di aggregazione. Questo requisito si applica anche se la colonna non è menzionata esplicitamente nella query o in altre parti della regola di analisi.

Controllo	Definizione	Utilizzo
columnName	Il aggregateColumn that viene utilizzato nella condizione che ogni riga di output deve soddisfare.	Può essere qualsiasi colonna nella tabella configurata.
minimum	Il numero minimo di valori distinti associati aggregateColumn che deve avere la riga di output (ad esempio, COUNT DISTINCT) per poter essere restituita nei risultati della query.	minimumDeve essere almeno il valore 2.

Struttura delle regole di analisi dell'aggregazione

L'esempio seguente mostra una struttura predefinita per una regola di analisi di aggregazione.

Nell'esempio seguente, MyTablefa riferimento alla tabella di dati. È possibile sostituire ogni segnaposto di input dell'utente con le proprie informazioni.

{
  "aggregateColumns": [
    {
      "columnNames": [MyTable column names], "function": [Allowed Agg Functions]
    },
  ],
  "joinRequired": ["QUERY_RUNNER"],  
  "joinColumns": [MyTable column names],
  "dimensionColumns": [MyTable column names],
  "scalarFunctions": [Allowed Scalar functions],
  "outputConstraints": [
    {
      "columnName": [MyTable column names], "minimum": [Numeric value] 
    },
  ]
}

Regola di analisi dell'aggregazione: esempio

L'esempio seguente dimostra come due aziende possono collaborare AWS Clean Rooms utilizzando l'analisi di aggregazione.

L'azienda A dispone di dati sui clienti e sulle vendite. L'azienda A è interessata a comprendere l'attività di restituzione dei prodotti. La società B è uno dei rivenditori della società A e dispone di dati sui resi. La società B dispone inoltre di attributi di segmento relativi ai clienti utili all'azienda A (ad esempio, ha acquistato prodotti correlati, utilizza il servizio clienti del rivenditore). L'azienda B non desidera fornire dati sui resi dei clienti a livello di riga e informazioni sugli attributi. La società B desidera solo abilitare una serie di query per l'azienda A per ottenere statistiche aggregate sui clienti che si sovrappongono a una soglia minima di aggregazione.

La società A e la società B decidono di collaborare in modo che l'azienda A possa comprendere l'attività di restituzione dei prodotti e fornire prodotti migliori presso l'azienda B e altri canali.

Per creare la collaborazione ed eseguire un'analisi di aggregazione, le aziende eseguono le seguenti operazioni:

1. L'azienda A crea una collaborazione e crea un'iscrizione. La collaborazione ha l'azienda B come altro membro della collaborazione. La società A consente la registrazione delle interrogazioni nell'ambito della collaborazione e la registrazione delle interrogazioni nel proprio account.

2. L'azienda B crea un'appartenenza alla collaborazione. Consente la registrazione delle interrogazioni nel proprio account.

3. La società A crea una tabella configurata per le vendite.

4. La società A aggiunge la seguente regola di analisi di aggregazione alla tabella configurata per le vendite.

   {
     "aggregateColumns": [
       {
         "columnNames": [
           "identifier"
         ],
         "function": "COUNT_DISTINCT"
       },
       {
         "columnNames": [
           "purchases"
         ],
         "function": "AVG"
       },
       {
         "columnNames": [
           "purchases"
         ],
         "function": "SUM"
       }
     ],
     "joinColumns": [
       "hashedemail"
     ],
     "dimensionColumns": [
       "demoseg",
       "purchasedate",
       "productline"
     ],
     "scalarFunctions": [
       "CAST",
       "COALESCE",
       "TRUNC"
     ],
     "outputConstraints": [
       {
         "columnName": "hashedemail",
         "minimum": 2,
         "type": "COUNT_DISTINCT"
       },
     ]
   }

   aggregateColumns— La società A desidera contare il numero di clienti unici nella sovrapposizione tra i dati di vendita e i dati sui resi. L'azienda A desidera inoltre sommare il numero di purchases prodotti da confrontare con il numero direturns.

   joinColumns— La società A intende utilizzare questa tecnica identifier per abbinare i clienti provenienti dai dati di vendita ai clienti provenienti dai dati sui resi. Ciò aiuterà l'Azienda A ad abbinare i resi agli acquisti giusti. Inoltre, aiuta l'azienda A a segmentare i clienti che si sovrappongono.

   dimensionColumns— La società A filtra in base dimensionColumns al prodotto specifico, confronta gli acquisti e i resi in un determinato periodo di tempo, assicura che la data di restituzione sia successiva a quella del prodotto e aiuta a segmentare i clienti che si sovrappongono.

   scalarFunctions— La società A seleziona la funzione CAST scalare per aiutare ad aggiornare i formati dei tipi di dati, se necessario, in base alla tabella configurata che la società A associa alla collaborazione. Aggiunge inoltre funzioni scalari per facilitare la formattazione delle colonne, se necessario.

   outputConstraints— La società A stabilisce vincoli minimi di output. Non è necessario limitare i risultati perché all'analista è consentito visualizzare i dati a livello di riga dalla tabella delle vendite

   Nota

   La società A non include joinRequired nella regola di analisi. Fornisce la flessibilità necessaria all'analista per interrogare solo la tabella delle vendite.

5. La società B crea una tabella configurata per i resi.

6. La società B aggiunge la seguente regola di analisi di aggregazione alla tabella configurata per i resi.

   {
     "aggregateColumns": [
       {
         "columnNames": [
           "identifier"
         ],
         "function": "COUNT_DISTINCT"
       },
       {
         "columnNames": [
           "returns"
         ],
         "function": "AVG"
       },
       {
         "columnNames": [
           "returns"
         ],
         "function": "SUM"
       }
     ],
     "joinColumns": [
       "hashedemail"
     ],
     "joinRequired": [
       "QUERY_RUNNER"
     ],
     "dimensionColumns": [
       "state",
       "popularpurchases",
       "customerserviceuser",
       "productline",
       "returndate"
     ],
     "scalarFunctions": [
       "CAST",
       "LOWER",
       "UPPER",
       "TRUNC"
     ],
     "outputConstraints": [
       {
         "columnName": "hashedemail",
         "minimum": 100,
         "type": "COUNT_DISTINCT"
       },
       {
         "columnName": "producttype",
         "minimum": 2,
         "type": "COUNT_DISTINCT"
       }
     ]
   }

   aggregateColumns— La società B consente alla società A di effettuare una somma returns da confrontare con il numero di acquisti. Hanno almeno una colonna aggregata perché abilitano una query aggregata.

   joinColumns— La società B consente alla società A di aderire per identifier abbinare i clienti provenienti dai dati di restituzione ai clienti dai dati di vendita. identifieri dati sono particolarmente sensibili e la loro presenza joinColumn garantisce che non vengano mai inseriti in una query.

   joinRequired— L'azienda B richiede che le domande sui dati di restituzione vengano sovrapposte ai dati di vendita. Non vogliono consentire all'azienda A di interrogare tutte le persone nel loro set di dati. Hanno anche concordato tale restrizione nel loro accordo di collaborazione.

   dimensionColumns— La società B consente alla società A di filtrare e raggruppare per statepopularpurchases, e customerserviceuser si tratta di attributi unici che potrebbero aiutare a effettuare l'analisi per la società A. La società B consente all'azienda A di utilizzare per filtrare l'output in base returndate a returndate ciò che si verifica successivamentepurchasedate. Con questo filtraggio, l'output è più accurato per valutare l'impatto della modifica del prodotto.

   scalarFunctions— L'azienda B consente quanto segue:

   • TRUNC per le date

   • LOWER e UPPER nel caso in producttype cui i dati siano immessi in un formato diverso

   • CASTse la società A deve convertire i tipi di dati delle vendite in modo che corrispondano ai tipi di dati dei resi

   La società A non abilita altre funzioni scalari perché non ritiene che siano necessarie per le query.

   outputConstraints— L'azienda B stabilisce vincoli minimi di output hashedemail per contribuire a ridurre la capacità di reidentificare i clienti. Aggiunge inoltre un vincolo minimo di output producttype per ridurre la capacità di identificare nuovamente i prodotti specifici che sono stati restituiti. Alcuni tipi di prodotto potrebbero essere più dominanti in base alle dimensioni della produzione (ad esempio,). state I loro vincoli di output verranno sempre applicati indipendentemente dai vincoli di output aggiunti dalla società A ai propri dati.

7. La società A crea una tabella di vendita associata alla collaborazione.

8. La società B crea un'associazione tra tabelle di restituzione e collaborazione.

9. La società A esegue interrogazioni, come nell'esempio seguente, per comprendere meglio la quantità di resi nell'azienda B rispetto al totale degli acquisti per località nel 2022.

   SELECT
     companyB.state,
     SUM(companyB.returns),
     COUNT(DISTINCT companyA.hashedemail)
   FROM
     sales companyA
     INNER JOIN returns companyB ON companyA.identifier = companyB.identifier
   WHERE
     companyA.purchasedate BETWEEN '2022-01-01' AND '2022-12-31' AND
     TRUNC(companyB.returndate) > companyA.purchasedate
   GROUP BY
     companyB.state;

10. La Società A e la Società B esaminano i registri delle interrogazioni. La società B verifica che la richiesta sia in linea con quanto concordato nell'accordo di collaborazione.

Risoluzione dei problemi relativi alle regole di analisi di aggregazione

Utilizza queste informazioni per aiutarti a diagnosticare e risolvere i problemi più comuni quando lavori con le regole di analisi di aggregazione.

Problemi

• La mia query non ha prodotto alcun risultato

La mia query non ha prodotto alcun risultato

Questo può accadere quando non ci sono risultati corrispondenti o quando i risultati corrispondenti non soddisfano una o più soglie minime di aggregazione.

Per ulteriori informazioni sulle soglie minime di aggregazione, consulta. Regola di analisi dell'aggregazione: esempio