INSERT OVERWRITE - Hologres SQL reference - Hologres - Centro de documentación de Alibaba Cloud

Hologres es compatible con INSERT OVERWRITE mediante el procedimiento almacenado hg_insert_overwrite (V2.0+) y la sintaxis nativa de INSERT OVERWRITE (V3.1+).

Comparación de funciones

El comportamiento de INSERT OVERWRITE varía según el tipo de tabla y el método utilizado:

Tablas no particionadas: se admiten ambos métodos.
Tablas particionadas físicas: utilice el procedimiento almacenado hg_insert_overwrite.
Tablas particionadas lógicas: utilice el procedimiento almacenado hg_insert_overwrite (que internamente llama a INSERT OVERWRITE nativo).
Migración de tablas particionadas físicas a lógicas: Adapt data import nodes.

Tipo de tabla	Elemento de comparación	hg_insert_overwrite	`INSERT OVERWRITE` nativo
Tabla no particionada		Compatible	Compatible
Tabla particionada física	Importar a una tabla padre	Importar con o sin tablas hijas Importar a tablas hijas específicas	No compatible
Tabla particionada física	Importar a una tabla hija	Compatible (se trata como una tabla no particionada)	Compatible (se trata como una tabla no particionada)
Tabla particionada lógica	Importar a la tabla padre (sin especificar una tabla hija)	No compatible	No compatible
Tabla particionada lógica	Importar a una tabla padre (con una tabla hija especificada)	Compatible	Compatible

Nota

Para usar hg_insert_overwrite o INSERT OVERWRITE nativo, asegúrese de que su instancia cumpla con los requisitos de versión. Para más detalles, consulte Upgrade an instance. Si no puede actualizar, use a temporary table to perform an INSERT OVERWRITE operation.

Uso de INSERT OVERWRITE nativo

Descripción general

La función INSERT OVERWRITE nativa está disponible a partir de Hologres V3.1.
La función INSERT OVERWRITE nativa admite los siguientes tipos de tablas:
- Tablas no particionadas.
- Tablas hijas de tablas particionadas físicas (se tratan como tablas no particionadas).
- Tablas particionadas lógicas, con una partición especificada.

Restricciones

La función INSERT OVERWRITE nativa habilita de forma predeterminada las transacciones DML mixtas: SET hg_experimental_enable_transaction = on;. Para obtener información sobre las capacidades de transacción en Hologres, consulte SQL transactions.
- No se pueden combinar instrucciones INSERT OVERWRITE y DDL en la misma transacción.
- Todas las instrucciones DML de una transacción se confirman únicamente cuando se ejecuta COMMIT.
Antes de Hologres V4.0, la función INSERT OVERWRITE nativa no genera registros binarios para las tablas que tienen habilitado el registro binario. A partir de Hologres V4.0, esta sintaxis sí los genera. La generación de registros binarios puede añadir una gran cantidad de sobrecarga de almacenamiento, por lo que se recomienda deshabilitarla si no la necesita. Para deshabilitar la generación de registros binarios a nivel de sesión, ejecute el siguiente comando: SET hg_experimental_generate_binlog = off;.
La atomicidad de lectura se garantiza de forma predeterminada, pero implica una mayor sobrecarga de metadatos y puede aumentar la latencia de DQL (los almacenes virtuales secundarios se ven más afectados). Las operaciones INSERT OVERWRITE de larga duración pueden provocar errores de lectura, como Data version is inconsistent o Insert overwrite version not match.
- Si no requiere atomicidad de lectura, deshabilite el parámetro GUC para las tareas DQL: set hg_experimental_enable_check_data_version=off. En ese caso, una tarea DQL podría analizar una combinación de archivos de datos anteriores y posteriores a la operación INSERT OVERWRITE.
- Si requiere atomicidad de lectura pero debe reducir la latencia de DQL, ejecute las tareas DQL en el almacén virtual principal.

Sintaxis

