Tutorial: Carregar dados Fabric no Microsoft Fabric HorizonDB com um trabalho de cópia

Neste passo tutorial, você carrega um resultado de sinais de cliente limitado de uma fonte Fabric elegível para o Fabric HorizonDB. O trabalho Copy grava em uma tabela de preparação. Você valida a carga e depois a publica em uma tabela local de disponibilização.

Importante

Fabric HorizonDB está em prévia pública. Capacidades, limites e comportamento podem mudar antes da disponibilidade geral. A prévia pública não promete captura incremental de alterações, propagação por exclusão de fonte, tratamento de conflitos, evolução de esquema, agendamento, checkpoints ou reprodução automática para este destino. Para mais informações, consulte os recursos de pré-visualização do Microsoft Fabric.

Prerequisites

  • Conclua Query mirrored Fabric data from Fabric HorizonDB.

  • Reutilize dbo.customer_signals, criado na etapa anterior, em contoso-signals-warehouse, com estas colunas:

    Column Valor obrigatório
    customer_id Um valor que corresponde a um cliente em horizon_sample.customers
    risk_score Um valor numérico de 0 a 100.
    recommended_action Uma ação não vazia para o cliente.
    calculated_at O timestamp do cálculo de origem.
    load_batch_id Um identificador estável para esta carga delimitada.
  • Tenha permissão para ler a fonte e criar um job de cópia.

  • Faça login como criador do banco de dados para a configuração do PostgreSQL e a conexão de destino do trabalho Copiar. Outros usuários e principals não conseguem se conectar na pré-visualização atual.

Use uma fonte de desenvolvimento ou de teste. Não use dados de produção sensíveis para o tutorial.

Se você pulou a etapa de federação, complete primeiro Criar uma fonte de armazém . Não crie a tabela de origem no endpoint espelhado do SQL analytics, que é somente leitura.

Crie tabelas de preparação e de serving

No contoso-orders-db endpoint PostgreSQL, execute:

CREATE SCHEMA IF NOT EXISTS analytics_ops;

