Tutorial: Consulta a dados espelhados do Fabric a partir do Microsoft Fabric HorizonDB

Neste passo tutorial, você usa a integração gerenciada pg_fabric_fdw por serviços para consultar os dados espelhados do Contoso a partir do endpoint PostgreSQL do Fabric HorizonDB. As tabelas estrangeiras importadas contêm apenas metadados. As linhas permanecem na fonte remota espelhada.

Você também inspeciona quais operações são executadas no Fabric e junta uma tabela PostgreSQL local a uma tabela estrangeira remota. Esta é a capacidade de consultas federadas do Federated Analytics.

Importante

Fabric HorizonDB está em prévia pública. Capacidades, limites e comportamento podem mudar antes da disponibilidade geral. Para mais informações, consulte os recursos de pré-visualização do Microsoft Fabric.

Prerequisites

  • Complete Use o endpoint de análise SQL.
  • Confirme que o espelhamento é saudável o suficiente para customers e orders para aparecer no endpoint de análise SQL.
  • Faça login como criador do banco de dados, com permissão para criar um data warehouse e ler seus dados. Outros usuários e entidades de segurança não podem se conectar ao PostgreSQL na pré-visualização atual.

Verifique a integração gerenciada

Abra uma consulta no contoso-orders-db endpoint PostgreSQL e execute:

SELECT
    extension.extname,
    extension.extversion
FROM pg_catalog.pg_extension AS extension
WHERE extension.extname = 'pg_fabric_fdw';

Verifique o servidor estrangeiro padrão:

SELECT
    server.srvname,
    server.srvoptions
FROM pg_catalog.pg_foreign_server AS server
WHERE server.srvname = 'fabric_dw';

Cada consulta deve retornar uma linha. A extensão e fabric_dw o servidor são gerenciados pelo serviço. Não os recrie, altere ou exclua.

O wrapper envia consultas traduzidas para o Fabric por meio de uma conexão nativa de Tabular Data Stream (TDS). Você não precisa de um driver de Conectividade de Banco de Dados Aberto (ODBC) nem de uma instalação separada de extensão PostgreSQL. Se o servidor gerenciado estiver ausente, verifique a prontidão de provisionamento e integração em vez de criar um substituto.

Importar as tabelas espelhadas

Crie um esquema de propriedade do cliente:

CREATE SCHEMA IF NOT EXISTS fabric_mirror;

Use o nome do esquema remoto mostrado pelo endpoint de análise SQL. Se for horizon_sample, execute:

IMPORT FOREIGN SCHEMA horizon_sample
    LIMIT TO (customers, orders)
    FROM SERVER fabric_dw
    INTO fabric_mirror;

Se o endpoint mostrar outro nome de esquema, substitua horizon_sample na IMPORT FOREIGN SCHEMA instrução. Importar o esquema lê o catálogo remoto e cria nomes de colunas e mapeamentos de tipos do PostgreSQL. Ele não copia linhas para dentro do Fabric HorizonDB. O nome fabric_mirror local não precisa corresponder ao esquema remoto.

LIMIT TO mantém essa importação limitada às duas tabelas tutoriais. Coloque os nomes entre aspas se a fonte usar maiúsculas e minúsculas misturadas. Se a importação apresentar um aviso de ordenamento, verifique se ela ainda está terminando com sucesso e valide as comparações de texto antes de confiar em resultados equivalentes do PostgreSQL.

Inspecionar e consultar as tabelas estrangeiras

Confirme os objetos importados:

SELECT
    foreign_table.foreign_table_schema,
    foreign_table.foreign_table_name,
    foreign_table.foreign_server_name
FROM information_schema.foreign_tables AS foreign_table
WHERE foreign_table.foreign_table_schema = 'fabric_mirror'
ORDER BY foreign_table.foreign_table_name;

Execute uma consulta limitada:

SELECT
    order_row.order_reference,
    order_row.order_date,
    order_row.status,
    order_row.total
FROM fabric_mirror.orders AS order_row
ORDER BY order_row.order_date DESC, order_row.order_reference
LIMIT 20;

Após o espelhamento se atualizar, os dados do tutorial inalterados retornam três pedidos.

Confirmar pushdown de agregação

Planeje uma agregação antes de executá-la:

EXPLAIN (VERBOSE, COSTS OFF)
SELECT
    order_row.status,
    count(*) AS order_count,
    sum(order_row.total) AS order_total
FROM fabric_mirror.orders AS order_row
GROUP BY order_row.status
ORDER BY order_row.status;

Localize a linha Fabric SQL. Ele mostra exatamente o T-SQL planejado para o Fabric. Se o agregado for totalmente enviado para baixo, essa linha inclui GROUP BY, COUNT_BIG e count(*), a tradução de PostgreSQL SUM. A Foreign Scan retorna as linhas agrupadas em vez de todas as ordens de entrada.

Com a configuração padrão de plano remoto, EXPLAIN sem ANALYZE planeja localmente sem entrar em contato com o Fabric. Isso não prova que o endpoint remoto seja acessível. Um nó local Aggregate ou Sort significa que PostgreSQL executa essa operação após receber linhas do Fabric.

Valide um agregado limitado:

SELECT
    order_row.status,
    count(*) AS order_count,
    sum(order_row.total) AS order_total
FROM fabric_mirror.orders AS order_row
GROUP BY order_row.status
ORDER BY order_row.status;

Compare os resultados com o mesmo agregado no endpoint de SQL analytics. Pequenas diferenças podem ocorrer enquanto o espelhamento aplica alterações confirmadas.