INSERT OVERWRITE <target_table_name> 
  [ PARTITION (<partition_key> = '<partition_value>') [, ...]]
  VALUES ( <expression>  [, ...] ) [, ...] | <query>;

Parámetros

Parámetro	Obligatorio	Descripción
`target_table_name`	Sí	El nombre de la tabla de destino.
`partition_key` y `partition_value`	No	La clave y el valor de la partición. Son obligatorios para las tablas particionadas lógicas.
`expression`	No	Una expresión o un valor para la columna correspondiente en la tabla de destino.
`query`	No	Una instrucción `SELECT` cuyo resultado sobrescribe los datos de la tabla `target_table_name`. Nota Si `target_table_name` es una tabla particionada lógica y `partition_value` especifica una partición, solo se importarán los datos que pertenezcan a dicha partición. Los datos fuera de la partición especificada se ignoran y la partición se vacía si no se encuentran datos coincidentes.

Ejemplos

Importar a una tabla no particionada

-- Create table A as the target table.
CREATE TABLE public.tablea (
    cid INTEGER NOT NULL,
    cname TEXT,
    code INTEGER
    ,PRIMARY KEY (cid)
);

-- Create table B as the source.
CREATE TABLE public.tableb (
    cid INTEGER NOT NULL,
    cname TEXT,
    code INTEGER
    ,PRIMARY KEY (cid)
);

INSERT INTO public.tableb VALUES(1,'aaa',10001),(2,'bbb','10002');

-- Use the native INSERT OVERWRITE syntax to insert data from table B into table A.
INSERT OVERWRITE public.tablea SELECT * FROM public.tableb;

Importar a una tabla particionada lógica

-- Create table A as the target table.
CREATE TABLE public.tablea(
  a TEXT , 
  b INT, 
  c TIMESTAMP, 
  d TEXT,
  ds TEXT,
  PRIMARY KEY(ds,b)
  )
  LOGICAL PARTITION BY LIST(ds);

-- Create physical partitioned table B for the input.
BEGIN;
CREATE TABLE public.tableb(
  a TEXT, 
  b INT, 
  c TIMESTAMP, 
  d TEXT,
  ds TEXT,
  PRIMARY KEY(ds,b)
  )
  PARTITION BY LIST(ds);
CREATE TABLE public.holo_child_3a PARTITION OF public.tableb FOR VALUES IN('20201215');
CREATE TABLE public.holo_child_3b PARTITION OF public.tableb FOR VALUES IN('20201216');
CREATE TABLE public.holo_child_3c PARTITION OF public.tableb FOR VALUES IN('20201217');
COMMIT;

INSERT INTO public.holo_child_3a VALUES('a',1,'2034-10-19','a','20201215');
INSERT INTO public.holo_child_3b VALUES('b',2,'2034-10-20','b','20201216');
INSERT INTO public.holo_child_3c VALUES('c',3,'2034-10-21','c','20201217');

-- Use the native INSERT OVERWRITE syntax to insert data from table B into table A.
INSERT OVERWRITE public.tablea PARTITION (ds = '20201215') SELECT * FROM public.tableb WHERE ds='20201215';

Implementación de INSERT OVERWRITE mediante `hg_insert_overwrite`

Historial de versiones

A partir de la V3.1, hg_insert_overwrite admite tablas particionadas lógicas (se debe especificar la partición).
A partir de la V3.0, hg_insert_overwrite admite la importación directa a tablas padre.
Tablas con vistas dependientes: en la V2.0.15 y posteriores, habilítelo con: set hg_experimental_hg_insert_overwrite_enable_view=on;. No se admiten tablas con dependencias de Materialized View.

En la V3.0 y posteriores no se requiere ninguna configuración, pero las dependencias de Materialized View siguen sin admitirse.

Si hg_insert_overwrite falla, elimine las tablas temporales manualmente. A partir de la V3.0, utilice el siguiente código SQL.