CREATE TABLE IF NOT EXISTS analytics_ops.customer_signals (
    customer_id bigint PRIMARY KEY,
    risk_score numeric(5, 2) NOT NULL,
    recommended_action text NOT NULL,
    calculated_at timestamptz NOT NULL,
    loaded_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE IF NOT EXISTS analytics_ops.customer_signals_stage (
    customer_id bigint NOT NULL,
    risk_score numeric(5, 2) NOT NULL,
    recommended_action text NOT NULL,
    calculated_at timestamptz NOT NULL,
    load_batch_id text NOT NULL,
    loaded_at timestamptz NOT NULL DEFAULT now()
);

A tarefa de cópia escreve para customer_signals_stage. As consultas do aplicativo usam customer_signals apenas após validação e publicação.

Prepare a carga delimitada

Esvazie a tabela de preparação imediatamente antes da execução do tutorial:

TRUNCATE TABLE analytics_ops.customer_signals_stage;

Não trunque a tabela de serving.

Crie e execute o trabalho de cópia

Siga as orientações vigentes para criação de trabalho Copy e configure este carregamento limitado:

  1. Crie uma tarefa de cópia chamada load-contoso-customer-signals.

  2. Selecione o armazém dbo.customer_signals e a tabela contoso-signals-warehouse.

  3. Selecione apenas customer_id, risk_score, recommended_action, calculated_at, e load_batch_id.

  4. Escolha o conector de destino Banco de Dados do Azure para PostgreSQL.

    Captura de tela do conector de destino do Banco de Dados do Azure para PostgreSQL.

  5. Copie o host PostgreSQL do contoso-orders-db painel Visual Studio Code do item e use o banco de dados postgres.

  6. Defina o tipo de autenticação para Conta organizacional e faça login como criador do banco de dados. Mantenha Usar conexão criptografada selecionado.

  7. Selecione Cópia completa na página do método de leitura.

  8. Selecione analytics_ops.customer_signals_stage como tabela de destino.

  9. Mapeie cada coluna de origem para a coluna de destino com o mesmo nome.

  10. Deixe loaded_at unmapeado para que o padrão PostgreSQL forneça o tempo de carregamento, e confirme que calculated_at representa UTC.

  11. Selecione Salvar e Executar.

  12. Monitore a execução e registre seu ID da execução, contagem de linhas, duração e erros.

Um job de cópia bem-sucedido significa que as linhas chegaram à área de staging. Isso não prova que as linhas são válidas ou publicadas.

Validar os dados em estágio

Substitua <batch-id> pelo identificador de lote fornecido pela fonte (preview-demo-001 para o armazém tutorial):

SELECT
    count(*) AS staged_rows,
    count(DISTINCT customer_id) AS distinct_customers,
    min(calculated_at) AS oldest_calculation,
    max(calculated_at) AS newest_calculation
FROM analytics_ops.customer_signals_stage
WHERE load_batch_id = '<batch-id>';

Verifique duplicatas e valores que não correspondem ao contrato do tutorial:

SELECT
    stage.customer_id,
    count(*) AS occurrences
FROM analytics_ops.customer_signals_stage AS stage
WHERE stage.load_batch_id = '<batch-id>'
GROUP BY stage.customer_id
HAVING count(*) > 1;
SELECT
    stage.customer_id,
    stage.risk_score,
    stage.recommended_action,
    stage.calculated_at
FROM analytics_ops.customer_signals_stage AS stage
LEFT JOIN horizon_sample.customers AS customer
  ON customer.customer_id = stage.customer_id
WHERE stage.load_batch_id = '<batch-id>'
  AND (
      customer.customer_id IS NULL
      OR stage.risk_score NOT BETWEEN 0 AND 100
      OR btrim(stage.recommended_action) = ''
  );

Não publique o lote a menos que staged_rows e distinct_customers ambos correspondam à contagem de clientes de origem esperada (3 para a fonte do tutorial inalterada), e ambas as consultas de validação não retornem linhas.

Publicar os valores mais recentes

Executar:

BEGIN;

INSERT INTO analytics_ops.customer_signals (
    customer_id,
    risk_score,
    recommended_action,
    calculated_at,
    loaded_at
)
SELECT DISTINCT ON (stage.customer_id)
    stage.customer_id,
    stage.risk_score,
    stage.recommended_action,
    stage.calculated_at,
    now()
FROM analytics_ops.customer_signals_stage AS stage
WHERE stage.load_batch_id = '<batch-id>'
ORDER BY
    stage.customer_id,
    stage.calculated_at DESC
ON CONFLICT (customer_id) DO UPDATE
SET
    risk_score = EXCLUDED.risk_score,
    recommended_action = EXCLUDED.recommended_action,
    calculated_at = EXCLUDED.calculated_at,
    loaded_at = EXCLUDED.loaded_at
WHERE analytics_ops.customer_signals.calculated_at <= EXCLUDED.calculated_at;

COMMIT;

O ID de cliente estável e ON CONFLICT a cláusula impedem linhas de serviço duplicadas quando você reexecuta a etapa de publicação para o mesmo lote validado. Confirme que o lote está atualizado antes de publicá-lo.

Consulte os dados operacionalizados

SELECT
    customer.customer_id,
    customer.customer_name,
    customer.segment,
    signal.risk_score,
    signal.recommended_action,
    signal.calculated_at
FROM horizon_sample.customers AS customer
JOIN analytics_ops.customer_signals AS signal
  ON signal.customer_id = customer.customer_id
ORDER BY signal.risk_score DESC, customer.customer_name;

Esta consulta lê tabelas locais do PostgreSQL. Sua recência é determinada pelo job de cópia e pelo processo de publicação.

Resultado esperado

O load-contoso-customer-signals trabalho Copiar carrega um lote limitado no staging, a validação é bem-sucedida e analytics_ops.customer_signals contém os valores publicados para corresponder aos IDs de clientes do tutorial Contoso.

Próxima etapa