Snowflake Data Clean Rooms: aprendizado de máquina¶

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 dos salas limpas só podem ser alfanuméricos. Os nomes de salas limpas não podem conter caracteres especiais além de espaços e sublinhados.

set cleanroom_name = 'Machine Learning 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, esse processo falhará.

Este procedimento pode demorar um pouco mais para ser executado, normalmente cerca de meio minuto.

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 e retornar aqui antes da etapa provider.create_cleanroom_listing enquanto a verificação é executada.

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¶

Vincule as tabelas do 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_provider_sample_database.lookalike_modeling.customers']);

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

Você pode visualizar os nomes dos conjuntos de dados vinculados à sala limpa chamando o procedimento a seguir.

call samooha_by_snowflake_local_db.provider.view_provider_datasets($cleanroom_name);

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

select * from samooha_provider_sample_database.lookalike_modeling.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_provider_sample_database.lookalike_modeling.customers:hashed_email']);

Se quiser visualizar todas as colunas para escolher as colunas de política de junção, chame o procedimento a seguir.

call samooha_by_snowflake_local_db.provider.view_join_policy($cleanroom_name);

Como adicionar código Python confidencial de aprendizado de máquina à sala limpa¶

Esta seção mostra como carregar algumas funções Python para a sala limpa para o trabalho de ML semelhante. Todas as funções Python instaladas na sala limpa permanecem completamente confidenciais. Elas não podem ser vistas pelo consumidor.

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.

call samooha_by_snowflake_local_db.provider.load_python_into_cleanroom(
    $cleanroom_name, 
    'lookalike_train',
    ['input_data variant', 'labels variant'],
    ['pandas', 'numpy', 'xgboost'],
    'variant',
    'train',
    $$
import numpy as np
import pandas as pd
import xgboost
from sklearn import preprocessing
import sys
import os
import pickle
import codecs
import threading


class TrainXGBoostClassifier(object):
    def __init__(self):
        self.model = None
        self._params = {
            "objective": "binary:logistic",
            "max_depth": 3,
            "nthread": 1,
            "eval_metric": "auc",
        }
        self.num_boosting_rounds = 10

    def get_params(self):
        if self.model is not None and "updater" not in self._params:
            self._params.update(
                {"process_type": "update", "updater": "refresh", "refresh_leaf": True}
            )
        return self._params

    def train(self, X, y):
        """
        Train the model in a threadsafe way
        """
        # pick only the categorical attributes
        categorical = X.select_dtypes(include=[object])

        # fit a one-hot-encoder to convert categorical features to binary features (required by XGBoost)
        ohe = preprocessing.OneHotEncoder()
        categorical_ohe = ohe.fit_transform(categorical)
        self.ohe = ohe

        # get the rest of the features and add them to the binary features
        non_categorical = X.select_dtypes(exclude=[object])
        train_x = np.concatenate((categorical_ohe.toarray(), non_categorical.to_numpy()), axis=1)

        xg_train = xgboost.DMatrix(train_x, label=y)

        params = self.get_params()
        params["eval_metric"] = "auc"
        evallist = [(xg_train, "train")]
        evals_result = {}

        self.model = xgboost.train(
            params, xg_train, self.num_boosting_rounds, evallist, evals_result=evals_result
        )

        self.evals_result = evals_result

    def __dump_model(self, model):
        """
        Save down the model as a json string to load up for scoring/inference
        """
        pickle_jar = codecs.encode(pickle.dumps([model, self.ohe]), "base64").decode()
        return pickle_jar

    def dump_model(self):
        """
        Save down the model as a json string to load up for scoring/inference
        """
        if self.model is not None:
            return self.__dump_model(self.model)
        else:
            raise ValueError("Model needs to be trained first")


def train(d1, l1):

    # get take training features and put them in a pandas dataframe
    X = pd.DataFrame(d1)

    # get the labels into a Numpy array
    y = np.array(l1)

    trainer = TrainXGBoostClassifier()
    trainer.train(X, y)

    # return training stats, accuracy, and the pickled model and pickled one-hot-encoder
    return {
        "total_rows": len(d1),
        "total_bytes_in": sys.getsizeof(d1),
        "model": trainer.dump_model(),
        "iteration": trainer.num_boosting_rounds,
        "auc": np.max(trainer.evals_result["train"]["auc"]),
        "error": 1 - np.max(trainer.evals_result["train"]["auc"])
    }    
    $$
);