-- Delete the temporary tables that were created by the system before the time specified by before_time.
CALL hg_clean_insert_overwrite_tmp_tables(before_time::timestamptz);

Restricciones de uso

Las importaciones de un subconjunto de campos deben coincidir con el orden de las columnas de la tabla de origen.
hg_insert_overwrite requiere permisos de propietario de la tabla (solo superusuarios o propietarios de la tabla).
La clave de partición admite los tipos INT, TEXT o VARCHAR.
A partir de la V3.0, hg_insert_overwrite no se puede utilizar dentro de transacciones.

Nota
En versiones anteriores, usar hg_insert_overwrite en una transacción implicaba el riesgo de interbloqueos o bloqueos del sistema.
A partir de la V3.0, la cantidad de columnas y los tipos de datos en sql de hg_insert_overwrite deben coincidir exactamente con target_table. Las discrepancias generan errores como "error: table "hg_alias" has x columns available but x columns specified" or "error: column xx is of type xxx but expression is of type xxx".

Cambios de comportamiento

Si solo se proporcionaban target_table (una tabla padre) y sql:

Antes de la V3.0, esta operación fallaba. A partir de la V3.0, los resultados posibles son los siguientes:

Si todas las tablas hijas presentes en los resultados de sql existen, la operación se completa correctamente.
Si alguna tabla hija no existe, se produce un error.

Sintaxis

-- Before V3.0
CALL hg_insert_overwrite('<target_table>' regclass, ['<partition_value>' TEXT], '<sql>' TEXT);

-- For Hologres V3.0 and later
CALL hg_insert_overwrite('<target_table>' regclass, ['<partition_value>' ARRAY], '<sql>' TEXT, ['<auto_create_partition>' BOOLEAN]);

Parámetros

Nota

A partir de la V3.0, partition_value para hg_insert_overwrite acepta el tipo ARRAY, lo que permite escribir en varias tablas hijas. El tipo TEXT para partition_value sigue siendo compatible, pero se limita a una sola tabla hija.

Parámetro	Descripción
`target_table`	Una tabla interna de Hologres existente.
`partition_value`	La partición de destino. Antes de la V3.0: si `target_table` es una tabla particionada física, `partition_value` (tipo TEXT) es obligatorio. Las particiones inexistentes se crean automáticamente. A partir de la V3.0: si `target_table` es una tabla particionada física, `partition_value` (tipo ARRAY o TEXT) es opcional. Consulte la tabla de comportamiento a continuación. A partir de la V3.1: si `target_table` es una tabla particionada lógica, `partition_value` (tipo ARRAY o TEXT) es obligatorio.
`sql`	Una instrucción `SELECT`. Puede consultar tablas de MaxCompute o de Hologres. Escape las comillas simples con `$$sql$$`. Antes de la V3.0: los resultados deben coincidir exactamente con `partition_value`. A partir de la V3.0: se elimina la limitación anterior. Consulte la tabla de comportamiento a continuación.
`auto_create_partition`	Controla la creación automática de particiones inexistentes. Solo disponible en la V3.0 y posteriores, y exclusivo para tablas particionadas físicas. `TRUE`: crea automáticamente las particiones faltantes encontradas en los resultados de `sql`. `FALSE` (predeterminado): no crea las particiones faltantes.

El comportamiento depende de auto_create_partition y partition_value. Una partición se considera "relevante" si aparece en los resultados de SQL.

Comportamiento de hg_insert_overwrite para tablas particionadas físicas

