Snowflake Data Clean Rooms: modelos baseados em Python seguro¶

Configuração do ambiente¶

Execute os seguintes comandos para configurar o ambiente Snowflake antes de usar as APIs de desenvolvedor para trabalhar com uma Snowflake Data Clean Room. Se você não tem a função SAMOOHA_APP_ROLE, entre em contato com o administrador da sua conta.

use role samooha_app_role;
use warehouse app_wh;

Crie a sala limpa¶

Crie um nome para a sala limpa. Insira um novo nome de salas limpas para evitar colisões com nomes de salas limpas. Observe que os nomes das salas limpas só podem conter caracteres alfanuméricos. Os nomes das salas limpas não podem conter caracteres especiais além de espaços e sublinhados.

set cleanroom_name = 'Custom Secure Python UDF Demo clean room';

Você pode criar uma nova sala limpa com o nome de sala limpa definido acima. Se o nome da sala limpa definido acima já existir como uma sala limpa, este processo falhará.

Este procedimento leva aproximadamente 45 segundos para ser executado.

O segundo argumento para provider.cleanroom_init é a distribuição da sala limpa. Ele pode ser INTERNAL ou EXTERNAL. Para fins de teste, se você estiver compartilhando a sala limpa com uma conta na mesma organização, você pode usar INTERNAL para ignorar a verificação de segurança automatizada que deve ocorrer antes que um pacote de aplicativo seja liberado aos colaboradores. No entanto, se você estiver compartilhando esta sala limpa com uma conta em uma organização diferente, você deve usar uma distribuição de sala limpa EXTERNAL.

call samooha_by_snowflake_local_db.provider.cleanroom_init($cleanroom_name, 'INTERNAL');

Para visualizar o status da verificação de segurança, use:

call samooha_by_snowflake_local_db.provider.view_cleanroom_scan_status($cleanroom_name);

Após criar sua sala limpa, você deve definir sua diretiva de lançamento para que ela possa ser compartilhada com qualquer colaborador. No entanto, se sua distribuição tiver sido definida como EXTERNAL, você deverá primeiro aguardar a conclusão da verificação de segurança antes de definir a diretiva de lançamento. Você pode continuar executando o restante das etapas enquanto a verificação é executada e retornar aqui antes da etapa provider.create_cleanroom_listing.

Para definir a diretiva de lançamento, chame:

call samooha_by_snowflake_local_db.provider.set_default_release_directive($cleanroom_name, 'V1_0', '0');

Compartilhamento entre regiões¶

Para compartilhar uma sala limpa com um cliente Snowflake cuja conta está em uma região diferente da sua conta, você deve habilitar o Preenchimento automático entre nuvens. Para obter mais informações sobre os custos adicionais associados à colaboração com consumidores em outras regiões, consulte Custos de preenchimento automático entre nuvens.

Ao usar as APIs de desenvolvedor, o processo para habilitar o compartilhamento entre regiões ocorre em duas etapas.

1. Um administrador Snowflake com a função ACCOUNTADMIN habilita o preenchimento automático entre nuvens para sua conta Snowflake. Para obter instruções, consulte Colaboração com contas em diferentes regiões.

2. Execute o comando provider.enable_laf_for_cleanroom para habilitar o preenchimento automático entre nuvens para a sala limpa. Por exemplo:

   call samooha_by_snowflake_local_db.provider.enable_laf_for_cleanroom($cleanroom_name);
   

   Copy

Após habilitar o preenchimento automático entre nuvens para a sala limpa, você pode adicionar consumidores à sua listagem normalmente usando o comando provider.create_cleanroom_listing. A listagem é replicada automaticamente para nuvens e regiões remotas, conforme necessário.

Vincule o conjunto de dados e defina a política de junção para o conjunto de dados¶

Conecte as tabelas Snowflake à sala limpa. Navegue pela lista de tabelas em sua conta Snowflake e insira os nomes de tabela totalmente qualificados (Database.Schema.Table) como uma matriz. O procedimento torna a tabela automaticamente acessível à sala limpa, criando uma exibição segura da tabela de dentro da sala limpa, evitando assim a necessidade de fazer uma cópia da tabela.

call samooha_by_snowflake_local_db.provider.link_datasets($cleanroom_name, [ 'SAMOOHA_SAMPLE_DATABASE.DEMO.CUSTOMERS']);

use role accountadmin;
call samooha_by_snowflake_local_db.provider.register_db('<DATABASE_NAME>');
use role samooha_app_role;

