Sintaxis SQL en el servicio de consultas
Puede utilizar ANSI SQL estándar para SELECT
instrucciones y otros comandos limitados en Adobe Experience Platform Query Service. Este documento describe la sintaxis SQL admitida por Query Service.
SELECCIONAR consultas select-queries
La siguiente sintaxis define un SELECT
consulta admitida 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 ]
La sección de pestañas a continuación proporciona las opciones disponibles para las palabras clave FROM, GROUP y 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 |
---|
|
Las siguientes subsecciones proporcionan detalles sobre cláusulas adicionales que puede utilizar en las consultas, siempre que sigan el formato descrito anteriormente.
Cláusula SNAPSHOT
Esta cláusula se puede utilizar para leer de forma incremental los datos de una tabla en función de los ID de instantánea. Un ID de instantánea es un marcador de punto de comprobación representado por un número de tipo Long que se aplica a una tabla de lago de datos cada vez que se escriben datos en ella. El SNAPSHOT
se adjunta a la relación de tabla a la que se utiliza junto.
[ SNAPSHOT { SINCE start_snapshot_id | AS OF end_snapshot_id | BETWEEN start_snapshot_id AND end_snapshot_id } ]
Ejemplo
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
La cláusula funciona con una tabla o alias de tabla, pero no sobre una subconsulta o vista. A SNAPSHOT
funciona en cualquier lugar a SELECT
se puede aplicar una consulta en una tabla.
Además, puede utilizar HEAD
y TAIL
como valores de desplazamiento especiales para cláusulas de instantánea. Uso de HEAD
hace referencia a un desplazamiento antes de la primera instantánea, mientras que TAIL
hace referencia a un desplazamiento después de la última instantánea.
resolve_fallback_snapshot_on_failure
) se ha definido:-
Si se establece el indicador de comportamiento de reserva opcional, el servicio de consultas selecciona la instantánea disponible más antigua, la define como la instantánea de inicio y devuelve los datos entre la instantánea disponible más antigua y la instantánea de finalización especificada. Estos datos son inclusivo de la instantánea más antigua disponible.
-
Si no se establece el indicador de comportamiento de reserva opcional, se devuelve un error.
Cláusula WHERE
De forma predeterminada, las coincidencias producidas por un WHERE
Cláusula sobre SELECT
Las consultas distinguen entre mayúsculas y minúsculas. Si desea que las coincidencias distingan entre mayúsculas y minúsculas, puede utilizar la palabra clave ILIKE
en lugar de LIKE
.
[ WHERE condition { LIKE | ILIKE | NOT LIKE | NOT ILIKE } pattern ]
La lógica de las cláusulas LIKE e ILIKE se explica en la siguiente tabla:
WHERE condition LIKE pattern
~~
WHERE condition NOT LIKE pattern
!~~
WHERE condition ILIKE pattern
~~*
WHERE condition NOT ILIKE pattern
!~~*
Ejemplo
SELECT * FROM Customers
WHERE CustomerName ILIKE 'a%';
Esta consulta devuelve clientes con nombres que comienzan por "A" o "a".
UNIRSE
A SELECT
La consulta que utiliza uniones tiene la siguiente sintaxis:
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
UNION, INTERSECT y EXCEPT
El UNION
, INTERSECT
, y EXCEPT
Las cláusulas se utilizan para combinar o excluir como filas de dos o más tablas:
SELECT statement 1
[UNION | UNION ALL | UNION DISTINCT | INTERSECT | EXCEPT | MINUS]
SELECT statement 2
CREAR TABLA COMO SELECCIÓN create-table-as-select
La siguiente sintaxis define un CREATE TABLE AS SELECT
Consulta (CTAS):
CREATE TABLE table_name [ WITH (schema='target_schema_title', rowvalidation='false', label='PROFILE') ] AS (select_query)
schema
rowvalidation
true
.label
profile
para etiquetar el conjunto de datos como habilitado para el perfil. Esto significa que el conjunto de datos se marca automáticamente para el perfil a medida que se crea. Consulte el documento de extensiones de atributos derivadas para obtener más información sobre el uso de label
.select_query
SELECT
declaración. La sintaxis del SELECT
La consulta se puede encontrar en la sección SELECCIONAR consultas.Ejemplo
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
debe tener un alias para las funciones de agregado, como COUNT
, SUM
, MIN
, etc. Además, la variable SELECT
se puede proporcionar con o sin paréntesis (). Puede proporcionar un SNAPSHOT
para leer los deltas incrementales en la tabla de destino.INSERTAR EN
El INSERT INTO
El comando se define de la siguiente manera:
INSERT INTO table_name select_query
table_name
select_query
SELECT
declaración. La sintaxis del SELECT
La consulta se puede encontrar en la sección SELECCIONAR consultas.Ejemplo
INSERT INTO Customers SELECT SupplierName, City, Country FROM OnlineCustomers;
INSERT INTO Customers AS (SELECT * from OnlineCustomers SNAPSHOT AS OF 345)
SELECT
entre paréntesis (). Además, el esquema del resultado del SELECT
debe ajustarse a la de la tabla definida en la variable INSERT INTO
declaración. Puede proporcionar un SNAPSHOT
para leer los deltas incrementales en la tabla de destino.La mayoría de los campos de un esquema XDM real no se encuentran en el nivel raíz y SQL no permite el uso de notación de puntos. Para lograr un resultado realista utilizando campos anidados, debe asignar cada campo en su INSERT INTO
ruta.
Hasta INSERT INTO
rutas anidadas, utilice la sintaxis siguiente:
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]
Ejemplo
INSERT INTO Customers SELECT struct(SupplierName as Supplier, City as SupplierCity, Country as SupplierCountry) _Adobe FROM OnlineCustomers;
SOLTAR TABLA
El DROP TABLE
El comando borra una tabla existente y elimina el directorio asociado a la tabla del sistema de archivos si no se trata de una tabla externa. Si la tabla no existe, se produce una excepción.
DROP TABLE [IF EXISTS] [db_name.]table_name
IF EXISTS
CREAR BASE DE DATOS
El CREATE DATABASE
crea una base de datos de Azure Data Lake Storage (ADLS).
CREATE DATABASE [IF NOT EXISTS] db_name
SOLTAR BASE DE DATOS
El DROP DATABASE
elimina la base de datos de una instancia.
DROP DATABASE [IF EXISTS] db_name
IF EXISTS
SOLTAR ESQUEMA
El DROP SCHEMA
El comando borra un esquema existente.
DROP SCHEMA [IF EXISTS] db_name.schema_name [ RESTRICT | CASCADE]
IF EXISTS
RESTRICT
CASCADE
CREAR VISTA
La siguiente sintaxis define un CREATE VIEW
consulta de un conjunto de datos. Este conjunto de datos puede ser un ADLS o un conjunto de datos de almacén acelerado.
CREATE VIEW view_name AS select_query
view_name
select_query
SELECT
declaración. La sintaxis del SELECT
La consulta se puede encontrar en la sección SELECCIONAR consultas.Ejemplo
CREATE VIEW V1 AS SELECT color, type FROM Inventory
CREATE OR REPLACE VIEW V1 AS SELECT model, version FROM Inventory
La siguiente sintaxis define un CREATE VIEW
consulta que crea una vista en el contexto de una base de datos y un esquema.
Ejemplo
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
declaración. La sintaxis del SELECT
La consulta se puede encontrar en la sección SELECCIONAR consultas.Ejemplo
CREATE VIEW <dbV1 AS SELECT color, type FROM Inventory;
CREATE OR REPLACE VIEW V1 AS SELECT model, version FROM Inventory;
MOSTRAR VISTAS
La siguiente consulta muestra la lista de vistas.
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)
COLOCAR VISTA
La siguiente sintaxis define un DROP VIEW
consulta:
DROP VIEW [IF EXISTS] view_name
IF EXISTS
view_name
Ejemplo
DROP VIEW v1
DROP VIEW IF EXISTS v1
Bloque anónimo anonymous-block
Un bloque anónimo consta de dos secciones: ejecutable y de control de excepciones. En un bloque anónimo, la sección ejecutable es obligatoria. Sin embargo, la sección de control de excepciones es opcional.
El siguiente ejemplo muestra cómo crear un bloque con una o más instrucciones que se van a ejecutar juntas:
$$BEGIN
statementList
[EXCEPTION exceptionHandler]
$$END
exceptionHandler:
WHEN OTHER
THEN statementList
statementList:
: (statement (';')) +
A continuación se muestra un ejemplo con un bloque 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;
Instrucciones condicionales en un bloque anónimo conditional-anonymous-block-statements
La estructura de control IF-THEN-ELSE permite la ejecución condicional de una lista de instrucciones cuando una condición se evalúa como TRUE. Esta estructura de control sólo es aplicable dentro de un bloque anónimo. Si esta estructura se utiliza como comando independiente, se produce un error de sintaxis ("Comando no válido fuera de bloque anónimo").
El siguiente fragmento de código muestra el formato correcto para una instrucción condicional IF-THEN-ELSE en un bloque 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
Ejemplo
El ejemplo siguiente ejecuta 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$$;
Esta estructura se puede utilizar con raise_error();
para devolver un mensaje de error personalizado. El bloque de código que se muestra a continuación finaliza el bloque anónimo con "mensaje de error personalizado".
Ejemplo
$$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$$;
Instrucciones IF anidadas
Las instrucciones IF anidadas se admiten en bloques anónimos.
Ejemplo
$$BEGIN
SET @V = SELECT 1;
IF @V = 1 THEN
SELECT 100;
IF @V > 0 THEN
SELECT 1000;
END IF;
END IF;
END$$;
Bloques de excepción
Los bloques de excepción son compatibles con los bloques anónimos.
Ejemplo
$$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$$;
Automático a JSON auto-to-json
El servicio de consulta admite una configuración opcional de nivel de sesión para devolver campos complejos de nivel superior desde consultas SELECT interactivas como cadenas JSON. El auto_to_json
Esta configuración permite devolver datos de campos complejos como JSON y luego analizarlos en objetos JSON mediante bibliotecas estándar.
ESTABLECER el indicador de funcionalidad auto_to_json
como true antes de ejecutar la consulta SELECT que contiene campos complejos.
set auto_to_json=true;
Antes de configurar el auto_to_json
indicador
En la tabla siguiente se muestra un ejemplo de resultado de consulta antes de auto_to_json
se aplica la configuración. En ambos casos se utilizó la misma consulta SELECT (como se ve a continuación) dirigida a una tabla con campos complejos.
SELECT * FROM TABLE_WITH_COMPLEX_FIELDS LIMIT 2;
Los resultados son los siguientes:
_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)
Después de configurar la variable auto_to_json
indicador
En la tabla siguiente se muestra la diferencia en los resultados que auto_to_json
La configuración de tiene en el conjunto de datos resultante. Se utilizó la misma consulta SELECT en ambos casos.
_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ánea de reserva ante un error resolve-fallback-snapshot-on-failure
El resolve_fallback_snapshot_on_failure
se utiliza para resolver el problema de un ID de instantánea caducado. Los metadatos de la instantánea caducan al cabo de dos días y una instantánea caducada puede invalidar la lógica de un script. Esto puede suponer un problema al utilizar bloques anónimos.
Configure las variables resolve_fallback_snapshot_on_failure
Opción verdadera para anular una instantánea con un ID de instantánea anterior.
SET resolve_fallback_snapshot_on_failure=true;
La siguiente línea de código anula la variable @from_snapshot_id
con el más antiguo disponible snapshot_id
de los metadatos.
$$ 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
$$;
Organización de recursos de datos
Es importante organizar lógicamente los recursos de datos dentro del lago de datos de Adobe Experience Platform a medida que crezcan. El servicio de consultas amplía las construcciones SQL que permiten agrupar lógicamente los recursos de datos en una zona protegida. Este método de organización permite compartir recursos de datos entre esquemas sin necesidad de moverlos físicamente.
Se admiten las siguientes construcciones SQL con sintaxis SQL estándar para organizar lógicamente los datos.
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 la organización lógica de los recursos de datos para obtener una explicación más detallada sobre las prácticas recomendadas del servicio de consultas.
La tabla existe
El table_exists
El comando SQL se utiliza para confirmar si existe actualmente una tabla en el sistema. El comando devuelve un valor booleano: true
si la tabla hace existen, y false
si la tabla tiene no existen.
Al validar si una tabla existe antes de ejecutar las instrucciones, la variable table_exists
simplifica el proceso de escritura de un bloque anónimo para cubrir ambos CREATE
y INSERT INTO
casos de uso.
La siguiente sintaxis define la variable 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 $$;
En línea inline
El inline
separa los elementos de una matriz de estructuras y genera los valores en una tabla. Solo se puede colocar en la SELECT
lista o un LATERAL VIEW
.
El inline
función no puede se colocará en una lista de selección donde haya otras funciones del generador.
De forma predeterminada, las columnas producidas se denominan "col1", "col2", etc. Si la expresión es NULL
a continuación, no se generan filas.
RENAME
comando.Ejemplo
> SELECT inline(array(struct(1, 'a'), struct(2, 'b'))), 'Spark SQL';
El ejemplo devuelve lo siguiente:
1 a Spark SQL
2 b Spark SQL
Este segundo ejemplo demuestra aún más el concepto y la aplicación del inline
función. El modelo de datos del ejemplo se ilustra en la siguiente imagen.
Ejemplo
select inline(productListItems) from source_dataset limit 10;
Los valores tomados del source_dataset
se utilizan para rellenar la tabla de destino.
Spark Comandos SQL
La subsección siguiente cubre los comandos SQL de Spark compatibles con el servicio de consultas.
ESTABLECER
El SET
establece una propiedad y devuelve el valor de una propiedad existente o enumera todas las propiedades existentes. Si se proporciona un valor para una clave de propiedad existente, se anula el valor antiguo.
SET property_key = property_value
property_key
property_value
Para devolver el valor de cualquier configuración, utilice SET [property key]
sin un property_value
.
PostgreSQL comandos
Las subsecciones siguientes tratan sobre PostgreSQL comandos admitidos por el servicio de consultas.
ANALIZAR TABLA analyze-table
El ANALYZE TABLE
realiza un análisis de distribución y cálculos estadísticos para la tabla o tablas con nombre. El uso de ANALYZE TABLE
varía en función de si los conjuntos de datos se almacenan en la variable almacén acelerado o el lago de datos. Consulte sus secciones respectivas para obtener más información sobre su uso.
ESTADÍSTICAS DE CÁLCULO en el almacén acelerado compute-statistics-accelerated-store
El ANALYZE TABLE
El comando calcula las estadísticas de una tabla en el almacén acelerado. Las estadísticas se calculan en consultas CTAS o ITAS ejecutadas para una tabla determinada del almacén acelerado.
Ejemplo
ANALYZE TABLE <original_table_name>
A continuación se muestra una lista de cálculos estadísticos disponibles después de utilizar el ANALYZE TABLE
comando:-
field
data-type
count
distinct-count
missing
max
min
mean
stdev
ESTADÍSTICAS DE CÁLCULO en el lago de datos compute-statistics-data-lake
Ahora puede calcular las estadísticas de nivel de columna de Azure Data Lake Storage Conjuntos de datos de (ADLS) con COMPUTE STATISTICS
Comando SQL. Calcular las estadísticas de columna en todo el conjunto de datos, un subconjunto de un conjunto de datos, todas las columnas o un subconjunto de columnas.
COMPUTE STATISTICS
amplía el ANALYZE TABLE
comando. Sin embargo, la variable COMPUTE STATISTICS
, FILTERCONTEXT
, y FOR COLUMNS
Los comandos de no son compatibles con las tablas de almacenamiento acelerado. Estas extensiones para ANALYZE TABLE
Actualmente, los comandos solo son compatibles con tablas ADLS.
Ejemplo
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);
El FILTER CONTEXT
El comando calcula las estadísticas de un subconjunto del conjunto de datos en función de la condición de filtro proporcionada. El FOR COLUMNS
el comando segmenta columnas específicas para su análisis.
Statistics ID
y las estadísticas generadas solo son válidas para cada sesión y no se puede acceder a ellas en diferentes sesiones de PSQL.Limitaciones:
- La generación de estadísticas no es compatible con los tipos de datos de matriz o asignación
- Las estadísticas calculadas son no persistió entre sesiones.
skip_stats_for_complex_datatypes
SET skip_stats_for_complex_datatypes = false
La salida de la consola aparece como se ve a continuación.
| Statistics ID |
| ---------------------- |
| adc_geometric_stats_1 |
(1 row)
A continuación, puede consultar las estadísticas calculadas directamente haciendo referencia al Statistics ID
. Utilice la variable Statistics ID
o el nombre del alias, como se muestra en la instrucción de ejemplo siguiente, para ver el resultado completo. Para obtener más información acerca de esta función, consulte la documentación del nombre del alias.
-- This statement gets the statistics generated for `alias adc_geometric_stats_1`.
SELECT * FROM adc_geometric_stats_1;
Utilice el SHOW STATISTICS
para mostrar los metadatos de todas las estadísticas temporales generadas en la sesión. Este comando puede ayudarle a refinar el ámbito del análisis estadístico.
SHOW STATISTICS;
A continuación se muestra un ejemplo de salida de SHOW STATISTICS.
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 la documentación de estadísticas de conjuntos de datos para obtener más información.
TABLESAMPLE tablesample
El servicio de consulta de Adobe Experience Platform proporciona conjuntos de datos de ejemplo como parte de sus capacidades aproximadas de procesamiento de consultas.
Las muestras de conjuntos de datos se utilizan mejor cuando no necesita una respuesta exacta para una operación de agregado sobre un conjunto de datos. Para realizar consultas exploratorias más eficientes en conjuntos de datos grandes emitiendo una consulta aproximada para devolver una respuesta aproximada, utilice el TABLESAMPLE
función.
Los conjuntos de datos de muestra se crean con muestras aleatorias uniformes de las existentes Azure Data Lake Storage Conjuntos de datos de (ADLS), utilizando solo un porcentaje de registros del original. La función de ejemplo del conjunto de datos amplía la variable ANALYZE TABLE
con el comando TABLESAMPLE
y SAMPLERATE
Comandos SQL.
En el ejemplo siguiente, la línea uno muestra cómo calcular una muestra del 5 % de la tabla. La línea dos muestra cómo calcular una muestra del 5 % a partir de una vista filtrada de los datos de la tabla.
Ejemplo
ANALYZE TABLE tableName TABLESAMPLE SAMPLERATE 5;
ANALYZE TABLE tableName FILTERCONTEXT (timestamp >= to_timestamp('2023-01-01')) TABLESAMPLE SAMPLERATE 5:
Consulte la documentación de muestras de conjuntos de datos para obtener más información.
COMENZAR
El BEGIN
o, alternativamente, el comando BEGIN WORK
o BEGIN TRANSACTION
, inicia un bloque de transacciones. Cualquier instrucción que se introduzca después del comando begin se ejecutará en una sola transacción hasta que se proporcione un comando COMMIT o ROLLBACK explícito. Este comando es el mismo que START TRANSACTION
.
BEGIN
BEGIN WORK
BEGIN TRANSACTION
CERRAR
El CLOSE
libera los recursos asociados con un cursor abierto. Una vez cerrado el cursor, no se permiten operaciones posteriores. Se debe cerrar un cursor cuando ya no sea necesario.
CLOSE name
CLOSE ALL
If CLOSE name
se utiliza, name
representa el nombre de un cursor abierto que debe cerrarse. If CLOSE ALL
se utiliza, todos los cursores abiertos se cierran.
DESASIGNAR
Para anular la asignación de una instrucción SQL preparada anteriormente, utilice el DEALLOCATE
comando. Si no desasigna explícitamente una instrucción preparada, se desasigna cuando finaliza la sesión. Puede encontrar más información sobre las instrucciones preparadas en la PREPARE, comando sección.
DEALLOCATE name
DEALLOCATE ALL
If DEALLOCATE name
se utiliza, name
representa el nombre de la instrucción preparada que se debe desasignar. If DEALLOCATE ALL
se utiliza, se desasignan todas las instrucciones preparadas.
DECLARAR
El DECLARE
permite al usuario crear un cursor, que puede utilizarse para recuperar un pequeño número de filas de una consulta mayor. Una vez creado el cursor, se recuperan filas de él utilizando FETCH
.
DECLARE name CURSOR FOR query
name
query
SELECT
o VALUES
comando que proporciona las filas que el cursor devolverá.EJECUTAR
El EXECUTE
se utiliza para ejecutar una instrucción preparada previamente. Dado que las declaraciones preparadas sólo existen durante un período de sesiones, la declaración preparada debe haber sido creada por un PREPARE
se ejecutó anteriormente en la sesión actual. Puede encontrar más información sobre el uso de instrucciones preparadas en la PREPARE
mando sección.
Si la variable PREPARE
que creó la instrucción especificó algunos parámetros, se debe pasar un conjunto de parámetros compatible a la instrucción EXECUTE
declaración. Si no se pasan estos parámetros, se generará un error.
EXECUTE name [ ( parameter ) ]
name
parameter
EXPLICAR
El EXPLAIN
muestra el plan de ejecución de la instrucción suministrada. El plan de ejecución muestra cómo se analizarán las tablas a las que hace referencia la sentencia. Si se hace referencia a varias tablas, se muestra qué algoritmos de combinación se utilizan para reunir las filas necesarias de cada tabla de entrada.
EXPLAIN statement
Para definir el formato de la respuesta, utilice el FORMAT
palabra clave con EXPLAIN
comando.
EXPLAIN FORMAT { TEXT | JSON } statement
FORMAT
FORMAT
para especificar el formato de salida. Las opciones disponibles son TEXT
o JSON
. La salida no textual contiene la misma información que el formato de salida de texto, pero es más fácil de analizar para los programas. El valor predeterminado de este parámetro es TEXT
.statement
SELECT
, INSERT
, UPDATE
, DELETE
, VALUES
, EXECUTE
, DECLARE
, CREATE TABLE AS
, o CREATE MATERIALIZED VIEW AS
, cuyo plan de ejecución desea ver.SELECT
La instrucción que podría devolver se descarta cuando se ejecuta con EXPLAIN
palabra clave. Otros efectos secundarios de la declaración ocurren como de costumbre.Ejemplo
En el siguiente ejemplo se muestra el plan para una consulta simple en una tabla con un único integer
filas de columna y 10000:
EXPLAIN SELECT * FROM foo;
QUERY PLAN
---------------------------------------------------------
Seq Scan on foo (dataSetId = "6307eb92f90c501e072f8457", dataSetName = "foo") [0,1000000242,6973776840203d3d,6e616c58206c6153,6c6c6f430a3d4d20,74696d674c746365]
(1 row)
BUSCAR
El FETCH
El comando recupera filas utilizando un cursor creado anteriormente.
FETCH num_of_rows [ IN | FROM ] cursor_name
num_of_rows
cursor_name
PREPARAR prepare
El PREPARE
El comando permite crear una instrucción preparada. Una instrucción preparada es un objeto del lado del servidor que se puede utilizar para crear plantillas de instrucciones SQL similares.
Las instrucciones preparadas pueden tomar parámetros, que son valores que se sustituyen en la instrucción cuando se ejecuta. Se hace referencia a los parámetros por posición, utilizando $1, $2, etc., al utilizar instrucciones preparadas.
De forma opcional, puede especificar una lista de tipos de datos de parámetros. Si el tipo de datos de un parámetro no aparece en la lista, el tipo se puede inferir del contexto.
PREPARE name [ ( data_type [, ...] ) ] AS SELECT
name
data_type
REVERSIÓN
El ROLLBACK
El comando deshace la transacción actual y descarta todas las actualizaciones realizadas por la transacción.
ROLLBACK
ROLLBACK WORK
SELECCIONAR EN
El SELECT INTO
crea una nueva tabla y la rellena con datos calculados por una consulta. Los datos no se devuelven al cliente, como sucede con un SELECT
comando. Las columnas de la nueva tabla tienen los nombres y tipos de datos asociados con las columnas de salida de la variable 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 ] [...] ]
Encontrará más información sobre los parámetros de consulta SELECT estándar en la sección de consulta SELECT. Esta sección solo enumera los parámetros que son exclusivos de SELECT INTO
comando.
TEMPORARY
o TEMP
UNLOGGED
new_table
Ejemplo
La siguiente consulta crea una nueva tabla films_recent
consiste únicamente en entradas recientes de la tabla films
:
SELECT * INTO films_recent FROM films WHERE date_prod >= '2002-01-01';
MOSTRAR
El SHOW
muestra la configuración actual de los parámetros de tiempo de ejecución. Estas variables se pueden configurar con la variable SET
mediante la edición de la postgresql.conf
archivo de configuración, a través de PGOPTIONS
variable de entorno (cuando se utiliza libpq o una aplicación basada en libpq), o mediante indicadores de línea de comandos al iniciar el servidor Postgres.
SHOW name
SHOW ALL
name
SERVER_VERSION
: Este parámetro muestra el número de versión del servidor.SERVER_ENCODING
: Este parámetro muestra la codificación del conjunto de caracteres del lado del servidor.LC_COLLATE
: Este parámetro muestra la configuración regional de la base de datos para la intercalación (orden de texto).LC_CTYPE
: Este parámetro muestra la configuración regional de la base de datos para la clasificación de caracteres.IS_SUPERUSER
: este parámetro muestra si la función actual tiene privilegios de superusuario.ALL
Ejemplo
La siguiente consulta muestra la configuración actual del parámetro DateStyle
.
SHOW DateStyle;
DateStyle
-----------
ISO, MDY
(1 row)
COPIAR
El COPY
El comando duplica la salida de cualquier SELECT
consulta a una ubicación especificada. El usuario debe tener acceso a esta ubicación para que este comando se ejecute correctamente.
COPY query
TO '%scratch_space%/folder_location'
[ WITH FORMAT 'format_name']
query
format_name
format_name
puede ser uno de parquet
, csv
, o json
. El valor predeterminado es parquet
.adl://<ADLS_URI>/users/<USER_ID>/acp_foundation_queryService/folder_location/<QUERY_ID>
MODIFICAR TABLA alter-table
El ALTER TABLE
El comando permite añadir o soltar restricciones de clave principal o externa y añadir columnas a la tabla.
AGREGAR o SOLTAR RESTRICCIÓN
Las siguientes consultas SQL muestran ejemplos de cómo agregar o quitar restricciones a una tabla. Las restricciones de clave principal y clave externa se pueden agregar a varias columnas con valores separados por comas. Puede crear claves compuestas pasando dos o más valores de nombre de columna, tal como se ve en los ejemplos siguientes.
Definir claves principales o compuestas
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 una relación entre tablas basada en una o más claves
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 )
Definición de una columna de identidad
ALTER TABLE table_name ADD CONSTRAINT PRIMARY IDENTITY ( column_name ) NAMESPACE namespace
ALTER TABLE table_name ADD CONSTRAINT IDENTITY ( column_name ) NAMESPACE namespace
Soltar una restricción/relación/identidad
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
Adición o eliminación de identidades principales y secundarias
Para añadir o eliminar restricciones para columnas de tabla de identidad principales y secundarias, utilice el ALTER TABLE
comando.
En los ejemplos siguientes se agregan una identidad principal y una identidad secundaria mediante la adición de restricciones.
ALTER TABLE t1 ADD CONSTRAINT PRIMARY IDENTITY (id) NAMESPACE 'IDFA';
ALTER TABLE t1 ADD CONSTRAINT IDENTITY(id) NAMESPACE 'IDFA';
Las identidades también se pueden eliminar soltando restricciones, como se ve en el ejemplo siguiente.
ALTER TABLE t1 DROP CONSTRAINT PRIMARY IDENTITY (c1) ;
ALTER TABLE t1 DROP CONSTRAINT IDENTITY (c1) ;
Para obtener información más detallada, consulte el documento sobre configuración de identidades en conjuntos de datos ad hoc.
AÑADIR COLUMNA
Las siguientes consultas SQL muestran ejemplos de adición de columnas a una tabla.
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 datos admitidos
En la tabla siguiente se enumeran los tipos de datos aceptados para agregar columnas a una tabla con Postgres SQL, XDM y el Accelerated Database Recovery (ADR) en Azure SQL.
bigint
int8
bigint
integer
int4
integer
smallint
int2
smallint
tinyint
int1
tinyint
varchar(len)
string
varchar(len)
varchar
se utiliza mejor cuando el tamaño de las entradas de datos de la columna varía considerablemente.double
float8
double precision
FLOAT8
y FLOAT
son sinónimos válidos para DOUBLE PRECISION
. double precision
es un tipo de datos de punto flotante. Los valores de punto flotante se almacenan en 8 bytes.double precision
float8
double precision
FLOAT8
es un sinónimo válido para double precision
.double precision
es un tipo de datos de punto flotante. Los valores de punto flotante se almacenan en 8 bytes.date
date
date
date
los tipos de datos son valores de fecha de calendario almacenados de 4 bytes sin información de marca de tiempo. El rango de fechas válidas es del 01-01-0001 al 12-31-9999.datetime
datetime
datetime
datetime
incluye los calificadores de: año, mes, día, hora, segundo y fracción. A datetime
la declaración puede incluir cualquier subconjunto de estas unidades de tiempo que se unan en esa secuencia, o incluso comprender solo una unidad de tiempo.char(len)
string
char(len)
char(len)
palabra clave se utiliza para indicar que el elemento es un carácter de longitud fija.AÑADIR ESQUEMA
La siguiente consulta SQL muestra un ejemplo de adición de una tabla a una base de datos o esquema.
ALTER TABLE table_name ADD SCHEMA database_name.schema_name
QUITAR ESQUEMA
La siguiente consulta SQL muestra un ejemplo de eliminación de una tabla de una base de datos o esquema.
ALTER TABLE table_name REMOVE SCHEMA database_name.schema_name
Parámetros
table_name
column_name
data_type
MOSTRAR CLAVES PRIMARIAS
El SHOW PRIMARY KEYS
El comando enumera todas las restricciones de clave principal de la base de datos determinada.
SHOW PRIMARY KEYS
tableName | columnName | datatype | namespace
------------------+----------------------+----------+-----------
table_name_1 | column_name1 | text | "ECID"
table_name_2 | column_name2 | text | "AAID"
MOSTRAR CLAVES EXTERNAS
El SHOW FOREIGN KEYS
El comando enumera todas las restricciones de clave externa para la base de datos determinada.
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 DATOS
El SHOW DATAGROUPS
El comando devuelve una tabla de todas las bases de datos asociadas. Para cada base de datos, la tabla incluye el esquema, el tipo de grupo, el tipo secundario, el nombre secundario y el ID secundario.
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 GRUPOS DE DATOS PARA LA tabla
El SHOW DATAGROUPS FOR 'table_name'
El comando devuelve una tabla de todas las bases de datos asociadas que contienen el parámetro como elemento secundario. Para cada base de datos, la tabla incluye el esquema, el tipo de grupo, el tipo secundario, el nombre secundario y el ID secundario.
SHOW DATAGROUPS FOR 'table_name'
Parámetros
table_name
: Nombre de la tabla para la que desea buscar bases de datos asociadas.
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