Valor del parámetro		auto_create_partition
Valor del parámetro		TRUE	FALSE
`partition_value`	No especificado	Particiones relevantes: las particiones existentes se sobrescriben. Las particiones inexistentes se crean automáticamente. Particiones irrelevantes: se ignoran.	Si todas las particiones relevantes ya existen: Las particiones relevantes se sobrescriben. Las particiones irrelevantes se ignoran. Si alguna partición relevante no existe, se genera un error y no se realizan operaciones de sobrescritura en las demás particiones.
`partition_value`	Especificado	Para las particiones especificadas: La partición relevante inexistente se crea automáticamente. Las particiones relevantes existentes se sobrescriben. Los datos de las particiones irrelevantes y existentes se eliminan. Para las particiones no especificadas: Sin efecto.	Para las particiones especificadas: Si alguna partición relevante no existe, se genera un error y no se realizan operaciones de sobrescritura en las demás particiones. Las particiones relevantes existentes se sobrescriben. Las particiones existentes e irrelevantes se vacían. Para las particiones no especificadas: Sin efecto.

Comportamiento de hg_insert_overwrite para tablas particionadas lógicas

Las tablas particionadas lógicas no admiten el particionamiento automático; auto_create_partition se ignora.

Valor del parámetro		Descripción

`partition_value`	No especificado	No compatible.
	Especificado	Para las particiones especificadas: Los datos de la partición relevante se sobrescriben. Las particiones irrelevantes se vacían. Para las particiones no especificadas: Ninguna se ve afectada.

Ejemplos

Ejemplo 1: importar datos a una tabla no particionada

-- Create table A as the target table.
BEGIN;

CREATE TABLE public.tablea (
    cid INTEGER NOT NULL,
    cname TEXT,
    code INTEGER
    ,PRIMARY KEY (cid)
);

CALL set_table_property('public.tablea', 'orientation', 'column');
CALL set_table_property('public.tablea', 'storage_format', 'orc');
CALL set_table_property('public.tablea', 'bitmap_columns', 'cname');
CALL set_table_property('public.tablea', 'dictionary_encoding_columns', 'cname:auto');
CALL set_table_property('public.tablea', 'distribution_key', 'cid');
CALL set_table_property('public.tablea', 'time_to_live_in_seconds', '3153600000');
COMMIT;

-- Create table B for data input.
CREATE TABLE public.tableb (
    cid INTEGER NOT NULL,
    cname TEXT,
    code INTEGER
    ,PRIMARY KEY (cid)
);

INSERT INTO public.tableb VALUES(1,'aaa',10001),(2,'bbb','10002');

-- Insert data from table B into table A.
CALL hg_insert_overwrite('public.tablea' , 'SELECT * FROM public.tableb');

Ejemplo 2: importar datos a una tabla particionada (física y lógica)

-- Create the target table.
BEGIN;
CREATE TABLE public.tableA(
  a TEXT, 
  b INT, 
  c TIMESTAMP, 
  d TEXT,
  ds TEXT,
  PRIMARY KEY(ds,b)
  )
  PARTITION BY LIST(ds);
CALL set_table_property('public.tableA', 'orientation', 'column');
CREATE TABLE public.holo_child_1 PARTITION OF public.tableA FOR VALUES IN('20201215');
CREATE TABLE public.holo_child_2 PARTITION OF public.tableA FOR VALUES IN('20201216');
CREATE TABLE public.holo_child_3 PARTITION OF public.tableA FOR VALUES IN('20201217');
COMMIT;

-- Or, a logical partitioned table.
CREATE TABLE public.tableA_lp(
  a TEXT, 
  b INT, 
  c TIMESTAMP, 
  d TEXT,
  ds TEXT,
  PRIMARY KEY(ds,b)
  )
  LOGICAL PARTITION BY LIST(ds);

-- Create table B for input.
BEGIN;
CREATE TABLE public.tableB(
  a TEXT, 
  b INT, 
  c TIMESTAMP, 
  d TEXT,
  ds TEXT,
  PRIMARY KEY(ds,b)
  )
  PARTITION BY LIST(ds);
CALL set_table_property('public.tableB', 'orientation', 'column');
CREATE TABLE public.holo_child_3a PARTITION OF public.tableB FOR VALUES IN('20201215');
CREATE TABLE public.holo_child_3b PARTITION OF public.tableB FOR VALUES IN('20201216');
CREATE TABLE public.holo_child_3c PARTITION OF public.tableB FOR VALUES IN('20201217');
COMMIT;