Você pode ver os conjuntos de dados vinculados à sala limpa usando o seguinte procedimento:

call samooha_by_snowflake_local_db.provider.view_provider_datasets($cleanroom_name);

Para descobrir quais colunas usar como política de junção, você pode analisar seu conjunto de dados para determinar as colunas PII. Para ver as 10 principais linhas, use esta consulta:

select * from SAMOOHA_SAMPLE_DATABASE.DEMO.CUSTOMERS limit 10;

Especifique em quais colunas o consumidor tem permissão para unir ao executar modelos na sala limpa. Este procedimento deve ser chamado em colunas de identidade como e-mail. A política de junção é “somente substituição”, portanto, se a função for chamada novamente, a política de junção definida anteriormente será completamente substituída pela nova.

call samooha_by_snowflake_local_db.provider.set_join_policy($cleanroom_name, ['SAMOOHA_SAMPLE_DATABASE.DEMO.CUSTOMERS:HEM']);

Se você quiser visualizar a política de junção adicionada à sala limpa, chame o procedimento a seguir.

call samooha_by_snowflake_local_db.provider.view_join_policy($cleanroom_name);

Carregamento confidencial do código Python personalizado como UDFs para a sala limpa¶

Esta seção mostra como carregar as seguintes funções Python na sala limpa.

• assign_group -> uma UDF que atribui um ID de grupo linha por linha.

• group_agg -> uma UDF que agrupa por ID e agrega um aspecto dos dados.

A API a seguir permite definir suas funções Python diretamente como funções em linha na sala limpa. Como alternativa, você pode carregar o código Python a partir de arquivos preparados que você enviou para o estágio da sala limpa. Consulte o Guia de referência da API para um exemplo.

O código a seguir define e carrega a UDF assign_group que atribui um ID de grupo linha por linha:

call samooha_by_snowflake_local_db.provider.load_python_into_cleanroom(
    $cleanroom_name, 
    'assign_group',                      -- Name of the UDF
    ['data variant', 'index integer'],   -- Arguments of the UDF, specified as (variable name, variable type)
    ['numpy', 'pandas'],                 -- Packages UDF will use
    'integer',                           -- Return type of UDF
    'main',                              -- Handler
    $$
import numpy as np
import pandas as pd

def main(data, index):
    df = pd.DataFrame(data) # Just as an example of what we could do
    np.random.seed(0)
    
    # First let's combine the data row and the additional index into a string
    data.append(index)
    data_string = ",".join(str(d) for d in data)

    # Hash it 
    encoded_data_string = data_string.encode()
    hashed_string = hash(encoded_data_string)

    # Return the hashed string
    return hashed_string
    $$
);

O código a seguir define e carrega a UDF group_agg que agrupa por ID e agrega um aspecto dos dados:

call samooha_by_snowflake_local_db.provider.load_python_into_cleanroom(
    $cleanroom_name, 
    'group_agg',              -- Name of the UDF
    ['data variant'],         -- Arguments of the UDF, specified as (variable name, variable type)
    ['pandas'],               -- Packages UDF will use
    'integer',                -- Return type of UDF
    'main',                   -- Handler
    $$
import pandas as pd

def main(s):
    s = pd.Series(s)
    return (s == 'SILVER').sum()
    $$
);

-- See the versions available inside the clean room
show versions in application package samooha_cleanroom_Custom_Secure_Python_UDF_Demo_clean_room;

-- Once the security scan is approved, update the release directive to the latest version
call samooha_by_snowflake_local_db.provider.set_default_release_directive($cleanroom_name, 'V1_0', '2');

Carregamento de código Python de arquivos Python em um estágio¶

Como alternativa à definição, você pode carregar o Python de arquivos .py em um estágio. Para fazer isso, você deve carregar seu código no estágio de código da sala limpa. É importante ressaltar que somente os arquivos no estágio de código da sala limpa estão disponíveis para uso na sala limpa, portanto seus arquivos não podem ser localizados em outro lugar. Os arquivos devem estar no seguinte estágio:

ls @samooha_cleanroom_Custom_Secure_Python_UDF_Demo_clean_room.app.code;

Para definir as UDFs assign_group e group_agg dessa forma, você pode carregar os seguintes scripts no estágio de sala limpa:

Crie um arquivo em seu diretório inicial chamado ~/assign_group.py e cole o seguinte código:

import numpy as np
import pandas as pd


