Sintaxe SQL no Serviço de consulta
Você pode usar ANSI SQL padrão para SELECT
instruções e outros comandos limitados no Adobe Experience Platform Query Service. Este documento aborda a sintaxe SQL compatível com o Query Service.
Consultas SELECT select-queries
A sintaxe a seguir define uma variável SELECT
consulta suportada por Query Service:
[ WITH with_query [, ...] ]
SELECT [ ALL | DISTINCT [( expression [, ...] ) ] ]
[ * | expression [ [ AS ] output_name ] [, ...] ]
[ FROM from_item [, ...] ]
[ SNAPSHOT { SINCE start_snapshot_id | AS OF end_snapshot_id | BETWEEN start_snapshot_id AND end_snapshot_id } ]
[ WHERE condition ]
[ GROUP BY grouping_element [, ...] ]
[ HAVING condition [, ...] ]
[ WINDOW window_name AS ( window_definition ) [, ...] ]
[ { UNION | INTERSECT | EXCEPT | MINUS } [ ALL | DISTINCT ] select ]
[ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
[ LIMIT { count | ALL } ]
[ OFFSET start ]
A seção de guias abaixo fornece as opções disponíveis para as palavras-chave FROM, GROUP e WITH.
code language-sql |
---|
|
code language-sql |
---|
|
code language-sql |
---|
|
code language-sql |
---|
|
code language-sql |
---|
|
code language-sql |
---|
|
code language-sql |
---|
|
code language-sql |
---|
|
code language-sql |
---|
|
code language-sql |
---|
|
code language-sql |
---|
|
As subseções a seguir fornecem detalhes sobre as cláusulas adicionais que você pode usar em seus queries, desde que elas sigam o formato descrito acima.
cláusula SNAPSHOT
Esta cláusula pode ser usada para ler incrementalmente os dados em uma tabela com base nas IDs do instantâneo. Uma ID de instantâneo é um marcador de ponto de verificação representado por um número tipo Long que é aplicado a uma tabela de data lake sempre que os dados são gravados nela. A variável SNAPSHOT
se anexa à relação de tabela à qual é usada ao lado.
[ SNAPSHOT { SINCE start_snapshot_id | AS OF end_snapshot_id | BETWEEN start_snapshot_id AND end_snapshot_id } ]
Exemplo
SELECT * FROM Customers SNAPSHOT SINCE 123;
SELECT * FROM Customers SNAPSHOT AS OF 345;
SELECT * FROM Customers SNAPSHOT BETWEEN 123 AND 345;
SELECT * FROM Customers SNAPSHOT BETWEEN HEAD AND 123;
SELECT * FROM Customers SNAPSHOT BETWEEN 345 AND TAIL;
SELECT * FROM (SELECT id FROM CUSTOMERS BETWEEN 123 AND 345) C
SELECT * FROM Customers SNAPSHOT SINCE 123 INNER JOIN Inventory AS OF 789 ON Customers.id = Inventory.id;
A SNAPSHOT
A cláusula funciona com um alias de tabela ou tabela, mas não na parte superior de uma subconsulta ou view. A SNAPSHOT
A cláusula funciona em qualquer lugar que um SELECT
a consulta em uma tabela pode ser aplicada.
Além disso, você pode usar HEAD
e TAIL
como valores de deslocamento especiais para cláusulas instantâneas. Usar HEAD
refere-se a um deslocamento antes do primeiro instantâneo, enquanto TAIL
refere-se a um deslocamento após o último instantâneo.
resolve_fallback_snapshot_on_failure
) está definido:-
Se o sinalizador de comportamento de fallback opcional estiver definido, o Serviço de Consulta escolherá o instantâneo disponível mais antigo, definirá-o como o instantâneo inicial e retornará os dados entre o instantâneo disponível mais antigo e o instantâneo final especificado. Esses dados são inclusivo do instantâneo mais antigo disponível.
-
Se o sinalizador de comportamento de fallback opcional não estiver definido, um erro será retornado.
Cláusula WHERE
Por padrão, correspondências produzidas por um WHERE
em uma SELECT
as consultas fazem distinção entre maiúsculas e minúsculas. Se você quiser que as correspondências não diferenciem maiúsculas de minúsculas, use a palavra-chave ILIKE
em vez de LIKE
.
[ WHERE condition { LIKE | ILIKE | NOT LIKE | NOT ILIKE } pattern ]
A lógica das cláusulas LIKE e ILIKE é explicada na tabela a seguir:
WHERE condition LIKE pattern
~~
WHERE condition NOT LIKE pattern
!~~
WHERE condition ILIKE pattern
~~*
WHERE condition NOT ILIKE pattern
!~~*
Exemplo
SELECT * FROM Customers
WHERE CustomerName ILIKE 'a%';
Esta consulta retorna clientes com nomes que começam com "A" ou "a".
ASSOCIAR-SE
A SELECT
a consulta que usa associações tem a seguinte sintaxe:
SELECT statement
FROM statement
[JOIN | INNER JOIN | LEFT JOIN | LEFT OUTER JOIN | RIGHT JOIN | RIGHT OUTER JOIN | FULL JOIN | FULL OUTER JOIN]
ON join condition
UNIÃO, INTERSEÇÃO e EXCETO
A variável UNION
, INTERSECT
, e EXCEPT
as cláusulas são usadas para combinar ou excluir linhas semelhantes de duas ou mais tabelas:
SELECT statement 1
[UNION | UNION ALL | UNION DISTINCT | INTERSECT | EXCEPT | MINUS]
SELECT statement 2
CRIAR TABELA COMO SELECIONAR create-table-as-select
A sintaxe a seguir define uma variável CREATE TABLE AS SELECT
Consulta do (CTAS):
CREATE TABLE table_name [ WITH (schema='target_schema_title', rowvalidation='false', label='PROFILE') ] AS (select_query)
schema
rowvalidation
true
.label
profile
para rotular o conjunto de dados como ativado para o perfil. Isso significa que seu conjunto de dados é marcado automaticamente para o perfil à medida que é criado. Consulte o documento de extensão de atributo derivado para obter mais informações sobre o uso do label
.select_query
SELECT
declaração. A sintaxe do SELECT
a consulta pode ser encontrada no SELECIONAR seção de consultas.Exemplo
CREATE TABLE Chairs AS (SELECT color, count(*) AS no_of_chairs FROM Inventory i WHERE i.type=="chair" GROUP BY i.color)
CREATE TABLE Chairs WITH (schema='target schema title', label='PROFILE') AS (SELECT color, count(*) AS no_of_chairs FROM Inventory i WHERE i.type=="chair" GROUP BY i.color)
CREATE TABLE Chairs AS (SELECT color FROM Inventory SNAPSHOT SINCE 123)
SELECT
A instrução deve ter um alias para as funções de agregação, como COUNT
, SUM
, MIN
e assim por diante. Além disso, a variável SELECT
A instrução pode ser fornecida com ou sem parênteses (). Você pode fornecer um SNAPSHOT
cláusula para ler deltas incrementais na tabela de destino.INSERIR EM
A variável INSERT INTO
é definido da seguinte maneira:
INSERT INTO table_name select_query
table_name
select_query
SELECT
declaração. A sintaxe do SELECT
a consulta pode ser encontrada no SELECIONAR seção de consultas.Exemplo
INSERT INTO Customers SELECT SupplierName, City, Country FROM OnlineCustomers;
INSERT INTO Customers AS (SELECT * from OnlineCustomers SNAPSHOT AS OF 345)
SELECT
declaração entre parênteses (). Além disso, o esquema do resultado da variável SELECT
deve estar em conformidade com o da tabela definida no INSERT INTO
declaração. Você pode fornecer um SNAPSHOT
cláusula para ler deltas incrementais na tabela de destino.A maioria dos campos em um esquema XDM real não é encontrada no nível raiz e o SQL não permite o uso da notação de pontos. Para obter um resultado realista usando campos aninhados, mapeie cada campo no INSERT INTO
caminho.
Para INSERT INTO
caminhos aninhados, use a seguinte sintaxe:
INSERT INTO [dataset]
SELECT struct([source field1] as [target field in schema],
[source field2] as [target field in schema],
[source field3] as [target field in schema]) [tenant name]
FROM [dataset]
Exemplo
INSERT INTO Customers SELECT struct(SupplierName as Supplier, City as SupplierCity, Country as SupplierCountry) _Adobe FROM OnlineCustomers;
SOLTAR TABELA
A variável DROP TABLE
O comando remove uma tabela existente e exclui o diretório associado à tabela do sistema de arquivos se ela não for uma tabela externa. Se a tabela não existir, ocorrerá uma exceção.
DROP TABLE [IF EXISTS] [db_name.]table_name
IF EXISTS
CRIAR BANCO DE DADOS
A variável CREATE DATABASE
O comando cria um banco de dados do Azure Data Lake Storage (ADLS).
CREATE DATABASE [IF NOT EXISTS] db_name
SOLTAR BANCO DE DADOS
A variável DROP DATABASE
O comando exclui o banco de dados de uma instância.
DROP DATABASE [IF EXISTS] db_name
IF EXISTS
SOLTAR ESQUEMA
A variável DROP SCHEMA
solta um esquema existente.
DROP SCHEMA [IF EXISTS] db_name.schema_name [ RESTRICT | CASCADE]
IF EXISTS
RESTRICT
CASCADE
CRIAR VISUALIZAÇÃO
A sintaxe a seguir define uma variável CREATE VIEW
consulta para um conjunto de dados. Esse conjunto de dados pode ser um ADLS ou um conjunto de dados de armazenamento acelerado.
CREATE VIEW view_name AS select_query
view_name
select_query
SELECT
declaração. A sintaxe do SELECT
a consulta pode ser encontrada no SELECIONAR seção de consultas.Exemplo
CREATE VIEW V1 AS SELECT color, type FROM Inventory
CREATE OR REPLACE VIEW V1 AS SELECT model, version FROM Inventory
A sintaxe a seguir define uma variável CREATE VIEW
consulta que cria uma visualização no contexto de um banco de dados e esquema.
Exemplo
CREATE VIEW db_name.schema_name.view_name AS select_query
CREATE OR REPLACE VIEW db_name.schema_name.view_name AS select_query
db_name
schema_name
view_name
select_query
SELECT
declaração. A sintaxe do SELECT
a consulta pode ser encontrada no SELECIONAR seção de consultas.Exemplo
CREATE VIEW <dbV1 AS SELECT color, type FROM Inventory;
CREATE OR REPLACE VIEW V1 AS SELECT model, version FROM Inventory;
MOSTRAR EXIBIÇÕES
A consulta a seguir mostra a lista de exibições.
SHOW VIEWS;
Db Name | Schema Name | Name | Id | Dataset Dependencies | Views Dependencies | TYPE
----------------------------------------------------------------------------------------------
qsaccel | profile_agg | view1 | view_id1 | dwh_dataset1 | | DWH
| | view2 | view_id2 | adls_dataset | adls_views | ADLS
(2 rows)
SOLTAR VISUALIZAÇÃO
A sintaxe a seguir define uma variável DROP VIEW
consulta:
DROP VIEW [IF EXISTS] view_name
IF EXISTS
view_name
Exemplo
DROP VIEW v1
DROP VIEW IF EXISTS v1
Bloqueio anônimo anonymous-block
Um bloco anônimo consiste em duas seções: executável e seções de manipulação de exceções. Em um bloco anônimo, a seção executável é obrigatória. No entanto, a seção de tratamento de exceções é opcional.
O exemplo a seguir mostra como criar um bloco com uma ou mais instruções a serem executadas juntas:
$$BEGIN
statementList
[EXCEPTION exceptionHandler]
$$END
exceptionHandler:
WHEN OTHER
THEN statementList
statementList:
: (statement (';')) +
Veja abaixo um exemplo de uso de bloco anônimo.
$$BEGIN
SET @v_snapshot_from = select parent_id from (select history_meta('email_tracking_experience_event_dataset') ) tab where is_current;
SET @v_snapshot_to = select snapshot_id from (select history_meta('email_tracking_experience_event_dataset') ) tab where is_current;
SET @v_log_id = select now();
CREATE TABLE tracking_email_id_incrementally
AS SELECT _id AS id FROM email_tracking_experience_event_dataset SNAPSHOT BETWEEN @v_snapshot_from AND @v_snapshot_to;
EXCEPTION
WHEN OTHER THEN
DROP TABLE IF EXISTS tracking_email_id_incrementally;
SELECT 'ERROR';
$$END;
Instruções condicionais em um bloco anônimo conditional-anonymous-block-statements
A estrutura de controle IF-THEN-ELSE permite a execução condicional de uma lista de instruções quando uma condição é avaliada como TRUE. Essa estrutura de controle só é aplicável em um bloco anônimo. Se essa estrutura for usada como um comando independente, ela resultará em um erro de sintaxe ("Comando inválido fora do Bloco anônimo").
O trecho de código abaixo demonstra o formato correto de uma declaração condicional IF-THEN-ELSE em um bloco anônimo.
IF booleanExpression THEN
List of statements;
ELSEIF booleanExpression THEN
List of statements;
ELSEIF booleanExpression THEN
List of statements;
ELSE
List of statements;
END IF
Exemplo
O exemplo abaixo executa SELECT 200;
.
$$BEGIN
SET @V = SELECT 2;
SELECT @V;
IF @V = 1 THEN
SELECT 100;
ELSEIF @V = 2 THEN
SELECT 200;
ELSEIF @V = 3 THEN
SELECT 300;
ELSE
SELECT 'DEFAULT';
END IF;
END$$;
Essa estrutura pode ser usada com raise_error();
para retornar uma mensagem de erro personalizada. O bloco de código visto abaixo encerra o bloco anônimo com "mensagem de erro personalizada".
Exemplo
$$BEGIN
SET @V = SELECT 5;
SELECT @V;
IF @V = 1 THEN
SELECT 100;
ELSEIF @V = 2 THEN
SELECT 200;
ELSEIF @V = 3 THEN
SELECT 300;
ELSE
SELECT raise_error('custom error message');
END IF;
END$$;
Instruções IF aninhadas
Instruções IF aninhadas são suportadas em blocos anônimos.
Exemplo
$$BEGIN
SET @V = SELECT 1;
IF @V = 1 THEN
SELECT 100;
IF @V > 0 THEN
SELECT 1000;
END IF;
END IF;
END$$;
Blocos de exceção
Blocos de exceção são suportados em blocos anônimos.
Exemplo
$$BEGIN
SET @V = SELECT 2;
IF @V = 1 THEN
SELECT 100;
ELSEIF @V = 2 THEN
SELECT raise_error(concat('custom-error for v= ', '@V' ));
ELSEIF @V = 3 THEN
SELECT 300;
ELSE
SELECT 'DEFAULT';
END IF;
EXCEPTION WHEN OTHER THEN
SELECT 'THERE WAS AN ERROR';
END$$;
Auto para JSON auto-to-json
O Serviço de consulta oferece suporte a uma configuração opcional no nível da sessão para retornar campos complexos de nível superior de consultas SELECT interativas como cadeias de caracteres JSON. A variável auto_to_json
permite que dados de campos complexos sejam retornados como JSON e depois analisados em objetos JSON usando bibliotecas padrão.
DEFINIR o sinalizador de recurso auto_to_json
como true antes de executar a consulta SELECT que contém campos complexos.
set auto_to_json=true;
Antes de definir a variável auto_to_json
sinalizador
A tabela a seguir fornece um exemplo de resultado de consulta antes da variável auto_to_json
é aplicada. A mesma consulta SELECT (como visto abaixo) que segmenta uma tabela com campos complexos foi usada em ambos os cenários.
SELECT * FROM TABLE_WITH_COMPLEX_FIELDS LIMIT 2;
Os resultados são os seguintes:
_id | _experience | application | commerce | dataSource | device | endUserIDs | environment | identityMap | placeContext | receivedTimestamp | timestamp | userActivityRegion | web | _adcstageforpqs
-----------------------------------+----------------------------------------------------------------------------+--------------+----------------------------------------------+------------+--------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------+-------------------------------------------------------------------------+-----------------------+-----------------------+--------------------+--------------------------------------------------------------------------------------+-----------------
31892EE15DE00000-401D52664FF48A52 | ("("("(1,1)","(1,1)")","(-209479095,4085488201,-2105158467,2189808829)")") | (background) | (NULL,"(USD,NULL)",NULL,NULL,NULL,NULL,NULL) | (475341) | (32,768,1024,205202,https://ns.adobe.com/xdm/external/deviceatlas) | ("("(31892EE080007B35-E6CE00000000000,"(AAID)",t)")") | ("(en-US,f,f,t,1.6,"Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_1 like Mac OS X; ja-jp) AppleWebKit/532.9 (KHTML, like Gecko) Version/4.0.5 Mobile/8B117 Safari/6531.22.7",490,1125)",xo.net,64.3.235.13) | [AAID -> "{(31892EE080007B35-E6CE00000000000,t)}"] | ("("(34.01,-84.0)",lawrenceville,US,524,30043,ga)",600) | 2022-09-02 19:47:14.0 | 2022-09-02 19:47:14.0 | (UT1) | ("(f,Search Results,"(1.0)")","(http://www.google.com/search?ie=UTF-8&q=,internal)") |
31892EE15DE00000-401B92664FF48AE8 | ("("("(1,1)","(1,1)")","(-209479095,4085488201,-2105158467,2189808829)")") | (background) | (NULL,"(USD,NULL)",NULL,NULL,NULL,NULL,NULL) | (475341) | (32,768,1024,205202,https://ns.adobe.com/xdm/external/deviceatlas) | ("("(31892EE100007BF3-215FE00000000001,"(AAID)",t)")") | ("(en-US,f,f,t,1.5,"Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_1 like Mac OS X; ja-jp) AppleWebKit/532.9 (KHTML, like Gecko) Version/4.0.5 Mobile/8B117 Safari/6531.22.7",768,556)",ntt.net,219.165.108.145) | [AAID -> "{(31892EE100007BF3-215FE00000000001,t)}"] | ("("(34.989999999999995,138.42)",shizuoka,JP,392005,420-0812,22)",-240) | 2022-09-02 19:47:14.0 | 2022-09-02 19:47:14.0 | (UT1) | ("(f,Home - JJEsquire,"(1.0)")","(NULL,typed_bookmarked)") |
(2 rows)
Depois de definir a variável auto_to_json
sinalizador
A tabela a seguir demonstra a diferença nos resultados que a auto_to_json
no conjunto de dados resultante. A mesma consulta SELECT foi usada em ambos os cenários.
_id | receivedTimestamp | timestamp | _experience | application | commerce | dataSource | device | endUserIDs | environment | identityMap | placeContext | userActivityRegion | web | _adcstageforpqs
-----------------------------------+-----------------------+-----------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+----------------------------------+------------------+-------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------
31892EE15DE00000-401D52664FF48A52 | 2022-09-02 19:47:14.0 | 2022-09-02 19:47:14.0 | {"analytics":{"customDimensions":{"eVars":{"eVar1":"1","eVar2":"1"},"props":{"prop1":"1","prop2":"1"}},"environment":{"browserID":-209479095,"browserIDStr":"4085488201","operatingSystemID":-2105158467,"operatingSystemIDStr":"2189808829"}}} | {"userPerspective":"background"} | {"order":{"currencyCode":"USD"}} | {"_id":"475341"} | {"colorDepth":32,"screenHeight":768,"screenWidth":1024,"typeID":"205202","typeIDService":"https://ns.adobe.com/xdm/external/deviceatlas"} | {"_experience":{"aaid":{"id":"31892EE080007B35-E6CE00000000000","namespace":{"code":"AAID"},"primary":true}}} | {"browserDetails":{"acceptLanguage":"en-US","cookiesEnabled":false,"javaEnabled":false,"javaScriptEnabled":true,"javaScriptVersion":"1.6","userAgent":"Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_1 like Mac OS X; ja-jp) AppleWebKit/532.9 (KHTML, like Gecko) Version/4.0.5 Mobile/8B117 Safari/6531.22.7","viewportHeight":490,"viewportWidth":1125},"domain":"xo.net","ipV4":"64.3.235.13"} | {"AAID":[{"id":"31892EE080007B35-E6CE00000000000","primary":true}]} | {"geo":{"_schema":{"latitude":34.01,"longitude":-84.0},"city":"lawrenceville","countryCode":"US","dmaID":524,"postalCode":"30043","stateProvince":"ga"},"localTimezoneOffset":600} | {"dataCenterLocation":"UT1"} | {"webPageDetails":{"isHomePage":false,"name":"Search Results","pageViews":{"value":1.0}},"webReferrer":{"URL":"http://www.google.com/search?ie=UTF-8&q=","type":"internal"}} |
31892EE15DE00000-401B92664FF48AE8 | 2022-09-02 19:47:14.0 | 2022-09-02 19:47:14.0 | {"analytics":{"customDimensions":{"eVars":{"eVar1":"1","eVar2":"1"},"props":{"prop1":"1","prop2":"1"}},"environment":{"browserID":-209479095,"browserIDStr":"4085488201","operatingSystemID":-2105158467,"operatingSystemIDStr":"2189808829"}}} | {"userPerspective":"background"} | {"order":{"currencyCode":"USD"}} | {"_id":"475341"} | {"colorDepth":32,"screenHeight":768,"screenWidth":1024,"typeID":"205202","typeIDService":"https://ns.adobe.com/xdm/external/deviceatlas"} | {"_experience":{"aaid":{"id":"31892EE100007BF3-215FE00000000001","namespace":{"code":"AAID"},"primary":true}}} | {"browserDetails":{"acceptLanguage":"en-US","cookiesEnabled":false,"javaEnabled":false,"javaScriptEnabled":true,"javaScriptVersion":"1.5","userAgent":"Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_1 like Mac OS X; ja-jp) AppleWebKit/532.9 (KHTML, like Gecko) Version/4.0.5 Mobile/8B117 Safari/6531.22.7","viewportHeight":768,"viewportWidth":556},"domain":"ntt.net","ipV4":"219.165.108.145"} | {"AAID":[{"id":"31892EE100007BF3-215FE00000000001","primary":true}]} | {"geo":{"_schema":{"latitude":34.989999999999995,"longitude":138.42},"city":"shizuoka","countryCode":"JP","dmaID":392005,"postalCode":"420-0812","stateProvince":"22"},"localTimezoneOffset":-240} | {"dataCenterLocation":"UT1"} | {"webPageDetails":{"isHomePage":false,"name":"Home - JJEsquire","pageViews":{"value":1.0}},"webReferrer":{"type":"typed_bookmarked"}} |
(2 rows)
Resolver instantâneo de fallback em caso de falha resolve-fallback-snapshot-on-failure
A variável resolve_fallback_snapshot_on_failure
é usada para resolver o problema de uma ID de instantâneo expirada. Os metadados de snapshot expiram após dois dias e um snapshot expirado pode invalidar a lógica de um script. Isso pode ser um problema ao usar blocos anônimos.
Defina o resolve_fallback_snapshot_on_failure
opção para verdadeiro para substituir um instantâneo por uma ID de instantâneo anterior.
SET resolve_fallback_snapshot_on_failure=true;
A linha de código a seguir substitui a @from_snapshot_id
com os mais antigos disponíveis snapshot_id
dos metadados.
$$ BEGIN
SET resolve_fallback_snapshot_on_failure=true;
SET @from_snapshot_id = SELECT coalesce(last_snapshot_id, 'HEAD') FROM checkpoint_log a JOIN
(SELECT MAX(process_timestamp)process_timestamp FROM checkpoint_log
WHERE process_name = 'DIM_TABLE_ABC' AND process_status = 'SUCCESSFUL' )b
on a.process_timestamp=b.process_timestamp;
SET @to_snapshot_id = SELECT snapshot_id FROM (SELECT history_meta('DIM_TABLE_ABC')) WHERE is_current = true;
SET @last_updated_timestamp= SELECT CURRENT_TIMESTAMP;
INSERT INTO DIM_TABLE_ABC_Incremental
SELECT * FROM DIM_TABLE_ABC SNAPSHOT BETWEEN @from_snapshot_id AND @to_snapshot_id WHERE NOT EXISTS (SELECT _id FROM DIM_TABLE_ABC_Incremental a WHERE _id=a._id);
Insert Into
checkpoint_log
SELECT
'DIM_TABLE_ABC' process_name,
'SUCCESSFUL' process_status,
cast( @to_snapshot_id AS string) last_snapshot_id,
cast( @last_updated_timestamp AS TIMESTAMP) process_timestamp;
EXCEPTION
WHEN OTHER THEN
SELECT 'ERROR';
END
$$;
Organização do ativo de dados
É importante organizar logicamente seus ativos de dados no data lake da Adobe Experience Platform à medida que eles crescem. O Serviço de consulta estende as construções SQL que permitem agrupar logicamente os ativos de dados em uma sandbox. Esse método de organização permite o compartilhamento de ativos de dados entre esquemas sem a necessidade de movê-los fisicamente.
As seguintes construções SQL usando sintaxe SQL padrão são compatíveis para que você organize logicamente seus dados.
CREATE DATABASE dg1;
CREATE SCHEMA dg1.schema1;
CREATE table t1 ...;
CREATE view v1 ...;
ALTER TABLE t1 ADD PRIMARY KEY (c1) NOT ENFORCED;
ALTER TABLE t2 ADD FOREIGN KEY (c1) REFERENCES t1(c1) NOT ENFORCED;
Consulte a organização lógica dos ativos de dados guia para obter uma explicação mais detalhada sobre as Práticas recomendadas do Serviço de consulta.
A tabela existe
A variável table_exists
O comando SQL é usado para confirmar se uma tabela existe atualmente no sistema. O comando retorna um valor booleano: true
se a tabela faz existir, e false
se a tabela não não existe.
Ao validar se uma tabela existe antes de executar as instruções, a variável table_exists
recurso simplifica o processo de gravação de um bloco anônimo para abranger CREATE
e INSERT INTO
casos de uso.
A sintaxe a seguir define a variável table_exists
comando:
$$
BEGIN
#Set mytableexist to true if the table already exists.
SET @mytableexist = SELECT table_exists('target_table_name');
#Create the table if it does not already exist (this is a one time operation).
CREATE TABLE IF NOT EXISTS target_table_name AS
SELECT *
FROM profile_dim_date limit 10;
#Insert data only if the table already exists. Check if @mytableexist = 'true'
INSERT INTO target_table_name (
select *
from profile_dim_date
WHERE @mytableexist = 'true' limit 20
) ;
EXCEPTION
WHEN other THEN SELECT 'ERROR';
END $$;
Em linha inline
A variável inline
A função separa os elementos de uma matriz de structs e gera os valores em uma tabela. Ele só pode ser colocado no estado SELECT
ou uma LATERAL VIEW
.
A variável inline
função não é possível ser colocados em uma lista de seleção onde há outras funções geradoras.
Por padrão, as colunas produzidas são nomeadas como "col1", "col2" e assim por diante. Se a expressão for NULL
então nenhuma linha é produzida.
RENAME
comando.Exemplo
> SELECT inline(array(struct(1, 'a'), struct(2, 'b'))), 'Spark SQL';
O exemplo retorna o seguinte:
1 a Spark SQL
2 b Spark SQL
Este segundo exemplo demonstra ainda mais o conceito e a aplicação da inline
função. O modelo de dados para o exemplo está ilustrado na imagem abaixo.
Exemplo
select inline(productListItems) from source_dataset limit 10;
Os valores obtidos de source_dataset
são usados para preencher a tabela do target.
Spark Comandos SQL
A subseção abaixo aborda os comandos do Spark SQL compatíveis com o Serviço de consulta.
DEFINIR
A variável SET
define uma propriedade e retorna o valor de uma propriedade existente ou lista todas as propriedades existentes. Se um valor for fornecido para uma chave de propriedade existente, o valor antigo será substituído.
SET property_key = property_value
property_key
property_value
Para retornar o valor de qualquer configuração, use SET [property key]
sem um property_value
.
PostgreSQL comandos
As subseções abaixo abrangem o PostgreSQL comandos suportados pelo Serviço de consulta.
ANALISAR TABELA analyze-table
A variável ANALYZE TABLE
executa uma análise de distribuição e cálculos estatísticos para a(s) tabela(s) nomeada(s). A utilização de ANALYZE TABLE
varia dependendo se os conjuntos de dados estão armazenados no armazenamento acelerado ou o data lake. Consulte as respectivas seções para obter mais informações sobre o uso.
CALCULAR ESTATÍSTICAS no armazenamento acelerado compute-statistics-accelerated-store
A variável ANALYZE TABLE
comando calcula estatísticas para uma tabela no repositório acelerado. As estatísticas são calculadas sobre consultas CTAS ou ITAS executadas para uma determinada tabela no armazenamento acelerado.
Exemplo
ANALYZE TABLE <original_table_name>
Veja a seguir uma lista de cálculos estatísticos que estão disponíveis após o uso de ANALYZE TABLE
comando:-
field
data-type
count
distinct-count
missing
max
min
mean
stdev
CALCULAR ESTATÍSTICAS no data lake compute-statistics-data-lake
Agora você pode calcular estatísticas em nível de coluna em Azure Data Lake Storage (ADLS) com a variável COMPUTE STATISTICS
Comando SQL. Calcular estatísticas de coluna em todo o conjunto de dados, um subconjunto de um conjunto de dados, todas as colunas ou um subconjunto de colunas.
COMPUTE STATISTICS
estende a ANALYZE TABLE
comando. No entanto, a COMPUTE STATISTICS
, FILTERCONTEXT
, e FOR COLUMNS
não há suporte para comandos em tabelas de armazenamento aceleradas. Essas extensões para o ANALYZE TABLE
atualmente, só há suporte para comandos ADLS.
Exemplo
ANALYZE TABLE tableName FILTERCONTEXT (timestamp >= to_timestamp('2023-04-01 00:00:00') and timestamp <= to_timestamp('2023-04-05 00:00:00')) COMPUTE STATISTICS FOR COLUMNS (commerce, id, timestamp);
A variável FILTER CONTEXT
O comando calcula estatísticas em um subconjunto do conjunto de dados com base na condição de filtro fornecida. A variável FOR COLUMNS
comando direciona colunas específicas para análise.
Statistics ID
e as estatísticas geradas são válidas apenas para cada sessão e não podem ser acessadas em diferentes sessões PSQL.Limitações
- A geração de estatísticas não é suportada para tipos de dados de matriz ou mapa
- As estatísticas calculadas são não persistida nas sessões.
skip_stats_for_complex_datatypes
SET skip_stats_for_complex_datatypes = false
A saída do console é exibida conforme visto abaixo.
| Statistics ID |
| ---------------------- |
| adc_geometric_stats_1 |
(1 row)
Você pode consultar as estatísticas calculadas diretamente fazendo referência à Statistics ID
. Use o Statistics ID
ou o nome do alias como mostrado na instrução de exemplo abaixo, para exibir a saída por completo. Para saber mais sobre esse recurso, consulte a documentação do nome do alias.
-- This statement gets the statistics generated for `alias adc_geometric_stats_1`.
SELECT * FROM adc_geometric_stats_1;
Use o SHOW STATISTICS
comando para exibir os metadados de todas as estatísticas temporárias geradas na sessão. Este comando pode ajudá-lo a refinar o escopo da análise estatística.
SHOW STATISTICS;
Um exemplo de saída de SHOW STATISTICS é visto abaixo.
statsId | tableName | columnSet | filterContext | timestamp
----------------------+---------------+-----------+-----------------------------+--------------------
adc_geometric_stats_1 | adc_geometric | (age) | | 25/06/2023 09:22:26
demo_table_stats_1 | demo_table | (*) | ((age > 25)) | 25/06/2023 12:50:26
age_stats | castedtitanic | (age) | ((age > 25) AND (age < 40)) | 25/06/2023 09:22:26
Consulte a documentação de estatísticas do conjunto de dados para obter mais informações.
TABLESAMPLE tablesample
O Serviço de consulta da Adobe Experience Platform fornece conjuntos de dados de amostra como parte de seus recursos aproximados de processamento de consulta.
As amostras de conjuntos de dados são usadas melhor quando você não precisa de uma resposta exata para uma operação de agregação em um conjunto de dados. Para realizar consultas exploratórias mais eficientes em grandes conjuntos de dados, emitindo uma consulta aproximada para retornar uma resposta aproximada, use o TABLESAMPLE
recurso.
Conjuntos de dados de amostra são criados com amostras aleatórias uniformes de Azure Data Lake Storage (ADLS), usando apenas uma porcentagem dos registros do original. O recurso de amostra do conjunto de dados estende a ANALYZE TABLE
com o comando TABLESAMPLE
e SAMPLERATE
Comandos SQL.
No exemplo abaixo, a linha um demonstra como calcular uma amostra de 5% da tabela. A linha dois demonstra como calcular uma amostra de 5% a partir de uma exibição filtrada dos dados na tabela.
Exemplo
ANALYZE TABLE tableName TABLESAMPLE SAMPLERATE 5;
ANALYZE TABLE tableName FILTERCONTEXT (timestamp >= to_timestamp('2023-01-01')) TABLESAMPLE SAMPLERATE 5:
Consulte a documentação de amostras do conjunto de dados para obter mais informações.
INICIAR
A variável BEGIN
ou, como alternativa, o BEGIN WORK
ou BEGIN TRANSACTION
inicia um bloco de transação. Quaisquer instruções inseridas após o comando begin serão executadas em uma única transação até que um comando COMMIT ou ROLLBACK explícito seja fornecido. Este comando é o mesmo que START TRANSACTION
.
BEGIN
BEGIN WORK
BEGIN TRANSACTION
FECHAR
A variável CLOSE
libera os recursos associados a um cursor aberto. Depois que o cursor for fechado, nenhuma operação subsequente será permitida nele. Um cursor deve ser fechado quando não for mais necessário.
CLOSE name
CLOSE ALL
Se CLOSE name
é usada, name
representa o nome de um cursor aberto que deve ser fechado. Se CLOSE ALL
for usado, todos os cursores abertos serão fechados.
DESALOCAR
Para desalocar uma instrução SQL preparada anteriormente, use o DEALLOCATE
comando. Se você não desalocou explicitamente uma instrução preparada, ela será desalocada quando a sessão terminar. Mais informações sobre instruções preparadas podem ser encontradas no comando PREPARE seção.
DEALLOCATE name
DEALLOCATE ALL
Se DEALLOCATE name
é usada, name
representa o nome da instrução preparada que deve ser desalocada. Se DEALLOCATE ALL
for usado, todas as instruções preparadas serão desalocadas.
DECLARAR
A variável DECLARE
permite que um usuário crie um cursor, que pode ser usado para recuperar um pequeno número de linhas de uma consulta maior. Após a criação do cursor, as linhas são buscadas nele usando FETCH
.
DECLARE name CURSOR FOR query
name
query
SELECT
ou VALUES
comando que fornece as linhas a serem retornadas pelo cursor.EXECUTAR
A variável EXECUTE
é usado para executar uma instrução preparada anteriormente. Como as instruções preparadas só existem durante uma sessão, a instrução preparada deve ter sido criada por um PREPARE
instrução executada anteriormente na sessão atual. Mais informações sobre o uso de instruções preparadas podem ser encontradas no PREPARE
comando seção.
Se a variável PREPARE
que criou a instrução especificou alguns parâmetros, um conjunto compatível de parâmetros deve ser passado para o EXECUTE
declaração. Se esses parâmetros não forem transmitidos, um erro será gerado.
EXECUTE name [ ( parameter ) ]
name
parameter
EXPLICAR
A variável EXPLAIN
exibe o plano de execução da instrução fornecida. O plano de execução mostra como as tabelas referenciadas pela instrução serão verificadas. Se várias tabelas forem referenciadas, ela mostrará quais algoritmos de junção são usados para reunir as linhas necessárias de cada tabela de entrada.
EXPLAIN statement
Para definir o formato da resposta, use o FORMAT
palavra-chave com a EXPLAIN
comando.
EXPLAIN FORMAT { TEXT | JSON } statement
FORMAT
FORMAT
para especificar o formato de saída. As opções disponíveis são TEXT
ou JSON
. A saída não textual contém as mesmas informações que o formato de saída de texto, mas é mais fácil para os programas analisarem. Esse parâmetro é padronizado como TEXT
.statement
SELECT
, INSERT
, UPDATE
, DELETE
, VALUES
, EXECUTE
, DECLARE
, CREATE TABLE AS
ou CREATE MATERIALIZED VIEW AS
cujo plano de execução você deseja ver.SELECT
A instrução pode retornar é descartada quando executada com EXPLAIN
palavra-chave. Outros efeitos colaterais da declaração acontecem como de costume.Exemplo
O exemplo a seguir mostra o plano para uma consulta simples em uma tabela com um único integer
coluna e 10000 linhas:
EXPLAIN SELECT * FROM foo;
QUERY PLAN
---------------------------------------------------------
Seq Scan on foo (dataSetId = "6307eb92f90c501e072f8457", dataSetName = "foo") [0,1000000242,6973776840203d3d,6e616c58206c6153,6c6c6f430a3d4d20,74696d674c746365]
(1 row)
BUSCAR
A variável FETCH
O comando recupera linhas usando um cursor criado anteriormente.
FETCH num_of_rows [ IN | FROM ] cursor_name
num_of_rows
cursor_name
PREPARAR prepare
A variável PREPARE
permite criar uma instrução preparada. Uma instrução preparada é um objeto do lado do servidor que pode ser usado para modelar instruções SQL semelhantes.
As instruções preparadas podem usar parâmetros, que são valores substituídos na instrução quando ela é executada. Os parâmetros são referenciados por posição, usando $1, $2 e assim por diante, ao usar instruções preparadas.
Como opção, você pode especificar uma lista de tipos de dados de parâmetro. Se o tipo de dados de um parâmetro não estiver listado, o tipo poderá ser inferido do contexto.
PREPARE name [ ( data_type [, ...] ) ] AS SELECT
name
data_type
REVERSÃO
A variável ROLLBACK
desfaz a transação atual e descarta todas as atualizações feitas pela transação.
ROLLBACK
ROLLBACK WORK
SELECIONAR EM
A variável SELECT INTO
Este comando cria uma nova tabela e a preenche com dados calculados por uma consulta. Os dados não são retornados ao cliente, como acontece com um SELECT
comando. As novas colunas da tabela têm os nomes e os tipos de dados associados às colunas de saída das SELECT
comando.
[ WITH [ RECURSIVE ] with_query [, ...] ]
SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
* | expression [ [ AS ] output_name ] [, ...]
INTO [ TEMPORARY | TEMP | UNLOGGED ] [ TABLE ] new_table
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY expression [, ...] ]
[ HAVING condition [, ...] ]
[ WINDOW window_name AS ( window_definition ) [, ...] ]
[ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
[ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
[ LIMIT { count | ALL } ]
[ OFFSET start [ ROW | ROWS ] ]
[ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
[ FOR { UPDATE | SHARE } [ OF table_name [, ...] ] [ NOWAIT ] [...] ]
Mais informações sobre os parâmetros de consulta SELECT padrão podem ser encontradas no seção SELECIONAR consulta. Esta seção lista apenas os parâmetros exclusivos do SELECT INTO
comando.
TEMPORARY
ou TEMP
UNLOGGED
new_table
Exemplo
A consulta a seguir cria uma nova tabela films_recent
consistindo somente em entradas recentes da tabela films
:
SELECT * INTO films_recent FROM films WHERE date_prod >= '2002-01-01';
MOSTRAR
A variável SHOW
exibe a configuração atual dos parâmetros de tempo de execução. Essas variáveis podem ser definidas usando o SET
por meio da edição do postgresql.conf
arquivo de configuração, por meio da variável PGOPTIONS
variável de ambiente (ao usar libpq ou um aplicativo baseado em libpq), ou através de sinalizadores de linha de comando ao iniciar o servidor Postgres.
SHOW name
SHOW ALL
name
SERVER_VERSION
: Esse parâmetro mostra o número de versão do servidor.SERVER_ENCODING
: esse parâmetro mostra a codificação do conjunto de caracteres do lado do servidor.LC_COLLATE
: Esse parâmetro mostra a configuração de localidade do banco de dados para agrupamento (ordenação de texto).LC_CTYPE
: Esse parâmetro mostra a configuração de localidade do banco de dados para classificação de caracteres.IS_SUPERUSER
: Este parâmetro mostra se a atribuição atual tem privilégios de superusuário.ALL
Exemplo
A consulta a seguir mostra a configuração atual do parâmetro DateStyle
.
SHOW DateStyle;
DateStyle
-----------
ISO, MDY
(1 row)
COPIAR
A variável COPY
duplica a saída de qualquer SELECT
consulta para um local especificado. O usuário deve ter acesso a esse local para que esse comando tenha êxito.
COPY query
TO '%scratch_space%/folder_location'
[ WITH FORMAT 'format_name']
query
format_name
format_name
pode ser um de parquet
, csv
ou json
. Por padrão, o valor é parquet
.adl://<ADLS_URI>/users/<USER_ID>/acp_foundation_queryService/folder_location/<QUERY_ID>
ALTERAR TABELA alter-table
A variável ALTER TABLE
permite adicionar ou eliminar restrições de chave primária ou estrangeira e adicionar colunas à tabela.
ADICIONAR OU SOLTAR RESTRIÇÃO
As consultas SQL a seguir mostram exemplos de adição ou eliminação de restrições em uma tabela. As restrições de chave primária e chave estrangeira podem ser adicionadas a várias colunas com valores separados por vírgula. Você pode criar chaves compostas transmitindo dois ou mais valores de nome de coluna, como visto nos exemplos abaixo.
Definir chaves primária ou composta
ALTER TABLE table_name ADD CONSTRAINT PRIMARY KEY ( column_name ) NAMESPACE namespace
ALTER TABLE table_name ADD CONSTRAINT PRIMARY KEY ( column_name1, column_name2 ) NAMESPACE namespace
Definir uma relação entre tabelas com base em uma ou mais chaves
ALTER TABLE table_name ADD CONSTRAINT FOREIGN KEY ( column_name ) REFERENCES referenced_table_name ( primary_column_name )
ALTER TABLE table_name ADD CONSTRAINT FOREIGN KEY ( column_name1, column_name2 ) REFERENCES referenced_table_name ( primary_column_name1, primary_column_name2 )
Definir uma coluna de identidade
ALTER TABLE table_name ADD CONSTRAINT PRIMARY IDENTITY ( column_name ) NAMESPACE namespace
ALTER TABLE table_name ADD CONSTRAINT IDENTITY ( column_name ) NAMESPACE namespace
Soltar uma restrição/relação/identidade
ALTER TABLE table_name DROP CONSTRAINT PRIMARY KEY ( column_name )
ALTER TABLE table_name DROP CONSTRAINT PRIMARY KEY ( column_name1, column_name2 )
ALTER TABLE table_name DROP CONSTRAINT FOREIGN KEY ( column_name )
ALTER TABLE table_name DROP CONSTRAINT FOREIGN KEY ( column_name1, column_name2 )
ALTER TABLE table_name DROP CONSTRAINT PRIMARY IDENTITY ( column_name )
ALTER TABLE table_name DROP CONSTRAINT IDENTITY ( column_name )
table_name
column_name
referenced_table_name
primary_column_name
Adicionar ou remover identidades primária e secundária
Para adicionar ou deletar restrições para colunas da tabela de identidade primária e secundária, use o ALTER TABLE
comando.
Os exemplos a seguir adicionam uma identidade primária e uma identidade secundária adicionando restrições.
ALTER TABLE t1 ADD CONSTRAINT PRIMARY IDENTITY (id) NAMESPACE 'IDFA';
ALTER TABLE t1 ADD CONSTRAINT IDENTITY(id) NAMESPACE 'IDFA';
As identidades também podem ser removidas removendo restrições, como visto no exemplo abaixo.
ALTER TABLE t1 DROP CONSTRAINT PRIMARY IDENTITY (c1) ;
ALTER TABLE t1 DROP CONSTRAINT IDENTITY (c1) ;
Para obter informações mais detalhadas, consulte o documento sobre definição de identidades em conjuntos de dados ad hoc.
ADICIONAR COLUNA
As consultas SQL a seguir mostram exemplos de adição de colunas a uma tabela.
ALTER TABLE table_name ADD COLUMN column_name data_type
ALTER TABLE table_name ADD COLUMN column_name_1 data_type1, column_name_2 data_type2
Tipos de dados compatíveis
A tabela a seguir lista os tipos de dados aceitos para adicionar colunas a uma tabela com Postgres SQL, XDM e o Accelerated Database Recovery (ADR) no Azure SQL.
bigint
int8
bigint
integer
int4
integer
smallint
int2
smallint
tinyint
int1
tinyint
varchar(len)
string
varchar(len)
varchar
é melhor usado quando os tamanhos das entradas de dados da coluna variam consideravelmente.double
float8
double precision
FLOAT8
e FLOAT
são sinônimos válidos para DOUBLE PRECISION
. double precision
é um tipo de dados de ponto flutuante. Os valores de ponto flutuante são armazenados em 8 bytes.double precision
float8
double precision
FLOAT8
é um sinônimo válido de double precision
.double precision
é um tipo de dados de ponto flutuante. Os valores de ponto flutuante são armazenados em 8 bytes.date
date
date
date
os tipos de dados são valores de data do calendário armazenados de 4 bytes sem informações de carimbo de data e hora. O intervalo de datas válidas é de 01-01-0001 a 12-31-9999.datetime
datetime
datetime
datetime
inclui os qualificadores de: ano, mês, dia, hora, segundo e fração. A datetime
a declaração pode incluir qualquer subconjunto dessas unidades de tempo que são unidas nessa sequência ou até mesmo incluir apenas uma única unidade de tempo.char(len)
string
char(len)
char(len)
A palavra-chave é usada para indicar que o item tem um caractere de comprimento fixo.ADICIONAR ESQUEMA
A consulta SQL a seguir mostra um exemplo de adição de uma tabela a um banco de dados/esquema.
ALTER TABLE table_name ADD SCHEMA database_name.schema_name
REMOVER ESQUEMA
A consulta SQL a seguir mostra um exemplo de remoção de uma tabela de um banco de dados/esquema.
ALTER TABLE table_name REMOVE SCHEMA database_name.schema_name
Parâmetros
table_name
column_name
data_type
MOSTRAR CHAVES PRIMÁRIAS
A variável SHOW PRIMARY KEYS
lista todas as restrições de chave primária para o banco de dados especificado.
SHOW PRIMARY KEYS
tableName | columnName | datatype | namespace
------------------+----------------------+----------+-----------
table_name_1 | column_name1 | text | "ECID"
table_name_2 | column_name2 | text | "AAID"
MOSTRAR CHAVES ESTRANGEIRAS
A variável SHOW FOREIGN KEYS
lista todas as restrições de chave estrangeira para o banco de dados especificado.
SHOW FOREIGN KEYS
tableName | columnName | datatype | referencedTableName | referencedColumnName | namespace
------------------+---------------------+----------+---------------------+----------------------+-----------
table_name_1 | column_name1 | text | table_name_3 | column_name3 | "ECID"
table_name_2 | column_name2 | text | table_name_4 | column_name4 | "AAID"
MOSTRAR GRUPOS DE DADOS
A variável SHOW DATAGROUPS
comando retorna uma tabela de todos os bancos de dados associados. Para cada banco de dados, a tabela inclui esquema, tipo de grupo, tipo filho, nome filho e ID filho.
SHOW DATAGROUPS
Database | Schema | GroupType | ChildType | ChildName | ChildId
-------------+-------------------+-----------+----------------------+----------------------------------------------------+--------------------------------------
adls_db | adls_scheema | ADLS | Data Lake Table | adls_table1 | 6149ff6e45cfa318a76ba6d3
adls_db | adls_scheema | ADLS | Accelerated Store | _table_demo1 | 22df56cf-0790-4034-bd54-d26d55ca6b21
adls_db | adls_scheema | ADLS | View | adls_view1 | c2e7ddac-d41c-40c5-a7dd-acd41c80c5e9
adls_db | adls_scheema | ADLS | View | adls_view4 | b280c564-df7e-405f-80c5-64df7ea05fc3
MOSTRAR DATAGROUPS PARA tabela
A variável SHOW DATAGROUPS FOR 'table_name'
O comando retorna uma tabela de todos os bancos de dados associados que contêm o parâmetro como filho. Para cada banco de dados, a tabela inclui esquema, tipo de grupo, tipo filho, nome filho e ID filho.
SHOW DATAGROUPS FOR 'table_name'
Parâmetros
table_name
: O nome da tabela para a qual você deseja encontrar bancos de dados associados.
Database | Schema | GroupType | ChildType | ChildName | ChildId
-------------+-------------------+-----------+----------------------+----------------------------------------------------+--------------------------------------
dwh_db_demo | schema2 | QSACCEL | Accelerated Store | _table_demo2 | d270f704-0a65-4f0f-b3e6-cb535eb0c8ce
dwh_db_demo | schema1 | QSACCEL | Accelerated Store | _table_demo2 | d270f704-0a65-4f0f-b3e6-cb535eb0c8ce
qsaccel | profile_aggs | QSACCEL | Accelerated Store | _table_demo2 | d270f704-0a65-4f0f-b3e6-cb535eb0c8ce