

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Aturan analisis agregasi
<a name="analysis-rules-aggregation"></a>

Dalam AWS Clean Rooms, *aturan analisis agregasi* menghasilkan statistik agregat menggunakan fungsi COUNT, SUM, and/or AVG sepanjang dimensi opsional. Ketika aturan analisis agregasi ditambahkan ke tabel yang dikonfigurasi, ini memungkinkan anggota yang dapat melakukan kueri untuk menjalankan kueri pada tabel yang dikonfigurasi.

Aturan analisis agregasi mendukung penggunaan kasus seperti perencanaan kampanye, jangkauan media, pengukuran frekuensi, dan atribusi. 

Struktur kueri dan sintaks yang didukung didefinisikan dalam[Struktur kueri agregasi dan sintaks](#agg-query-structure-syntax).

Parameter aturan analisis, yang didefinisikan dalam[Aturan analisis agregasi - kontrol kueri](#agg-query-controls), termasuk kontrol kueri dan kontrol hasil kueri. Kontrol kuerinya mencakup kemampuan untuk mengharuskan tabel yang dikonfigurasi digabungkan ke setidaknya satu tabel yang dikonfigurasi yang dimiliki oleh anggota yang dapat melakukan kueri, baik secara langsung maupun transitif. Persyaratan ini memungkinkan Anda untuk memastikan bahwa kueri dijalankan di persimpangan (INNERJOIN) tabel Anda dan mereka.

## Struktur kueri agregasi dan sintaks
<a name="agg-query-structure-syntax"></a>

Kueri pada tabel yang memiliki aturan analisis agregasi harus mematuhi sintaks berikut.

```
--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}]] [,...]]
```

Tabel berikut menjelaskan setiap ekspresi yang tercantum dalam sintaks sebelumnya.


| Ekspresi | Definisi | Contoh | 
| --- | --- | --- | 
| select\$1aggregate\$1function\$1expression |  Daftar dipisahkan koma yang berisi ekspresi berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/clean-rooms/latest/userguide/analysis-rules-aggregation.html)  Harus ada setidaknya satu `select_aggregation_function_expression` di`select_aggregate_expression`.    |  `SELECT SUM(PRICE), user_segment`  | 
| select\$1aggregation\$1function\$1expression |  Satu atau lebih fungsi agregasi yang didukung diterapkan pada satu atau beberapa kolom. Hanya kolom yang diizinkan sebagai argumen fungsi agregasi.  Harus ada setidaknya satu `select_aggregation_function_expression` di`select_aggregate_expression`.    |  `AVG(PRICE)` `COUNT(DISTINCT user_id)`  | 
| select\$1grouping\$1column\$1expression |  Ekspresi yang dapat berisi ekspresi apa pun menggunakan berikut ini: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/clean-rooms/latest/userguide/analysis-rules-aggregation.html)  `select_aggregate_expression`dapat alias kolom dengan atau tanpa `AS` parameter. Untuk informasi selengkapnya, lihat [Referensi AWS Clean Rooms SQL](https://docs.aws.amazon.com/clean-rooms/latest/sql-reference/sql-reference.html).   |  `TRUNC(timestampColumn)`  `UPPER(campaignName)`   | 
| table\$1expression |  Sebuah tabel, atau gabungan tabel, menghubungkan menggabungkan ekspresi kondisional dengan`join_condition`. `join_condition`mengembalikan Boolean.  `table_expression`Dukungan: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/clean-rooms/latest/userguide/analysis-rules-aggregation.html)  |  <pre>FROM consumer_table <br />INNER JOIN provider_table<br />ON<br />consumer_table.identifier1 = provider_table.identifier1<br />AND<br />consumer_table.identifier2 = provider_table.identifier2</pre>  | 
| where\$1expression |  Ekspresi kondisional yang mengembalikan Boolean. Ini mungkin terdiri dari yang berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/clean-rooms/latest/userguide/analysis-rules-aggregation.html) Kondisi perbandingan yang didukung adalah (`=, >, <, <=, >=, <>, !=, NOT, IN, NOT IN, LIKE, IS NULL, IS NOT NULL`).  Operator logis yang didukung adalah (`AND, OR`). `where_expression`Itu opsional.  |  `WHERE where_condition` `WHERE price > 100`  `WHERE TRUNC(timestampColumn) = '1/1/2022'`  `WHERE timestampColumn = timestampColumn2 - 14`   | 
| group\$1by\$1expression |  Daftar ekspresi yang dipisahkan koma yang cocok dengan persyaratan untuk. `select_grouping_column_expression`   |  `GROUP BY TRUNC(timestampColumn), UPPER(campaignName), segment`  | 
| having\$1expression |  Ekspresi kondisional yang mengembalikan Boolean. Mereka memiliki fungsi agregasi yang didukung diterapkan ke satu kolom (misalnya,`SUM(price)`) dan dibandingkan dengan literal numerik. Kondisi yang didukung adalah (`=, >, <, <=, >=, <>, !=`).  Operator logis yang didukung adalah (`AND, OR`). `having_expression`Itu opsional.  |  `HAVING SUM(SALES) > 500`  | 
| order\$1by\$1expression |  Daftar ekspresi yang dipisahkan koma yang kompatibel dengan persyaratan yang sama yang didefinisikan dalam `select_aggregate_expression` didefinisikan sebelumnya.  `order_by_expression`Itu opsional.  `order_by_expression`izin `ASC` dan `DESC` parameter. Untuk informasi selengkapnya, lihat parameter ASC DESC di Referensi [AWS Clean Rooms SQL](https://docs.aws.amazon.com/clean-rooms/latest/sql-reference/sql-reference.html).   |  `ORDER BY SUM(SALES), UPPER(campaignName)`  | 

Untuk struktur kueri agregasi dan sintaks, perhatikan hal berikut:
+ Perintah SQL selain SELECT tidak didukung.
+ Sub-kueri dan ekspresi tabel umum (misalnya,WITH) tidak didukung.
+ Operator yang menggabungkan beberapa kueri (misalnya,UNION) tidak didukung. 
+ TOP,LIMIT, dan OFFSET parameter tidak didukung.

## Aturan analisis agregasi - kontrol kueri
<a name="agg-query-controls"></a>

Dengan kontrol kueri agregasi, Anda dapat mengontrol bagaimana kolom dalam tabel Anda digunakan untuk menanyakan tabel. Misalnya, Anda dapat mengontrol kolom mana yang digunakan untuk bergabung, kolom mana yang dapat dihitung, atau kolom mana yang dapat digunakan dalam WHERE pernyataan.

Bagian berikut menjelaskan setiap kontrol.

**Topics**
+ [Kontrol agregasi](#agg-functions)
+ [Bergabunglah dengan kontrol](#join-controls)
+ [Kontrol dimensi](#dimension-controls)
+ [Fungsi skalar](#scalar-functions)

### Kontrol agregasi
<a name="agg-functions"></a>

Dengan menggunakan *kontrol agregasi*, Anda dapat menentukan fungsi agregasi mana yang akan diizinkan, dan kolom apa yang harus diterapkan. Fungsi agregasi dapat digunakan dalamSELECT,HAVING, dan ORDER BY ekspresi.


| Kontrol | Definisi | Penggunaan | 
| --- | --- | --- | 
| aggregateColumns | Kolom kolom tabel dikonfigurasi yang Anda izinkan untuk digunakan dalam fungsi agregasi. |  `aggregateColumns`dapat digunakan di dalam fungsi agregasi diSELECT,HAVING, dan ORDER BY ekspresi. Beberapa juga `aggregateColumns` dapat dikategorikan sebagai `joinColumn` (didefinisikan nanti). Diberikan tidak `aggregateColumn` dapat juga dikategorikan sebagai `dimensionColumn` (didefinisikan nanti).  | 
| function | Fungsi COUNT, SUM, dan AVG yang Anda izinkan untuk digunakan di atas. aggregateColumns |  `function`dapat diterapkan pada `aggregateColumns` yang terkait dengannya.   | 

### Bergabunglah dengan kontrol
<a name="join-controls"></a>

Sebuah `JOIN` klausa digunakan untuk menggabungkan baris dari dua atau lebih tabel, berdasarkan kolom terkait di antara mereka.

Anda dapat menggunakan *kontrol Gabung* untuk mengontrol bagaimana tabel Anda dapat digabungkan ke tabel lain di`table_expression`. AWS Clean Rooms hanya mendukung INNERJOIN. INNERJOINpernyataan hanya dapat menggunakan kolom yang telah dikategorikan secara eksplisit sebagai `joinColumn` aturan analisis Anda, tunduk pada kontrol yang Anda tentukan. 

INNERJOINHarus beroperasi pada `joinColumn` dari tabel yang dikonfigurasi dan `joinColumn` dari tabel lain yang dikonfigurasi dalam kolaborasi. Anda memutuskan kolom mana dari tabel Anda dapat digunakan sebagai`joinColumn`.

Setiap kondisi kecocokan dalam ON klausa diperlukan untuk menggunakan kondisi perbandingan kesetaraan (`=`) antara dua kolom. 

Beberapa kondisi pertandingan dalam suatu ON klausa dapat berupa: 
+ Dikombinasikan menggunakan operator `AND` logis
+ Dipisahkan menggunakan operator `OR` logis

**catatan**  
Semua kondisi JOIN pertandingan harus cocok dengan satu baris dari setiap sisiJOIN. Semua kondisional yang dihubungkan oleh `OR` atau operator `AND` logis harus mematuhi persyaratan ini juga.

Berikut ini adalah contoh dari query dengan operator `AND` logis.

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

Berikut ini adalah contoh dari query dengan operator `OR` logis.

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


| Kontrol | Definisi | Penggunaan | 
| --- | --- | --- | 
| joinColumns | Kolom (jika ada) yang ingin Anda izinkan anggota yang dapat kueri untuk digunakan dalam INNER JOIN pernyataan. |  Spesifik juga `joinColumn` dapat dikategorikan sebagai `aggregateColumn` (lihat[Kontrol agregasi](#agg-functions)). Kolom yang sama tidak dapat digunakan sebagai `joinColumn` dan `dimensionColumns` (lihat nanti). Kecuali itu juga telah dikategorikan sebagai`aggregateColumn`, a tidak `joinColumn` dapat digunakan di bagian lain dari kueri selain. INNER JOIN  | 
| joinRequired | Kontrol apakah Anda memerlukan tabel INNER JOIN yang dikonfigurasi dari anggota yang dapat melakukan kueri.  |  Jika Anda mengaktifkan parameter ini, INNER JOIN diperlukan. Jika Anda tidak mengaktifkan parameter ini, INNER JOIN adalah opsional. Dengan asumsi Anda mengaktifkan parameter ini, anggota yang dapat melakukan kueri diminta untuk menyertakan tabel yang mereka miliki di INNERJOIN. Mereka harus meja JOIN Anda dengan mereka, baik secara langsung atau transitif (yaitu, menggabungkan meja mereka ke meja lain, yang dengan sendirinya bergabung dengan meja Anda).  | 

Berikut ini adalah contoh transitivitas.

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

**catatan**  
Anggota yang dapat melakukan query juga dapat menggunakan `joinRequired` parameter. Dalam hal ini, kueri harus menggabungkan tabel mereka dengan setidaknya satu tabel lainnya. 

### Kontrol dimensi
<a name="dimension-controls"></a>

*Kontrol dimensi mengontrol* kolom di mana kolom agregasi dapat disaring, dikelompokkan, atau digabungkan.


| Kontrol | Definisi | Penggunaan | 
| --- | --- | --- | 
| dimensionColumns |  Kolom (jika ada) yang Anda izinkan anggota yang dapat kueri untuk digunakanSELECT,WHERE, GROUPBY, dan ORDERBY.  |  A `dimensionColumn` dapat digunakan dalam SELECT (`select_grouping_column_expression`),WHERE, GROUPBY, dan ORDERBY. Kolom yang sama tidak bisa berupa a`dimensionColumn`, a`joinColumn`, and/or an`aggregateColumn`.  | 

### Fungsi skalar
<a name="scalar-functions"></a>

Fungsi *skalar mengontrol fungsi* skalar mana yang dapat digunakan pada kolom dimensi.


| Kontrol | Definisi | Penggunaan | 
| --- | --- | --- | 
| scalarFunctions |  Fungsi skalar yang dapat digunakan `dimensionColumns` dalam kueri.  |  Menentukan fungsi skalar (jika ada) yang Anda izinkan (misalnya,CAST) untuk diterapkan pada. `dimensionColumns`  Fungsi skalar tidak dapat digunakan di atas fungsi lain atau di dalam fungsi lainnya. Argumen fungsi skalar dapat berupa kolom, literal string, atau literal numerik.  | 

Fungsi skalar berikut didukung:
+ Fungsi matematika - ABS, CEILING, FLOOR, LOG, LN, ROUND, SQRT
+ Fungsi pemformatan tipe data - CAST, CONVERT, TO\$1CHAR, TO\$1DATE, TO\$1NUMBER, TO\$1TIMESTAMP
+ Fungsi string - BAWAH, ATAS, TRIM, RTRIM, SUBSTRING
  + Untuk RTRIM, set karakter khusus untuk dipangkas tidak diperbolehkan. 
+ Ekspresi bersyarat - COALESCE
+ Fungsi tanggal - EXTRACT, GETDATE, CURRENT\$1DATE, DATEADD
+ Fungsi lainnya - TRUNC

Untuk detail selengkapnya, lihat [Referensi AWS Clean Rooms SQL](https://docs.aws.amazon.com/clean-rooms/latest/sql-reference/sql-reference.html).

## Aturan analisis agregasi - kontrol hasil kueri
<a name="agg-query-results-controls"></a>

Dengan kontrol hasil kueri agregasi, Anda dapat mengontrol hasil mana yang dikembalikan dengan menentukan satu atau beberapa kondisi yang harus dipenuhi oleh setiap baris keluaran agar dapat dikembalikan. AWS Clean Rooms mendukung kendala agregasi dalam bentuk. `COUNT (DISTINCT column) >= X` Formulir ini mengharuskan setiap baris menggabungkan setidaknya X nilai pilihan yang berbeda dari tabel Anda yang dikonfigurasi (misalnya, jumlah minimum `user_id` nilai yang berbeda). Ambang batas minimum ini secara otomatis diberlakukan, bahkan jika kueri yang dikirimkan itu sendiri tidak menggunakan kolom yang ditentukan. Mereka diberlakukan secara kolektif di setiap tabel yang dikonfigurasi dalam kueri dari tabel yang dikonfigurasi dari setiap anggota dalam kolaborasi. 

Setiap tabel yang dikonfigurasi harus memiliki setidaknya satu batasan agregasi dalam aturan analisisnya. Pemilik tabel yang dikonfigurasi dapat menambahkan beberapa `columnName` dan terkait `minimum` dan diberlakukan secara kolektif. 

### Kendala agregasi
<a name="agg-constraints"></a>

*Batasan agregasi* mengontrol baris mana dalam hasil kueri yang dikembalikan. Untuk dikembalikan, baris harus memenuhi jumlah minimum yang ditentukan dari nilai berbeda di setiap kolom yang ditentukan dalam batasan agregasi. Persyaratan ini berlaku bahkan jika kolom tidak disebutkan secara eksplisit dalam kueri atau di bagian lain dari aturan analisis.


| Kontrol | Definisi | Penggunaan | 
| --- | --- | --- | 
| columnName |  `aggregateColumn`Yang digunakan dalam kondisi bahwa setiap baris output harus memenuhi.  |  Dapat berupa kolom apa pun di tabel yang dikonfigurasi.  | 
| minimum |  Jumlah minimum nilai berbeda untuk yang terkait `aggregateColumn` yang harus dimiliki baris keluaran (misalnya, COUNT DISTINCT) agar dapat dikembalikan dalam hasil kueri.   |  `minimum`Harus minimal nilai 2.  | 

## Struktur aturan analisis agregasi
<a name="agg-analysis-rule-template"></a>

Contoh berikut menunjukkan struktur yang telah ditetapkan untuk aturan analisis agregasi. 

Dalam contoh berikut, *`MyTable`* mengacu pada tabel data Anda. Anda dapat mengganti masing-masing *user input placeholder* dengan informasi Anda sendiri. 

```
{
  "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] 
    },
  ]
}
```

## Aturan analisis agregasi - contoh
<a name="agg-analysis-rule-example"></a>

Contoh berikut menunjukkan bagaimana dua perusahaan dapat berkolaborasi dalam AWS Clean Rooms menggunakan analisis agregasi.

Perusahaan A memiliki data pelanggan dan penjualan. Perusahaan A tertarik untuk memahami aktivitas pengembalian produk. Perusahaan B adalah salah satu pengecer Perusahaan A dan memiliki data pengembalian. Perusahaan B juga memiliki atribut segmen pada pelanggan yang berguna bagi Perusahaan A (misalnya, membeli produk terkait, menggunakan layanan pelanggan dari pengecer). Perusahaan B tidak ingin memberikan data pengembalian pelanggan tingkat baris dan informasi atribut. Perusahaan B hanya ingin mengaktifkan serangkaian kueri untuk Perusahaan A untuk mendapatkan statistik agregat tentang pelanggan yang tumpang tindih pada ambang agregasi minimum. 

Perusahaan A dan Perusahaan B memutuskan untuk berkolaborasi sehingga Perusahaan A dapat memahami aktivitas pengembalian produk dan memberikan produk yang lebih baik di Perusahaan B dan saluran lainnya. 

Untuk membuat kolaborasi dan menjalankan analisis agregasi, perusahaan melakukan hal berikut: 

1. Perusahaan A menciptakan kolaborasi dan menciptakan keanggotaan. Kolaborasi ini menjadikan Perusahaan B sebagai anggota lain dalam kolaborasi tersebut. Perusahaan A memungkinkan pencatatan kueri dalam kolaborasi, dan memungkinkan pencatatan kueri di akun mereka. 

1. Perusahaan B menciptakan keanggotaan dalam kolaborasi. Ini memungkinkan pencatatan kueri di akunnya. 

1. Perusahaan A membuat tabel penjualan yang dikonfigurasi.

1. Perusahaan A menambahkan aturan analisis agregasi berikut ke tabel yang dikonfigurasi penjualan.

   ```
   {
     "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`Perusahaan A ingin menghitung jumlah pelanggan unik dalam tumpang tindih antara data penjualan dan data pengembalian. Perusahaan A juga ingin menjumlahkan jumlah yang `purchases` dibuat untuk dibandingkan dengan jumlah`returns`.

   `joinColumns`— Perusahaan A ingin menggunakan `identifier` untuk mencocokkan pelanggan dari data penjualan ke pelanggan dari data pengembalian. Ini akan membantu perusahaan A match kembali ke pembelian yang tepat. Ini juga membantu segmen Perusahaan A tumpang tindih pelanggan.

   `dimensionColumns`— Perusahaan A menggunakan `dimensionColumns` untuk memfilter berdasarkan produk tertentu, membandingkan pembelian dan pengembalian selama periode waktu tertentu, memastikan tanggal pengembalian setelah tanggal produk, dan membantu segmen pelanggan yang tumpang tindih. 

   `scalarFunctions`— Perusahaan A memilih fungsi `CAST` skalar untuk membantu memperbarui format tipe data jika diperlukan berdasarkan tabel yang dikonfigurasi Perusahaan A terkait dengan kolaborasi. Ini juga menambahkan fungsi skalar untuk membantu memformat kolom jika diperlukan. 

   `outputConstraints`— Perusahaan A menetapkan batasan output minimum. Tidak perlu membatasi hasil karena analis diizinkan untuk melihat data tingkat baris dari tabel penjualan mereka 
**catatan**  
Perusahaan A tidak termasuk `joinRequired` dalam aturan analisis. Ini memberikan fleksibilitas bagi analis mereka untuk menanyakan tabel penjualan saja.

1. Perusahaan B membuat tabel yang dikonfigurasi pengembalian.

1. Perusahaan B menambahkan aturan analisis agregasi berikut ke tabel pengembalian yang dikonfigurasi.

   ```
   {
     "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`— Perusahaan B memungkinkan Perusahaan A untuk menjumlahkan `returns` untuk dibandingkan dengan jumlah pembelian. Mereka memiliki setidaknya satu kolom agregat karena mereka mengaktifkan kueri agregat. 

   `joinColumns`— Perusahaan B memungkinkan Perusahaan A untuk bergabung `identifier` untuk mencocokkan pelanggan dari data pengembalian ke pelanggan dari data penjualan. `identifier`data sangat sensitif dan memilikinya sebagai `joinColumn` memastikan bahwa data tidak akan pernah dikeluarkan dalam kueri. 

   `joinRequired`— Perusahaan B membutuhkan kueri pada data pengembalian agar tumpang tindih dengan data penjualan. Mereka tidak ingin mengaktifkan Perusahaan A untuk menanyakan semua individu dalam kumpulan data mereka. Mereka juga menyetujui pembatasan itu dalam perjanjian kolaborasi mereka. 

   `dimensionColumns`— Perusahaan B memungkinkan Perusahaan A untuk memfilter dan mengelompokkan berdasarkan `state``popularpurchases`,, dan `customerserviceuser` yang merupakan atribut unik yang dapat membantu membuat analisis untuk Perusahaan A. Perusahaan B memungkinkan Perusahaan A untuk menggunakan `returndate` untuk menyaring output pada `returndate` yang terjadi setelahnya`purchasedate`. Dengan penyaringan ini, output lebih akurat untuk mengevaluasi dampak perubahan produk. 

   `scalarFunctions`— Perusahaan B memungkinkan hal-hal berikut: 
   + TRUNC untuk tanggal
   + LOWER dan UPPER jika `producttype` dimasukkan dalam format yang berbeda dalam data mereka
   + CASTjika Perusahaan A perlu mengonversi tipe data dalam penjualan agar sama dengan tipe data dalam pengembalian

   Perusahaan A tidak mengaktifkan fungsi skalar lainnya karena mereka tidak percaya bahwa mereka diperlukan untuk kueri.

   `outputConstraints`Perusahaan B menetapkan batasan output minimum `hashedemail` untuk membantu mengurangi kemampuan untuk mengidentifikasi kembali pelanggan. Ini juga menambahkan kendala keluaran minimum `producttype` untuk mengurangi kemampuan mengidentifikasi kembali produk tertentu yang dikembalikan. Jenis produk tertentu bisa lebih dominan berdasarkan dimensi output (misalnya,`state`). Kendala output mereka akan selalu diberlakukan terlepas dari kendala output yang ditambahkan oleh Perusahaan A ke data mereka. 

1. Perusahaan A menciptakan asosiasi tabel penjualan untuk kolaborasi.

1. Perusahaan B menciptakan asosiasi tabel pengembalian untuk kolaborasi.

1. Perusahaan A menjalankan kueri, seperti contoh berikut, untuk lebih memahami jumlah pengembalian di Perusahaan B dibandingkan dengan total pembelian berdasarkan lokasi pada tahun 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;
   ```

1. Perusahaan A dan Perusahaan B meninjau log kueri. Perusahaan B memverifikasi bahwa kueri sejalan dengan apa yang disepakati dalam perjanjian kolaborasi. 

## Memecahkan masalah aturan analisis agregasi
<a name="troubleshooting-agg-analysis-rule"></a>

Gunakan informasi di sini untuk membantu Anda mendiagnosis dan memperbaiki masalah umum saat Anda bekerja dengan aturan analisis agregasi. 

**Topics**
+ [Kueri saya tidak mengembalikan hasil apa pun](#query-no-results)

### Kueri saya tidak mengembalikan hasil apa pun
<a name="query-no-results"></a>

Hal ini dapat terjadi ketika tidak ada hasil yang cocok atau ketika hasil yang cocok tidak memenuhi satu atau lebih ambang agregasi minimum. 

Untuk informasi selengkapnya tentang ambang agregasi minimum, lihat. [Aturan analisis agregasi - contoh](#agg-analysis-rule-example)