def main(data, index):
    _ = pd.DataFrame(data)  # Just as an example of what we could do
    np.random.seed(0)

    # First let's combine the data row and the additional index into a string
    data.append(index)
    data_string = ",".join(str(d) for d in data)

    # Hash it
    encoded_data_string = data_string.encode()
    hashed_string = hash(encoded_data_string)

    # Return the hashed string
    return hashed_string

Agora, você precisa carregar o código para o estágio de sala limpa. Faça isso adicionando-o à pasta que contém a versão dos arquivos do aplicativo de sala limpa publicada no momento. Para obter a pasta necessária, você pode usar o seguinte procedimento:

call samooha_by_snowflake_local_db.provider.get_stage_for_python_files($cleanroom_name);

Isso lhe fornece o estágio para enviar este arquivo. Você pode carregar este arquivo no estágio usando o seguinte comando do snowsql:

PUT file://~/assign_group.py @samooha_cleanroom_Custom_Secure_Python_UDF_Demo_clean_room.app.code/V1_0P1/test_folder overwrite=True auto_compress=False;

Por fim, você pode carregar o Python na sala limpa usando o seguinte comando:

call samooha_by_snowflake_local_db.provider.load_python_into_cleanroom(
    $cleanroom_name,
    'assign_group',                      // Name of the UDF
    ['data variant', 'index integer'],   // Arguments of the UDF, specified as (variable name, variable type)
    ['numpy', 'pandas'],                 // Packages UDF will use
    ['/test_folder/assign_group.py'],                // Name of Python file to import, relative to stage folder uploaded to
    'integer',                           // Return type of UDF
    'assign_group.main'                  // Handler - now scoped to file
);

De maneira semelhante, você pode criar um arquivo chamado ~/group_agg.py com o seguinte código:

import pandas as pd


def main(s):
    s = pd.Series(s)
    return (s == "SILVER").sum()

A pasta para a qual ele precisa ser carregado agora terá sido alterada desde que a última chamada para load_python_into_cleanroom tenha adicionado um patch à sala limpa. A nova pasta pode ser obtida executando novamente o seguinte comando:

call samooha_by_snowflake_local_db.provider.get_stage_for_python_files($cleanroom_name);

O arquivo pode então ser carregado na pasta apropriada:

PUT file://~/group_agg.py @samooha_cleanroom_Custom_Secure_Python_UDF_Demo_clean_room.app.code/V1_0P2 overwrite=True auto_compress=False;

Uma vez carregado, a UDF em Python pode ser criada a partir deste arquivo usando o seguinte comando:

call samooha_by_snowflake_local_db.provider.load_python_into_cleanroom(
    $cleanroom_name,
    'group_agg',                         // Name of the UDF
    ['data variant'],                    // Arguments of the UDF, specified as (variable name, variable type)
    ['pandas'],                          // Packages UDF will use
    ['/group_agg.py'],                   // Name of Python file to import, relative to stage folder uploaded to
    'integer',                           // Return type of UDF
    'group_agg.main'                     // Handler - now scoped to file
);

Como adicionar um modelo personalizado usando UDFs¶

Para adicionar um modelo de análise personalizado à sala limpa, você precisa de um espaço reservado para nomes de tabelas no lado do provedor e do consumidor, juntamente com colunas de junção do lado do provedor. Nos modelos SQL Jinja, esses espaços reservados devem ser sempre:

• source_table: uma matriz de nomes de tabela do provedor

• my_table: uma matriz de nomes de tabela do consumidor

Os nomes das tabelas podem ser tornados dinâmicos por meio do uso dessas variáveis, mas também podem ser embutidos em código no modelo, se desejado, usando o nome da visualização vinculada à sala limpa. Os nomes das colunas podem ser embutidos em código no modelo, se desejado, ou definidos dinamicamente por meio de parâmetros. Se eles forem definidos por meio de parâmetros, lembre-se de que você precisa chamar os parâmetros dimensions ou measure_column, que precisam ser matrizes para que sejam verificados em relação à política de coluna. Você adiciona estes como parâmetros SQL Jinja no modelo que serão passados posteriormente pelo consumidor durante a consulta. As políticas de junção garantem que o consumidor não possa ingressar em colunas não autorizadas.

Alternativamente, qualquer argumento em um modelo SQL Jinja personalizado pode ser verificado quanto à conformidade com as políticas de junção e coluna usando os seguintes filtros:

• join_policy: verifica se um valor de cadeia de caracteres ou cláusula de filtro está em conformidade com a política de junção