Agora vamos instalar uma função de pontuação na sala limpa.

call samooha_by_snowflake_local_db.provider.load_python_into_cleanroom(
    $cleanroom_name, 
    'lookalike_score',
    ['pickle_jar variant', 'emails variant', 'features variant'],
    ['pandas', 'numpy', 'xgboost', 'scikit-learn'],
    'string',
    'score',
    $$
import numpy as np
import pandas as pd
import xgboost as xgb
import pickle
import codecs
import json


def score(model, emails, features):
    # load model
    model = model[0] if not isinstance(model, str) else model
    model = pickle.loads(codecs.decode(model.encode(), "base64"))

    # retrieve the XGBoost trainer from the pickle jar
    bst = model[0]

    # retrieve the fitted one-hot-encoder from the pickle jar
    ohe2 = model[1]

    # create pandas dataframe from the inference features
    Y = pd.DataFrame(features)

    # select the categorical attributes and one-hot-encode them
    Y1 = Y.select_dtypes(include=[object])
    Y2 = ohe2.transform(Y1)

    # select the non-categorical attributes
    Y3 = Y.select_dtypes(exclude=[object])

    # join the results of the one-hot encoding to the rest of the attributes
    Y_pred = np.concatenate((Y2.toarray(), Y3.to_numpy()), axis=1)

    # inference
    dscore = xgb.DMatrix(Y_pred)
    pred = bst.predict(dscore)

    retval = list(zip(np.array(emails), list(map(str, pred))))
    retval = [{"email": r[0], "score": r[1]} for r in retval]
    return json.dumps(retval)  
    $$
);

-- See the versions available inside the cleanroom
show versions in application package samooha_cleanroom_Machine_Learning_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');

Como adicionar um modelo de modelagem semelhante personalizado¶

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 de tabela 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 exibiçã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. Observação: use o filtro sqlsafe apenas com cautela, visto que 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.

Um conjunto de recursos é selecionado do conjunto de dados do provedor e um conjunto de rótulos é selecionado do conjunto de dados do consumidor, juntamente com um sinalizador de “alto valor” (chamado label_value). Essas duas tabelas são então unidas internamente por e-mail e passadas ao algoritmo de treinamento de floresta aleatória. Por fim, a saída da etapa de treinamento do modelo é passada para uma função de inferência, que usa o modelo treinado para “inferir” quais clientes do provedor que NOT estão nos conjuntos de dados do consumidor poderiam ser de “alto valor”. A contagem desses indivíduos é então retornada, juntamente com o erro do modelo.

O limite para determinar a pontuação além da qual um cliente é “provavelmente de alto valor” é definido manualmente no modelo como 0,5. Isso pode ser facilmente alterado ao adicionar o modelo à sala limpa.

call samooha_by_snowflake_local_db.provider.add_custom_sql_template(
    $cleanroom_name, 
    'prod_custom_lookalike_template', 
    $$
WITH
features AS (
    SELECT
        p.hashed_email,
        array_construct(identifier({{ dimensions[0] | column_policy }}) {% for feat in dimensions[1:] %} , identifier({{ feat | column_policy }}) {% endfor %}) as features
    FROM
        identifier({{ source_table[0] }}) as p
),
labels AS (
    SELECT
        c.hashed_email,
        {{ filter_clause | sqlsafe | column_policy }} as label_value
    FROM
        identifier({{ my_table[0] }}) as c
),
trained_model AS (
    SELECT
        train_out:model::varchar as model,
        train_out:error::float as error
    FROM (
      SELECT
        cleanroom.lookalike_train(array_agg(f.features), array_agg(l.label_value)) as train_out
      FROM features f, labels l
      WHERE f.hashed_email = l.hashed_email
    )
),
inference_output AS (
    SELECT
        MOD(seq4(), 100) as batch,
        cleanroom.lookalike_score(
            array_agg(distinct t.model), 
            array_agg(p.hashed_email), 
            array_agg(array_construct( identifier({{ dimensions[0] | column_policy }}) {% for feat in dimensions[1:] %} , identifier({{ feat | column_policy }}) {% endfor %}) )
        ) as scores
    FROM trained_model t, identifier({{ source_table[0] }}) p
    WHERE p.hashed_email NOT IN (SELECT c.hashed_email FROM identifier({{ my_table[0] }}) c)
    GROUP BY batch
),
processed_output AS (
    SELECT value:email::string as email, value:score::float as score FROM (select scores from inference_output), lateral flatten(input => parse_json(scores))
)
SELECT p.audience_size, t.error from (SELECT count(distinct email) as audience_size FROM processed_output WHERE score > 0.5) p, trained_model t;
    $$
);  