INSERT INTO public.holo_child_3a VALUES('a',1,'2034-10-19','a','20201215');
INSERT INTO public.holo_child_3b VALUES('b',2,'2034-10-20','b','20201216');
INSERT INTO public.holo_child_3c VALUES('c',3,'2034-10-21','c','20201217');

-- Physical partitioned table
CALL hg_insert_overwrite('public.tableA' , '{20201215,20201216,20201217}'::text[],$$SELECT * FROM public.tableB$$);
-- Logical partitioned table
CALL hg_insert_overwrite('public.tableA_lp' , '{20201215,20201216,20201217}'::text[],$$SELECT * FROM public.tableB$$);

Ejemplo 3: importar datos de una tabla no particionada de MaxCompute a una tabla no particionada de Hologres

-- Create a non-partitioned table in MaxCompute. This example uses data from the customer table in the public_data project, which is a public dataset in MaxCompute. The following code provides the DDL statement for the table.
CREATE TABLE IF NOT EXISTS public_data.customer(
  c_customer_sk BIGINT,
  c_customer_id STRING,
  c_current_cdemo_sk BIGINT,
  c_current_hdemo_sk BIGINT,
  c_current_addr_sk BIGINT,
  c_first_shipto_date_sk BIGINT,
  c_first_sales_date_sk BIGINT,
  c_salutation STRING,
  c_first_name STRING,
  c_last_name STRING,
  c_preferred_cust_flag STRING,
  c_birth_day BIGINT,
  c_birth_month BIGINT,
  c_birth_year BIGINT,
  c_birth_country STRING,
  c_login STRING,
  c_email_address STRING,
  c_last_review_date STRING,
  useless STRING);

-- Create a foreign table in Hologres to map to the source data table in MaxCompute.
CREATE FOREIGN TABLE customer (
    "c_customer_sk" INT8,
    "c_customer_id" TEXT,
    "c_current_cdemo_sk" INT8,
    "c_current_hdemo_sk" INT8,
    "c_current_addr_sk" INT8,
    "c_first_shipto_date_sk" INT8,
    "c_first_sales_date_sk" INT8,
    "c_salutation" TEXT,
    "c_first_name" TEXT,
    "c_last_name" TEXT,
    "c_preferred_cust_flag" TEXT,
    "c_birth_day" INT8,
    "c_birth_month" INT8,
    "c_birth_year" INT8,
    "c_birth_country" TEXT,
    "c_login" TEXT,
    "c_email_address" TEXT,
    "c_last_review_date" TEXT,
    "useless" TEXT
)
SERVER odps_server
OPTIONS (project_name 'public_data', table_name 'customer');

-- Create an internal table in Hologres, such as a column-oriented table, to receive data from the MaxCompute source table.
BEGIN;
CREATE TABLE public.holo_customer (
 "c_customer_sk" INT8,
 "c_customer_id" TEXT,
 "c_current_cdemo_sk" INT8,
 "c_current_hdemo_sk" INT8,
 "c_current_addr_sk" INT8,
 "c_first_shipto_date_sk" INT8,
 "c_first_sales_date_sk" INT8,
 "c_salutation" TEXT,
 "c_first_name" TEXT,
 "c_last_name" TEXT,
 "c_preferred_cust_flag" TEXT,
 "c_birth_day" INT8,
 "c_birth_month" INT8,
 "c_birth_year" INT8,
 "c_birth_country" TEXT,
 "c_login" TEXT,
 "c_email_address" TEXT,
 "c_last_review_date" TEXT,
 "useless" TEXT
);
COMMIT;