Associe clientes locais a pedidos espelhados

Use a tabela de clientes operacionais locais para selecionar clientes e leia seus pedidos do Fabric:

EXPLAIN (VERBOSE, COSTS OFF)
SELECT
    customer.customer_name,
    order_row.order_reference,
    order_row.total
FROM horizon_sample.customers AS customer
JOIN fabric_mirror.orders AS order_row
  ON order_row.customer_id = customer.customer_id
WHERE customer.segment = 'Enterprise'
ORDER BY order_row.order_reference
LIMIT 20;

Remova EXPLAIN (VERBOSE, COSTS OFF) para executar a consulta. Para cada cliente local correspondente, o resultado contém os pedidos espelhados disponíveis no momento da consulta. Uma nova ordem operacional pode não aparecer até que o espelhamento se atualize.

A junção não pode ser executada inteiramente no Fabric porque uma das entradas é local. O PostgreSQL pode escolher uma varredura externa parametrizada para chaves de cliente selecionadas ou uma varredura remota seguida de uma junção local. Leia o plano em vez de assumir que apenas as linhas correspondentes cruzam a conexão.

Use federação com segurança

  • Tabelas estrangeiras são somente de leitura durante a pré-visualização pública.
  • Selecione apenas as colunas obrigatórias e use filtros e limites seletivos.
  • Use EXPLAIN (VERBOSE) para verificar filtros, agregados e junções antes de executar consultas maiores.
  • Valide identificadores, tipos, comportamento nulo, marcas de tempo e agregados em relação à fonte.
  • Não presuma que médias inteiras, espaços finais, padrões LIKE ou a ordem dos UUIDs se comportam de forma idêntica em ambos os motores.
  • Trate o PostgreSQL, espelhamento, endpoint de análise SQL e federação de forma independente.
  • Use uma tarefa de cópia quando o aplicativo precisar de uma cópia local estável.

O guia prático separado mostra importações e controles de transferência entre bancos de dados.

Criar uma origem de warehouse

Crie um warehouse separado para os sinais analíticos usados neste tutorial e na próxima etapa do trabalho de Cópia. Não crie a tabela na cópia do endpoint SQL Analytics do seu banco de dados, esse endpoint é somente de leitura.

  1. No endpoint HorizonDB PostgreSQL, registre os IDs gerados:

    SELECT customer_id, customer_name
    FROM horizon_sample.customers
    ORDER BY customer_id;
    
  2. No seu espaço de trabalho tutorial, crie um novo item Fabric Data Warehouse chamado contoso-signals-warehouse.

  3. No editor T-SQL do warehouse, execute o seguinte script. O exemplo usa IDs 1, 2, e 3; substitua-os pelos IDs retornados para seus clientes de exemplo antes de executá-lo.

    CREATE TABLE dbo.customer_signals (
        customer_id bigint NOT NULL,
        risk_score decimal(5, 2) NOT NULL,
        recommended_action varchar(200) NOT NULL,
        calculated_at datetime2(6) NOT NULL,
        load_batch_id varchar(50) NOT NULL
    );
    
    INSERT INTO dbo.customer_signals (
        customer_id, risk_score, recommended_action,
        calculated_at, load_batch_id
    )
    VALUES
        (1, 82.00, 'Prioritize account review',
         SYSUTCDATETIME(), 'preview-demo-001'),
        (2, 64.00, 'Monitor engagement',
         SYSUTCDATETIME(), 'preview-demo-001'),
        (3, 91.00, 'Escalate renewal risk',
         SYSUTCDATETIME(), 'preview-demo-001');
    

    Execute essa configuração uma vez no armazém dedicado ao tutorial. Em uma reexecução, inspecione dados existentes em vez de adicionar o mesmo lote novamente. O timestamp usa seis dígitos fracionários de segundo para compatibilidade de federação.

  4. Abra as Configurações> do armazém. Copie seu host da cadeia de conexão SQL e nome do banco de dados SQL; o nome do banco de dados SQL pode diferir de contoso-signals-warehouse.

Importar e consultar sinais do warehouse

Voltar ao editor PostgreSQL do HorizonDB. Substitua ambos os espaços reservados de conexão por valores do seu data warehouse:

CREATE SERVER customer_signals_dw
    FOREIGN DATA WRAPPER pg_fabric_fdw
    OPTIONS (
        endpoint '<warehouse-sql-endpoint>',
        database '<warehouse-sql-database-name>'
    );

CREATE SCHEMA IF NOT EXISTS fabric_sales;

IMPORT FOREIGN SCHEMA dbo
    LIMIT TO (customer_signals)
    FROM SERVER customer_signals_dw
    INTO fabric_sales;

customer_signals_dw é de propriedade do cliente. Não altere nem recrie o servidor gerenciado fabric_dw .

Associe os clientes locais aos sinais do armazém:

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 fabric_sales.customer_signals AS signal
  ON signal.customer_id = customer.customer_id
WHERE signal.risk_score >= 70
ORDER BY signal.risk_score DESC
LIMIT 20;

Com os mapeamentos de exemplo, o resultado contém Adventure Works e Contoso Retail. A aplicação permanece conectada ao PostgreSQL enquanto os sinais permanecem no warehouse. Mantenha esses metadados de warehouse e tabela estrangeira para as etapas do trabalho Copy e da aplicação.

Resultado esperado

O fabric_mirror esquema expõe tabelas espelhadas do Contoso e fabric_sales expõe sinais de clientes de um armazém separado. Você pode inspecionar o pushdown e unir dados operacionais locais com qualquer uma das fontes.

Próxima etapa