Se quiser visualizar os modelos atualmente ativos na sala limpa, chame o procedimento a seguir. Você pode fazer modificações para habilitar garantias de privacidade diferencial em sua análise. Um padrão semelhante pode ser incorporado em qualquer modelo personalizado que você escolher escrever.

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_provider_sample_database.lookalike_modeling.customers limit 10;

Defina as colunas nas quais deseja 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 coluna dependendo do modelo subjacente. Isso deve ser chamado somente após adicionar o modelo.

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_lookalike_template:samooha_provider_sample_database.lookalike_modeling.customers:status', 
    'prod_custom_lookalike_template:samooha_provider_sample_database.lookalike_modeling.customers:age', 
    'prod_custom_lookalike_template:samooha_provider_sample_database.lookalike_modeling.customers:region_code', 
    'prod_custom_lookalike_template:samooha_provider_sample_database.lookalike_modeling.customers:days_active', 
    'prod_custom_lookalike_template:samooha_provider_sample_database.lookalike_modeling.customers:income_bracket', 
    'prod_custom_lookalike_template:samooha_provider_sample_database.lookalike_modeling.customers:household_size', 
    'prod_custom_lookalike_template:samooha_provider_sample_database.lookalike_modeling.customers:gender'
]);

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_Machine_Learning_Demo_clean_room;

call samooha_by_snowflake_local_db.provider.add_consumers($cleanroom_name, '<CONSUMER_ACCOUNT_LOCATOR>', '<CONSUMER_ACCOUNT_NAME>');
call samooha_By_snowflake_local_db.provider.create_cleanroom_listing($cleanroom_name, '<CONSUMER_ACCOUNT_NAME>');

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);

Se quiser visualizar as salas limpas criadas recentemente, use o seguinte procedimento.

call samooha_by_snowflake_local_db.provider.view_cleanrooms();

Se quiser obter mais informações sobre a sala limpa que criou, use o 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 = 'Machine Learning 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 pode demorar um pouco mais para ser executado, normalmente cerca de meio minuto.

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¶

Agora você pode vincular alguns de seus 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_consumer_sample_database.lookalike_modeling.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ê precisará 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 adicionado à sala limpa pelo provedor e usando o comando “run_analysis”. Você pode ver como cada campo é determinado na seção abaixo.

Os usuários de “alto valor” são identificados com filter_clause na consulta abaixo. Se c.SALES_DLR representa a quantidade de vendas por usuário, então um filtro válido poderia ser parecido com c.HIGH_VALUE > 4.000.

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

    ['samooha_consumer_sample_database.lookalike_modeling.customers'],                -- consumer tables

    ['samooha_provider_sample_database.lookalike_modeling.customers'],                -- provider tables

    object_construct(                    -- Rest of the custom arguments needed for the template
        'dimensions', ['p.STATUS', 'p.AGE', 'p.REGION_CODE', 'p.DAYS_ACTIVE', 'p.INCOME_BRACKET'], -- Features used in training

        'filter_clause', 'c.SALES_DLR > 2000' -- Consumer flag for which customers are considered high value
    )
);

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_lookalike_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.

call samooha_by_snowflake_local_db.consumer.get_arguments_from_template($cleanroom_name, 'prod_custom_lookalike_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);