-- Import data into Hologres.
IMPORT FOREIGN SCHEMA <project_name> LIMIT TO
(customer) FROM server odps_server INTO PUBLIC options(if_table_exist 'update');-- Update the foreign table.
SELECT pg_sleep(30);-- Wait for some time before you import data to Hologres. This prevents synchronization failures that are caused by data inconsistency due to slow updates of the metadata cache in Hologres.

CALL  hg_insert_overwrite('holo_customer', 'SELECT * FROM customer where c_birth_year > 1980');

-- Query data from the MaxCompute source table in Hologres.
SELECT * FROM holo_customer limit 10;

Ejemplo 4: importar datos de una tabla particionada de MaxCompute a una partición física de Hologres

-- Create a partitioned table in MaxCompute.
DROP TABLE IF EXISTS odps_sale_detail;

CREATE TABLE IF NOT EXISTS odps_sale_detail 
(
    shop_name STRING
    ,customer_id STRING
    ,total_price DOUBLE
)
PARTITIONED BY 
(
    sale_date STRING
)
;

-- Add the 20210815 partition to the source table.
ALTER TABLE odps_sale_detail ADD IF NOT EXISTS PARTITION(sale_date='20210815')
;

-- Write data to the partition.
INSERT OVERWRITE TABLE odps_sale_detail PARTITION(sale_date='20210815') VALUES 
('s1','c1',100.1),
('s2','c2',100.2),
('s3','c3',100.3)
;

-- Create a foreign table in Hologres to map to the source data table in MaxCompute.
DROP FOREIGN TABLE IF EXISTS odps_sale_detail;

-- Create a foreign table.
IMPORT FOREIGN SCHEMA <maxcompute_project> LIMIT TO
(
    odps_sale_detail
) 
FROM SERVER odps_server INTO public 
OPTIONS(if_table_exist 'error',if_unsupported_type 'error');

-- Create an internal table in Hologres to receive data from the MaxCompute source table.
DROP TABLE IF EXISTS holo_sale_detail;

-- Create a partitioned table (internal table) in Hologres.
BEGIN ;
CREATE TABLE IF NOT EXISTS holo_sale_detail
(
    shop_name TEXT
    ,customer_id TEXT 
    ,total_price FLOAT8
    ,sale_date TEXT
)
PARTITION BY LIST(sale_date);
COMMIT;

-- Import data into Hologres.
CALL hg_insert_overwrite('holo_sale_detail', '20210815', $$SELECT * FROM public.odps_sale_detail WHERE sale_date='20210815'$$);

-- Query data from the MaxCompute source table in Hologres.
SELECT * FROM holo_sale_detail;

Ejemplo 5: importar datos de una tabla particionada de MaxCompute a una tabla particionada física de Hologres

-- Create a partitioned table in MaxCompute.
DROP TABLE IF EXISTS odps_sale_detail;

CREATE TABLE IF NOT EXISTS odps_sale_detail 
(
    shop_name STRING
    ,customer_id STRING
    ,total_price DOUBLE
)
PARTITIONED BY 
(
    sale_date STRING
)
;

-- Add the 20210815 and 20210816 partitions to the source table.
ALTER TABLE odps_sale_detail ADD IF NOT EXISTS PARTITION(sale_date='20210815')
;
ALTER TABLE odps_sale_detail ADD IF NOT EXISTS PARTITION(sale_date='20210816')
;

-- Write data to the partitions.
INSERT OVERWRITE TABLE odps_sale_detail PARTITION(sale_date='20210815') VALUES 
('s1','c1',100.1),
('s2','c2',100.2),
('s3','c3',100.3)
;
INSERT OVERWRITE TABLE odps_sale_detail PARTITION(sale_date='20210816') VALUES 
('s1','c1',100.1),
('s2','c2',100.2),
('s3','c3',100.3)
;

-- Create a foreign table in Hologres to map to the source data table in MaxCompute.
DROP FOREIGN TABLE IF EXISTS odps_sale_detail;