• column_policy: verifica se um valor de cadeia de caracteres ou cláusula de filtro está em conformidade com a política de coluna

• join_and_column_policy: verifica se as colunas usadas para uma junção em uma cláusula de filtro estão em conformidade com a política de junção e se as colunas usadas como um filtro estão em conformidade com a política de coluna

Por exemplo, na cláusula {{ provider_id | sqlsafe | join_policy }}, uma entrada de p.HEM será analisada para verificar se p.HEM está na política de junção. Nota: Use o filtro sqlsafe com cautela, pois ele permite que os colaboradores coloquem SQL puro no modelo.

Observe que esta função substitui qualquer modelo existente com o mesmo nome. Se quiser atualizar qualquer modelo existente, basta chamar esta função novamente com o modelo atualizado.

Este modelo primeiro enriquece os dados do provedor com um hash de uma série de colunas da tabela do provedor. Esses dados enriquecidos são então unidos internamente ao conjunto de dados do consumidor no e-mail, com uma cláusula de filtro opcional passada. Finalmente, a UDF grupo_agg em Python personalizada é usada para calcular alguma agregação como uma função das colunas com hash da primeira UDF.

call samooha_by_snowflake_local_db.provider.add_custom_sql_template(
    $cleanroom_name, 
    'prod_custom_udf_template', 
    $$
with enriched_provider_data as (
    select 
        cleanroom.assign_group(array_construct(identifier({{ filter_column | column_policy }}), identifier({{ dimensions[0] | column_policy }})), identifier({{ measure_column[0] | column_policy }})) as groupid,
        {{ filter_column | sqlsafe }},
        hem
    from identifier({{ source_table[0] }}) p
), filtered_data as (
    select 
        groupid,
        identifier({{ filter_column | column_policy }})
    from enriched_provider_data p
    inner join identifier({{ my_table[0] }}) c
    on p.hem = c.hem
    {% if where_clause %}
    where {{ where_clause | sqlsafe }}
    {% endif %}
)
select groupid, cleanroom.group_agg(array_agg({{ filter_column | sqlsafe }})) as count from filtered_data p
group by groupid;
    $$
);

Se quiser visualizar os modelos atualmente ativos na sala limpa, chame o procedimento a seguir.

call samooha_by_snowflake_local_db.provider.view_added_templates($cleanroom_name);

Definição da política de coluna em cada tabela¶

Visualize os dados vinculados para ver as colunas presentes na tabela. Para exibir as 10 primeiras linhas, chame o procedimento a seguir.

select * from SAMOOHA_SAMPLE_DATABASE.DEMO.CUSTOMERS limit 10;

Defina as colunas que o consumidor pode agrupar, agregar (por exemplo SUM/AVG) e geralmente usa em uma análise para cada combinação de tabela e modelo. Isso proporciona flexibilidade para que a mesma tabela possa permitir diferentes seleções de colunas, dependendo do modelo subjacente. Isso só deve ser chamado depois que o modelo for adicionado.

Observe que a política de coluna é somente substituição, portanto, se a função for chamada novamente, a política de coluna definida anteriormente será completamente substituída pela nova.

A política de coluna não deve ser usada em colunas de identidade como e-mail, HEM, RampID etc., já que você não quer que o consumidor seja capaz de agrupar por essas colunas. No ambiente de produção, o sistema irá inferir de forma inteligente as colunas PII e bloquear esta operação, mas esse recurso não está disponível no ambiente sandbox. Ele só deve ser usado em colunas que você deseja que o consumidor possa agregar e agrupar, como Status, Faixa etária, Código de região, Dias ativos etc.

Observe que para que “column_policy” e “join_policy” realizem verificações nas solicitações de análise do consumidor, todos os nomes de colunas DEVEM ser referidos como dimensions ou measure_columns no modelo SQL Jinja. Certifique-se de usar essas tags para se referir às colunas que deseja verificar nos modelos de SQL Jinja personalizados.

call samooha_by_snowflake_local_db.provider.set_column_policy($cleanroom_name, [
    'prod_custom_udf_template:SAMOOHA_SAMPLE_DATABASE.DEMO.CUSTOMERS:STATUS', 
    'prod_custom_udf_template:SAMOOHA_SAMPLE_DATABASE.DEMO.CUSTOMERS:REGION_CODE',
    'prod_custom_udf_template:SAMOOHA_SAMPLE_DATABASE.DEMO.CUSTOMERS:AGE_BAND',
    'prod_custom_udf_template:SAMOOHA_SAMPLE_DATABASE.DEMO.CUSTOMERS:DAYS_ACTIVE']);