-- Create a foreign table.
IMPORT FOREIGN SCHEMA <maxcompute_project> LIMIT TO
(
    odps_sale_detail
) 
FROM SERVER odps_server INTO public 
OPTIONS(if_table_exist 'error',if_unsupported_type 'error');

-- Create an internal table in Hologres to receive data from the MaxCompute source table.
DROP TABLE IF EXISTS holo_sale_detail;

-- Create a partitioned table (internal table) in Hologres.
BEGIN ;
CREATE TABLE IF NOT EXISTS holo_sale_detail
(
    shop_name TEXT
    ,customer_id TEXT 
    ,total_price FLOAT8
    ,sale_date TEXT
)
PARTITION BY LIST(sale_date);
COMMIT;

-- Import data into Hologres. Do not specify child partitions and set auto_create_partition to TRUE. The system automatically creates two child partitions and imports data.
CALL hg_insert_overwrite ('holo_sale_detail', $$SELECT * FROM public.odps_sale_detail$$, TRUE);

-- Query data in Hologres.
SELECT * FROM holo_sale_detail;

Nota

maxcompute_project: el nombre del proyecto donde se encuentra la tabla particionada de MaxCompute.

Implementación de INSERT OVERWRITE mediante una tabla temporal

Sintaxis

Utilice el siguiente código SQL para implementar INSERT OVERWRITE.

BEGIN ;

-- Clear potential temporary tables.
DROP TABLE IF EXISTS <table_new>;

-- Create a temporary table.
SET hg_experimental_enable_create_table_like_properties=on;
CALL HG_CREATE_TABLE_LIKE ('<table_new>', 'select * from <table>');

COMMIT ;

-- Insert data into the temporary table.
INSERT INTO <table_new> [( <column> [, ...] )]
VALUES ( {<expression>}  [, ...] )
[, ...] | <query>}

ANALYZE <table_new>;

BEGIN ;

-- Delete the old table.
DROP TABLE IF EXISTS  <table>;

-- Rename the temporary table.
ALTER TABLE <table_new> RENAME TO <table>;

COMMIT ;

Parámetros

Parámetro	Descripción
`table_new`	El nombre de la tabla temporal. Admite el formato `Schema.Table`.
`table`	El nombre de la tabla existente. Admite el formato `Schema.Table`
DDL de la tabla temporal	Existen dos formas de crear una tabla temporal: Copiar desde una tabla existente: `SET hg_experimental_enable_create_table_like_properties=on; CALL HG_CREATE_TABLE_LIKE ('<table_new>', 'select * from <table>');` Crear desde cero: `CREATE TABLE IF NOT EXISTS <table_new> ([ { column_name column_type [column_constraints, [...]] \| table_constraints [, ...] } ]); CALL set_table_property('<table_new>', property, value);`

Ejemplos de interacción con MaxCompute

Importar a Hologres (no particionada)

Sobrescriba los datos de Hologres con los resultados por lotes de MaxCompute. Este ejemplo sobrescribe por completo la tabla region de Hologres utilizando odps_region_10g de MaxCompute.

BEGIN ;

-- Clear the existing temporary table.
DROP TABLE IF EXISTS public.region_new;

-- Create a temporary table.
SET hg_experimental_enable_create_table_like_properties=on;
CALL HG_CREATE_TABLE_LIKE ('public.region_new', 'select * from public.region');
COMMIT ;

-- Insert data into the temporary table.
INSERT INTO public.region_new
SELECT *
FROM public.odps_region_10g;

ANALYZE public.region_new;

BEGIN ;

-- Drop the old table.
DROP TABLE IF EXISTS public.region;

-- Rename the temporary table.
ALTER TABLE IF EXISTS public.region_new RENAME TO region;

COMMIT ;

Importar a Hologres (particionada)

Las actualizaciones diarias de una tabla particionada de MaxCompute pueden sobrescribir una tabla particionada de Hologres para corregir los datos en tiempo real con los resultados procesados por lotes. Este ejemplo importa datos de odps_lineitem_10g de MaxCompute (particionada diariamente por ds) a la tabla lineitem de Hologres.