Se você quiser visualizar a política de coluna adicionada à sala limpa, chame o procedimento a seguir.

call samooha_by_snowflake_local_db.provider.view_column_policy($cleanroom_name);

Compartilhamento com um consumidor¶

Por fim, adicione um consumidor de dados à sala limpa adicionando o localizador de conta Snowflake e os nomes de conta, conforme mostrado abaixo. O nome da conta Snowflake deve ter o formato <ORGANIZATION>.<ACCOUNT_NAME>.

show versions in application package samooha_cleanroom_Custom_Secure_Python_UDF_Demo_clean_room;

call samooha_by_snowflake_local_db.provider.add_consumers($cleanroom_name, '<CONSMUMER_ACCOUNT_LOCATOR>');

Vários localizadores de contas de consumidores podem ser passados para a função provider.add_consumers como uma cadeia de caracteres separada por vírgulas ou como chamadas separadas para provider.add_consumers.

Se quiser visualizar os consumidores adicionados a esta sala limpa, chame o procedimento a seguir.

call samooha_by_snowflake_local_db.provider.view_consumers($cleanroom_name);

Veja as salas limpas que foram criadas recentemente por meio do seguinte procedimento:

call samooha_by_snowflake_local_db.provider.view_cleanrooms();

Veja mais informações sobre a sala limpa criada recentemente por meio do procedimento a seguir.

call samooha_by_snowflake_local_db.provider.describe_cleanroom($cleanroom_name);

Qualquer sala limpa criada também pode ser excluída. O comando a seguir descarta a sala limpa completamente, de modo que qualquer consumidor que antes tivesse acesso à sala não poderá mais usá-la. Se uma sala limpa com o mesmo nome for desejada no futuro, ela deverá ser reinicializada usando o fluxo acima.

call samooha_by_snowflake_local_db.provider.drop_cleanroom($cleanroom_name);

Configuração do ambiente¶

Execute os seguintes comandos para configurar o ambiente Snowflake antes de usar as APIs de desenvolvedor para trabalhar com uma Snowflake Data Clean Room. Se você não tem a função SAMOOHA_APP_ROLE, entre em contato com o administrador da sua conta.

use role samooha_app_role;
use warehouse app_wh;

Instalação da sala limpa¶

Depois que um compartilhamento de sala limpa for instalado, a lista de salas limpas disponíveis poderá ser visualizada usando o comando abaixo.

call samooha_by_snowflake_local_db.consumer.view_cleanrooms();

Atribua um nome para a sala limpa que o provedor compartilhou com você.

set cleanroom_name = 'Custom Secure Python UDF Demo clean room';

O comando a seguir instala a sala limpa na conta do consumidor com o provedor associado e a sala limpa selecionada.

Este procedimento leva aproximadamente 45 segundos para ser executado.

call samooha_by_snowflake_local_db.consumer.install_cleanroom($cleanroom_name, '<PROVIDER_ACCOUNT_LOCATOR>');

Após a instalação da sala limpa, o provedor precisa terminar de configurá-la do seu lado antes que ela seja habilitada para uso. A função abaixo permite que você verifique o status da sala limpa. Depois que ela for habilitada, você poderá executar o comando Run Analysis abaixo. Normalmente, leva cerca de 1 minuto para que a sala limpa seja habilitada.

call samooha_by_snowflake_local_db.consumer.is_enabled($cleanroom_name);

Vincule o conjunto de dados¶

Vincule conjuntos de dados à sala limpa para realizar cálculos seguros com os dados do provedor.

call samooha_by_snowflake_local_db.consumer.link_datasets($cleanroom_name, ['SAMOOHA_SAMPLE_DATABASE.DEMO.CUSTOMERS']);

use role accountadmin;
call samooha_by_snowflake_local_db.consumer.register_db('<DATABASE_NAME>');
use role samooha_app_role;

Para executar a análise, você precisa passar a tabela do consumidor. Se quiser visualizar os conjuntos de dados que adicionou à sala limpa, chame o procedimento a seguir.

call samooha_by_snowflake_local_db.consumer.view_consumer_datasets($cleanroom_name);

Execute a análise¶

Agora que a sala limpa está instalada, você pode executar o modelo de análise fornecido à sala limpa pelo provedor usando o comando “run_analysis”. Você pode ver como cada campo é determinado nas seções abaixo.

O número de conjuntos de dados que podem ser transmitidos é limitado pelo modelo implementado pelo provedor. Alguns modelos exigem um número específico de tabelas. O criador do modelo pode implementar os requisitos que deseja atender.

call samooha_by_snowflake_local_db.consumer.run_analysis(
  $cleanroom_name,               -- cleanroom
  'prod_custom_udf_template',    -- template name

  ['SAMOOHA_SAMPLE_DATABASE.DEMO.CUSTOMERS'],    -- consumer tables

  ['SAMOOHA_SAMPLE_DATABASE.DEMO.CUSTOMERS'],     -- provider tables

  object_construct(    -- Rest of the custom arguments needed for the template
    'filter_column', 'p.status',            -- One of the SQL Jinja arguments, the column the UDF filters on

    'dimensions', ['p.DAYS_ACTIVE'],
    
    'measure_column', ['p.AGE_BAND'],

    'where_clause', 'c.status = $$GOLD$$'   -- A boolean filter applied to the data
  )
);

Para cada uma das colunas referenciadas na filtragem do conjunto de dados “where_clause” ou dimensions ou measure_columns, você pode usar p. para consultar campos nas tabelas do provedor e c. para consultar campos nas tabelas do consumidor. Use p2, p3 etc. para mais de uma tabela de provedores e c2, c3 etc. para mais de uma tabela de consumidores.

Como determinar as entradas para run_analysis¶

Para executar a análise, você precisa passar alguns parâmetros à função run_analysis. Esta seção mostrará como determinar quais parâmetros devem ser passados.

Nomes dos modelos

Primeiro, você pode ver os modelos de análise compatíveis chamando o procedimento a seguir.

call samooha_by_snowflake_local_db.consumer.view_added_templates($cleanroom_name);

Antes de executar uma análise com um modelo, você precisa saber quais argumentos especificar e quais tipos são esperados. Para modelos personalizados, você pode executar o seguinte.

call samooha_by_snowflake_local_db.consumer.view_template_definition($cleanroom_name, 'prod_custom_udf_template');

Isso geralmente também pode conter um grande número de diferentes parâmetros SQL Jinja. A funcionalidade a seguir analisa o modelo SQL Jinja e extrai os argumentos que precisam ser especificados em run_analysis organizando-os em uma lista conveniente.

call samooha_by_snowflake_local_db.consumer.get_arguments_from_template($cleanroom_name, 'prod_custom_udf_template');

Nomes dos conjuntos de dados

Se você quiser visualizar os nomes dos conjuntos de dados adicionados à sala limpa pelo provedor, chame o procedimento a seguir. Observe que você não pode visualizar os dados presentes nos conjuntos de dados adicionados à sala limpa pelo provedor devido às propriedades de segurança da sala limpa.

call samooha_by_snowflake_local_db.consumer.view_provider_datasets($cleanroom_name);

Você também pode ver as tabelas vinculadas à sala limpa usando a seguinte chamada:

call samooha_by_snowflake_local_db.consumer.view_consumer_datasets($cleanroom_name);

Colunas de dimensão e medida

Ao executar a análise, você pode querer filtrar, agrupar e agregar em determinadas colunas. Se você quiser visualizar a política de coluna adicionada à sala limpa pelo provedor, chame o procedimento a seguir.

call samooha_by_snowflake_local_db.consumer.view_provider_column_policy($cleanroom_name);

Erros comuns

Se você estiver recebendo o erro Não aprovado: colunas não autorizadas usadas como resultado da análise de execução, talvez seja necessário visualizar novamente a política de junção e a política de coluna definidas pelo provedor.

call samooha_by_snowflake_local_db.consumer.view_provider_join_policy($cleanroom_name);
call samooha_by_snowflake_local_db.consumer.view_provider_column_policy($cleanroom_name);

Também é possível que você tenha esgotado seu orçamento de privacidade, o que o impedirá de executar mais consultas. Seu orçamento de privacidade restante pode ser visualizado usando o comando abaixo. Ele é redefinido diariamente, mas o provedor de sala limpa pode redefini-lo, se quiser.

call samooha_by_snowflake_local_db.consumer.view_remaining_privacy_budget($cleanroom_name);

Você pode verificar se a privacidade diferencial foi habilitada para sua sala limpa usando a seguinte API:

call samooha_by_snowflake_local_db.consumer.is_dp_enabled($cleanroom_name);