BEGIN ;

-- Clear potential temporary tables.
DROP TABLE IF EXISTS public.lineitem_new_20210101;

-- Create a temporary table.
SET hg_experimental_enable_create_table_like_properties=on;
CALL HG_CREATE_TABLE_LIKE ('public.lineitem_new_20210101', 'select * from public.lineitem');
COMMIT ;

-- Insert data into the temporary table.
INSERT INTO public.lineitem_new_20210101
SELECT *
FROM public.odps_lineitem_10g
WHERE DS = '20210101'

ANALYZE public.lineitem_new_20210101;

BEGIN ;

-- Delete the old partition.
DROP TABLE IF EXISTS public.lineitem_20210101;

-- Rename the temporary table.
ALTER TABLE public.lineitem_new_20210101 RENAME TO lineitem_20210101;

-- Attach the temporary table to the specified partitioned table.
ALTER TABLE public.lineitem ATTACH PARTITION lineitem_20210101 FOR VALUES IN ('20210101');

COMMIT ;

Importar a MaxCompute (no particionada)

Para exportar datos de Hologres (holotable) a mc_holotable de MaxCompute, escriba primero en una tabla temporal y luego cámbiele el nombre para sobrescribir por completo mc_holotable.

-- Create a temporary table for the sink table in MaxCompute.
CREATE  TABLE if not exists mc_holotable_temp(
    age INT,
    job STRING,
    name STRING
);

-- Create a mapping for the temporary table in Hologres.
CREATE FOREIGN TABLE "public"."mapping_holotable_temp" (
 "age" INT,
 "job" TEXT,
 "name" TEXT
)
SERVER odps_server
OPTIONS (project_name 'DLF_test',table_name 'mc_holotable_temp');
-- Update the source table in Hologres.
UPDATE holotable SET "job" = 'president' WHERE "name" = 'Lily';
-- Write the updated data to the mapping of the temporary table.
INSERT INTO mapping_holotable_temp SELECT * FROM holotable;

-- Delete the old sink table in MaxCompute.
DROP TABLE IF EXISTS mc_holotable;
-- Rename the temporary table to the sink table.
ALTER TABLE mc_holotable_temp RENAME TO mc_holotable;

La importación de datos admite tanto la importación parcial como la completa:

Exportación de algunos campos:

INSERT INTO mapping_holotable_temp
SELECT x,x,x FROM holotable;  --You can replace x,x,x with the names of the fields that you want to export.

Exportación de todos los campos:

INSERT INTO mapping_holotable_temp
SELECT * FROM holotable;

Comparación de funciones

Uso de INSERT OVERWRITE nativo

Descripción general

Restricciones

Sintaxis

Parámetros

Ejemplos

Importar a una tabla no particionada

Importar a una tabla particionada lógica

Implementación de INSERT OVERWRITE mediante hg_insert_overwrite

Historial de versiones

Restricciones de uso

Cambios de comportamiento

Sintaxis

Parámetros

Ejemplos

Ejemplo 1: importar datos a una tabla no particionada

Ejemplo 2: importar datos a una tabla particionada (física y lógica)

Ejemplo 3: importar datos de una tabla no particionada de MaxCompute a una tabla no particionada de Hologres

Ejemplo 4: importar datos de una tabla particionada de MaxCompute a una partición física de Hologres

Ejemplo 5: importar datos de una tabla particionada de MaxCompute a una tabla particionada física de Hologres

Implementación de INSERT OVERWRITE mediante una tabla temporal

Sintaxis

Parámetros

Ejemplos de interacción con MaxCompute

Importar a Hologres (no particionada)

Importar a Hologres (particionada)

Importar a MaxCompute (no particionada)

Implementación de INSERT OVERWRITE mediante `hg_insert_overwrite`