O Spark é um mecanismo de análise unificado para processamento de dados em grande escala. O Hologres integra-se eficientemente ao Spark da comunidade e ao EMR Serverless Spark para construir rapidamente um data warehouse. O conector Spark do Hologres permite criar um catálogo Hologres em um cluster Spark. Isso viabiliza leituras e importações em lote de alto desempenho usando tabelas externas, superando o JDBC nativo.
Limitações
O conector Spark exige a versão 1.3 ou posterior do Hologres. Verifique a versão da sua instância na página Instance Details no console do Hologres. Se a sua instância for anterior à versão 1.3, atualize sua instância ou entre no grupo DingTalk do Hologres para solicitar uma atualização. Para mais informações, consulte Como obter mais suporte online?.
Pré-requisitos
-
Utilize um ambiente Spark capaz de executar os comandos
spark-sql,spark-shelloupyspark. Use o Spark 3.3.0 ou posterior para evitar problemas de dependência e acessar mais recursos.Use o Alibaba Cloud EMR Spark para configurar rapidamente um ambiente Spark e conectar-se a uma instância Hologres. Para mais informações, consulte Recursos do EMR Spark.
Como alternativa, configure um ambiente Spark independente. Para mais informações, consulte Apache Spark.
Para ler e gravar no Hologres com Spark, use o conector
hologres-connector-spark-3.x. Este tópico usa a versão 1.5.2 como exemplo, disponível para baixe no Repositório Central Maven. O conector é open source. Para mais informações, consulte Hologres-Connectors.-
Para desenvolver e depurar localmente jobs Spark em Java com uma IDE como IntelliJ IDEA, adicione a seguinte dependência Maven ao seu arquivo pom.xml.
<dependency> <groupId>com.alibaba.hologres</groupId> <artifactId>hologres-connector-spark-3.x</artifactId> <version>1.5.2</version> <classifier>jar-with-dependencies</classifier> </dependency>
Catálogo Hologres
O conector Hologres 1.5.2 e posteriores oferece suporte a catálogos Hologres, permitindo o uso de tabelas externas para leitura e gravação no Hologres.
Cada catálogo Hologres no Spark mapeia para um banco de dados no Hologres. Cada namespace em um catálogo Hologres mapeia para um schema no banco de dados correspondente. As seções a seguir explicam como usar catálogos Hologres no Spark.
Os catálogos Hologres não oferecem suporte à criação de tabelas.
Este tópico utiliza o seguinte banco de dados e tabelas em uma instância Hologres:
test_db -- Database
public.test_table1 -- Table in the public schema
public.test_table2
test_schema.test_table3 -- Table in the test_schema schema
Inicializar um catálogo Hologres
Inicie o spark-sql no cluster Spark, carregue o conector Hologres e especifique os parâmetros do catálogo.
spark-sql --jars hologres-connector-spark-3.x-1.5.2-jar-with-dependencies.jar \
--conf spark.sql.catalog.hologres_external_test_db=com.alibaba.hologres.spark3.HoloTableCatalog \
--conf spark.sql.catalog.hologres_external_test_db.username=*** \
--conf spark.sql.catalog.hologres_external_test_db.password=*** \
--conf spark.sql.catalog.hologres_external_test_db.jdbcurl=jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db
Comandos do catálogo Hologres
-
Carregar um catálogo Hologres
Um catálogo Hologres no Spark mapeia para um banco de dados Hologres. Esse mapeamento é fixo durante toda a sessão.
USE hologres_external_test_db; -
Consultar todos os namespaces
Um namespace no Spark mapeia para um schema no Hologres. O schema padrão é public. Use o comando
USEpara alterar o schema padrão.-- View all namespaces in the Hologres Catalog, which correspond to the schemas in the Hologres database. SHOW NAMESPACES; -
Consultar tabelas em um namespace
-
Listar todas as tabelas
SHOW TABLES; -
Listar tabelas em um namespace específico
USE test_schema; SHOW TABLES; -- Or, use the following statement. SHOW TABLES IN test_schema;
-
-
Ler e gravar em uma tabela
Utilize instruções SELECT e INSERT para ler e gravar em tabelas externas.
-- Read from the table. SELECT * FROM public.test_table1; -- Write to the table. INSERT INTO test_schema.test_table3 SELECT * FROM public.test_table1;
Importar dados para o Hologres
Os dados de teste nesta seção provêm da tabela customer em um conjunto de dados TPC-H. O Spark pode ler dados de um arquivo CSV e gravá-los em uma tabela Hologres. Baixe os dados de amostra customer. A instrução SQL a seguir cria a tabela customer_holo_table.
CREATE TABLE customer_holo_table
(
c_custkey BIGINT ,
c_name TEXT ,
c_address TEXT ,
c_nationkey INT ,
c_phone TEXT ,
c_acctbal DECIMAL(15,2) ,
c_mktsegment TEXT ,
c_comment TEXT
);
Importação usando Spark-SQL
No Spark-SQL, utilizar um catálogo para carregar metadados de tabelas Hologres é mais prático. Também é possível declarar uma tabela Hologres criando uma tabela temporária.
Versões do conector Spark do Hologres anteriores a 1.5.2 não suportam catálogos. Nesse caso, declare a tabela Hologres apenas por meio da criação de uma tabela temporária.
Para mais informações sobre os parâmetros do conector Spark do Hologres, consulte parâmetros.
-
Inicialize um catálogo Hologres.
spark-sql --jars hologres-connector-spark-3.x-1.5.2-jar-with-dependencies.jar \ --conf spark.sql.catalog.hologres_external_test_db=com.alibaba.hologres.spark3.HoloTableCatalog \ --conf spark.sql.catalog.hologres_external_test_db.username=*** \ --conf spark.sql.catalog.hologres_external_test_db.password=*** \ --conf spark.sql.catalog.hologres_external_test_db.jdbcurl=jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db -
Importe dados de uma fonte CSV para uma tabela Hologres.
NotaA sintaxe INSERT INTO no Spark não suporta o uso de
column_listpara especificar um subconjunto de colunas. Por exemplo, não é possível usarINSERT INTO hologresTable(c_custkey) SELECT c_custkey FROM csvTablepara gravar dados apenas no campo c_custkey.Se desejar gravar dados em campos específicos, utilize a instrução
CREATE TEMPORARY VIEWpara declarar uma view temporária do Hologres contendo apenas os campos necessários.Usando um catálogo
-- Load a Hologres catalog. USE hologres_external_test_db; -- Create a CSV data source. CREATE TEMPORARY VIEW csvTable ( c_custkey BIGINT, c_name STRING, c_address STRING, c_nationkey INT, c_phone STRING, c_acctbal DECIMAL(15, 2), c_mktsegment STRING, c_comment STRING) USING csv OPTIONS ( path "resources/customer", sep "," -- For local testing, use the absolute path to the file. ); -- Write data from the CSV table to Hologres. INSERT INTO public.customer_holo_table SELECT * FROM csvTable;Usando uma view temporária
-- Create a CSV data source. CREATE TEMPORARY VIEW csvTable ( c_custkey BIGINT, c_name STRING, c_address STRING, c_nationkey INT, c_phone STRING, c_acctbal DECIMAL(15, 2), c_mktsegment STRING, c_comment STRING) USING csv OPTIONS ( path "resources/customer", sep "," ); -- Create a Hologres temporary view. CREATE TEMPORARY VIEW hologresTable ( c_custkey BIGINT, c_name STRING, c_phone STRING) USING hologres OPTIONS ( jdbcurl "jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db", username "***", password "***", table "customer_holo_table" ); INSERT INTO hologresTable SELECT c_custkey,c_name,c_phone FROM csvTable;
Importação usando DataFrame
Ferramentas como spark-shell ou pyspark permitem desenvolver jobs Spark e chamar a API write para gravar dados. O job lê dados de um arquivo CSV, converte-os em um DataFrame e, em seguida, grava o DataFrame em uma instância Hologres. As seções a seguir fornecem exemplos de código para diferentes linguagens de programação. Para mais informações sobre os parâmetros do conector Spark do Hologres, consulte parâmetros.
Scala
import org.apache.spark.sql.types._
import org.apache.spark.sql.SaveMode
// The schema of the CSV source.
val schema = StructType(Array(
StructField("c_custkey", LongType),
StructField("c_name", StringType),
StructField("c_address", StringType),
StructField("c_nationkey", IntegerType),
StructField("c_phone", StringType),
StructField("c_acctbal", DecimalType(15, 2)),
StructField("c_mktsegment", StringType),
StructField("c_comment", StringType)
))
// Read data from a CSV file into a DataFrame.
val csvDf = spark.read.format("csv").schema(schema).option("sep", ",").load("resources/customer")
// Write the DataFrame to Hologres.
csvDf.write
.format("hologres")
.option("username", "***")
.option("password", "***")
.option("jdbcurl", "jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db")
.option("table", "customer_holo_table")
.mode(SaveMode.Append)
.save()
Java
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.types.*;
import org.apache.spark.sql.SaveMode;
import java.util.Arrays;
import java.util.List;
public class SparkTest {
public static void main(String[] args) {
// The schema of the CSV source.
List<StructField> asList =
Arrays.asList(
DataTypes.createStructField("c_custkey", DataTypes.LongType, true),
DataTypes.createStructField("c_name", DataTypes.StringType, true),
DataTypes.createStructField("c_address", DataTypes.StringType, true),
DataTypes.createStructField("c_nationkey", DataTypes.IntegerType, true),
DataTypes.createStructField("c_phone", DataTypes.StringType, true),
DataTypes.createStructField("c_acctbal", new DecimalType(15, 2), true),
DataTypes.createStructField("c_mktsegment", DataTypes.StringType, true),
DataTypes.createStructField("c_comment", DataTypes.StringType, true));
StructType schema = DataTypes.createStructType(asList);
// Run in local mode.
SparkSession spark = SparkSession.builder()
.appName("Spark CSV Example")
.master("local[*]")
.getOrCreate();
// Read data from a CSV file into a DataFrame.
// For local testing, use the absolute path to the customer data.
Dataset<Row> csvDf = spark.read().format("csv").schema(schema).option("sep", ",").load("resources/customer");
// Write the DataFrame to Hologres.
csvDf.write.format("hologres").option(
"username", "***").option(
"password", "***").option(
"jdbcurl", "jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db").option(
"table", "customer_holo_table").mode(
"append").save();
}
}
Adicione a seguinte dependência ao seu arquivo pom.xml.
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-sql_2.13</artifactId>
<version>3.5.4</version>
<scope>provided</scope>
</dependency>
Python
from pyspark.sql.types import *
# The schema of the CSV source.
schema = StructType([
StructField("c_custkey", LongType()),
StructField("c_name", StringType()),
StructField("c_address", StringType()),
StructField("c_nationkey", IntegerType()),
StructField("c_phone", StringType()),
StructField("c_acctbal", DecimalType(15, 2)),
StructField("c_mktsegment", StringType()),
StructField("c_comment", StringType())
])
# Read data from a CSV file into a DataFrame.
csvDf = spark.read.csv("resources/customer", header=False, schema=schema, sep=',')
# Write the DataFrame to Hologres.
csvDf.write.format("hologres").option(
"username", "***").option(
"password", "***").option(
"jdbcurl", "jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db").option(
"table", "customer_holo_table").mode(
"append").save()
Para executar os jobs Spark em diferentes linguagens, siga estas etapas:
-
Scala
-
Crie um arquivo
sparktest.scalacom o código de exemplo e execute os comandos abaixo para rodar o job.-- Load dependencies. spark-shell --jars hologres-connector-spark-3.x-1.5.2-jar-with-dependencies.jar -- For local testing, use the absolute path to load the file. scala> :load D:/sparktest.scala Alternativamente, cole o código de exemplo diretamente no shell para executá-lo após carregar as dependências.
-
-
Java
Utilize uma ferramenta de desenvolvimento para importar o código de exemplo e empacotá-lo com Maven. Por exemplo, se o arquivo JAR de saída for
spark_test.jar, execute o comando a seguir para rodar o job.-- Use the absolute path to the job JAR package. spark-submit --class SparkTest --jars hologres-connector-spark-3.x-1.5.2-jar-with-dependencies.jar D:\spark_test.jar -
Python
Após executar o comando abaixo, cole o código de exemplo no shell para executá-lo.
pyspark --jars hologres-connector-spark-3.x-1.5.2-jar-with-dependencies.jar
Leitura de dados do Hologres
A partir da versão 1.3.2, o conector Spark suporta leitura de dados do Hologres. Em comparação com o
jdbc-connectorpadrão do Spark, ospark-connectoroferece melhor desempenho ao ler dados em paralelo com base nos shards de uma tabela Hologres. O paralelismo de leitura está relacionado ao número de shards na tabela. Ospark-connectorpode limitar o paralelismo usando o parâmetroread.max_task_count. O job gera, no final,Min(shardCount, max_task_count)tarefas de leitura. Ele também suporta inferência de schema. Se você não fornecer um schema, ele inferirá o schema Spark a partir do schema da tabela Hologres.Desde a versão 1.5.0 do conector Spark, a leitura de dados de tabelas Hologres suporta pushdown de predicado, pushdown de LIMIT e poda de colunas. Também é possível usar uma
SELECT QUERYdo Hologres para ler dados. Essa versão introduz o modo de leitura em lote, que melhora o desempenho de leitura em 3 a 4 vezes em comparação às versões anteriores.
Leitura de dados usando Spark SQL
Ao usar Spark SQL, carregue os metadados de uma tabela Hologres utilizando um catálogo. Como alternativa, declare uma tabela Hologres criando uma tabela temporária.
Versões do conector Spark do Hologres anteriores a 1.5.2 não suportam catálogos. Declare a tabela Hologres apenas criando uma tabela temporária.
Para mais informações sobre os parâmetros do conector Spark do Hologres, consulte Parâmetros.
-
Inicialize um catálogo Hologres.
spark-sql --jars hologres-connector-spark-3.x-1.5.2-jar-with-dependencies.jar \ --conf spark.sql.catalog.hologres_external_test_db=com.alibaba.hologres.spark3.HoloTableCatalog \ --conf spark.sql.catalog.hologres_external_test_db.username=*** \ --conf spark.sql.catalog.hologres_external_test_db.password=*** \ --conf spark.sql.catalog.hologres_external_test_db.jdbcurl=jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db -
Leia dados do Hologres.
-
Leitura de dados usando um catálogo.
-- Load the Hologres catalog. USE hologres_external_test_db; -- Read data from the Hologres table. Field pruning and predicate pushdown are supported. SELECT c_custkey,c_name,c_phone FROM public.customer_holo_table WHERE c_custkey < 500 LIMIT 10; -
Leitura de dados através da criação de uma tabela temporária.
Tabela
CREATE TEMPORARY VIEW hologresTable USING hologres OPTIONS ( jdbcurl "jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db", username "***", password "***", read.max_task_count "80", -- The maximum number of tasks to use for reading from the Hologres table. table "customer_holo_table" ); -- Field pruning and predicate pushdown are supported. SELECT c_custkey,c_name,c_phone FROM hologresTable WHERE c_custkey < 500 LIMIT 10;Consulta
CREATE TEMPORARY VIEW hologresTable USING hologres OPTIONS ( jdbcurl "jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db", username "***", password "***", read.query "SELECT c_custkey,c_name,c_phone FROM customer_holo_table WHERE c_custkey < 500 LIMIT 10" ); SELECT * FROM hologresTable LIMIT 5;
-
Leitura de dados do Hologres para um DataFrame
Ao desenvolver jobs Spark com ferramentas como spark-shell ou pyspark, chame a API read do Spark para carregar dados em um DataFrame. Os exemplos a seguir mostram como ler dados de uma tabela Hologres para um DataFrame em diferentes linguagens de programação. Para mais informações sobre os parâmetros do conector Spark do Hologres, consulte Parâmetros.
Scala
val readDf = (
spark.read
.format("hologres")
.option("username", "***")
.option("password", "***")
.option("jdbcurl", "jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db")
.option("table", "customer_holo_table")
.option("read.max_task_count", "80") // The maximum number of tasks to use for reading from the Hologres table.
.load()
.filter("c_custkey < 500")
)
readDf.select("c_custkey", "c_name", "c_phone").show(10)
Java
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;
public class SparkSelect {
public static void main(String[] args) {
// Run in local mode.
SparkSession spark = SparkSession.builder()
.appName("Spark CSV Example")
.master("local[*]")
.getOrCreate();
Dataset<Row> readDf = (
spark.read
.format("hologres")
.option("username", "***")
.option("password", "***")
.option("jdbcurl", "jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db")
.option("table", "customer_holo_table")
.option("read.max_task_count", "80") // The maximum number of tasks to use for reading from the Hologres table.
.load()
.filter("c_custkey < 500")
);
readDf.select("c_custkey", "c_name", "c_phone").show(10);
}
}
Adicione a seguinte dependência ao seu arquivo Maven pom.xml.
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-sql_2.13</artifactId>
<version>3.5.4</version>
<scope>provided</scope>
</dependency>
Python
readDf = spark.read.format("hologres").option(
"username", "***").option(
"password", "***").option(
"jdbcurl", "jdbc:postgresql://hgpostcn-cn-***-vpc-st.hologres.aliyuncs.com:80/test_db").option(
"table", "customer_holo_table").option(
"read.max_task_count", "80").load()
readDf.select("c_custkey", "c_name", "c_phone").show(10)
Para executar jobs Spark em diferentes linguagens de programação:
-
Scala
-
Crie um arquivo
sparkselect.scalacom o código de exemplo e execute o job com o comando a seguir.-- Load dependencies. spark-shell --jars hologres-connector-spark-3.x-1.5.2-jar-with-dependencies.jar -- For local testing, use an absolute path to load the file. scala> :load D:/sparkselect.scala Alternativamente, após carregar as dependências, cole o código de exemplo diretamente no shell para executá-lo.
-
-
Java
Utilize uma ferramenta de desenvolvimento para importar o código de exemplo e empacotá-lo usando Maven. Por exemplo, se o JAR empacotado for nomeado
spark_select.jar, execute o job com o comando a seguir.-- Use an absolute path for the job JAR. spark-submit --class SparkSelect --jars hologres-connector-spark-3.x-1.5.2-jar-with-dependencies.jar D:\spark_select.jar -
Python
Após executar o comando abaixo, cole o código de exemplo diretamente no shell para executá-lo.
pyspark --jars hologres-connector-spark-3.x-1.5.2-jar-with-dependencies.jar -
O AccessKey ID da sua conta Alibaba Cloud. Obtenha-o na página AccessKey Management.
-
Alternativamente, o nome da conta de usuário. Após criar uma conta, conceda a ela as permissões necessárias no banco de dados. Para mais informações, consulte Modelo de permissões do Hologres. Em seguida, conecte-se ao HoloWeb e execute consultas para verificar as permissões.
-
O AccessKey Secret correspondente ao seu AccessKey ID. Para mais informações, consulte Criar um AccessKey.
-
Alternativamente, a senha da conta.
-
auto(Padrão): O conector seleciona automaticamente o modo ideal com base na versão do Hologres e nos metadados da tabela de destino. A lógica de seleção é a seguinte:-
Se a instância Hologres for v2.2.25 ou posterior e a tabela tiver uma chave primária, o modo
bulk_load_on_conflictserá utilizado. -
Se a instância Hologres for v2.1.0 ou posterior e a tabela não tiver uma chave primária, o modo
bulk_loadserá utilizado. -
Se a instância Hologres for v1.3 ou posterior, o modo
streamserá utilizado. -
Nos demais casos, o modo
insertserá utilizado.
-
-
stream: Utiliza Fixed Plan para acelerar a execução de SQL. Em um Fixed Plan,COPYé um recurso introduzido no Hologres v1.3. Comparado ao métodoINSERT, oCOPYoferece maior throughput (devido à sua natureza de streaming), menor latência de dados e consumo reduzido de memória do cliente (pois não faz batch de dados).NotaRequer conector Hologres v1.3.0 ou posterior e Hologres v1.3.34 ou posterior.
-
bulk_load: UtilizaCOPYem lote. Comparado aoCOPYvia streaming em um Fixed Plan, oCOPYem lote impõe uma carga menor à instância Hologres sob condições de alto RPS, mas suporta apenas gravação em tabelas sem chave primária.NotaRequer conector Hologres v1.4.2 ou posterior e Hologres v2.1.0 ou posterior.
-
bulk_load_on_conflict: UtilizaCOPYem lote para gravar em tabelas com chave primária e consegue lidar com chaves primárias duplicadas. Por padrão, a importação de dados em lote para uma tabela Hologres com chave primária aciona um bloqueio de tabela, limitando operações de gravação simultâneas de múltiplas conexões. O conector pode redistribuir os dados pela chave de distribuição da tabela de destino, permitindo que cada tarefa Spark grave em um único shard. Isso reduz o bloqueio de tabela para um bloqueio no nível de shard, habilitando gravações concorrentes e melhorando o desempenho de gravação. Como cada conexão mantém dados de apenas alguns shards, essa otimização também reduz significativamente o número de arquivos pequenos e diminui o uso de memória do Hologres. Testes mostram que reparticionar dados antes de uma gravação concorrente pode reduzir a carga do sistema em cerca de 67% em comparação ao modostream.NotaRequer conector Hologres v1.4.2 ou posterior e Hologres v2.2.25 ou posterior.
-
insert: Grava dados usando o métodoINSERT. -
stage: Usa uma tabela Stage para gravações em lote. Este modo importa dados em tempo quase real através de um estágio de armazenamento temporário e depois carrega os dados na tabela de destino usando uma instruçãoINSERT FROM SELECT. Em cenários de lote, este modo oferece melhor desempenho e menor carga no sistema do que outros modos. Ele também suporta o uso de recursos de computação serverless. Tanto operaçõesINSERT INTOquantoINSERT OVERWRITEsão suportadas. Requer Hologres v4.1.0 ou posterior e conector v1.6.1 ou posterior. -
INSERT_OR_IGNORE: Se ocorrer um conflito de chave primária, os dados não serão gravados.
-
INSERT_OR_UPDATE: Se ocorrer um conflito de chave primária, as colunas especificadas serão atualizadas.
-
INSERT_OR_REPLACE: Se ocorrer um conflito de chave primária, todas as colunas serão atualizadas.
-
auto(Padrão): O conector seleciona automaticamente o modo ideal com base na versão do Hologres e nos metadados da tabela. A lógica de seleção é a seguinte:-
Se os campos a serem lidos incluírem o tipo de dados
JSONB, o modoselectserá utilizado. -
Se a instância for v3.0.24 ou posterior, o modo bulk_read_compressed será utilizado.
-
Nos demais casos, o modo bulk_read será utilizado.
-
-
bulk_read: Utiliza o métodoCOPY OUTpara ler dados no formatoarrow, que é várias vezes mais rápido que o modoselect. Atualmente, não há suporte para leitura do tipoJSONBdo Hologres. -
bulk_read_compressed: Lê dados compactados no formatoArrowusando o método COPY OUT, economizando aproximadamente 45% de largura de banda em comparação à leitura de dados não compactados. -
select: Utiliza instruçõesSELECTpadrão para ler dados. -
Ao ler dados usando o método
query, apenas uma única tarefa pode ser utilizada. Não há suporte para pushdown de predicado. -
Ao ler dados usando o método
table, a operação de leitura é dividida em múltiplas Tasks que rodam em paralelo com base no ShardCount da tabela Hologres. -
auto(padrão): O conector seleciona automaticamente a estratégia ideal. -
shard: Fragmenta os dados com base nos shards do Hologres, e cada tarefa lê uma parte dos shards. Adequado para tabelas com distribuição clara de shards. -
range: Fragmenta os dados com base no intervalo de valores de uma coluna especificada. Esta configuração requer os parâmetrosread.split.column,read.split.lower_bound,read.split.upper_bounderead.split.num. -
partitionfragmenta os dados com base nos valores da coluna de partição. Esta opção deve ser usada com os parâmetrosread.split.columneread.split.num. Aplica-se a tabelas particionadas ou views particionadas. Paralelismo do Spark, ou seja, o número de tarefas concorrentes executadas durante o job, visíveis na UI do Spark.
-
O número de conexões usadas por tarefa:
Ao gravar no modo COPY, cada tarefa usa uma conexão JDBC.
Ao gravar no modo INSERT, cada tarefa usa
write_thread_sizeconexões JDBC.Ao ler dados, cada tarefa usa uma conexão JDBC.
Outras operações: Um job pode usar brevemente uma conexão para tarefas como obtenção de schema ao iniciar.
-
Adicionado o modo de gravação stage, que usa uma tabela stage temporária para melhorar o desempenho de gravação. Este recurso requer Hologres v4.1.0 ou posterior.
-
Adicionado suporte para operações
INSERT INTOeINSERT OVERWRITEno modo stage. -
Otimizada a lógica de limpeza de tabelas temporárias para operações
overwrite. -
Adicionado o parâmetro
write.rps_limitpara controlar a taxa de gravação por tarefa. -
Corrigido um problema de replay síncrono forçado que ocorria ao executar DDL durante uma operação
overwrite. -
Adicionado o parâmetro
read.split.strategypara suportar três estratégias de divisão de leitura:shard,rangeepartition. -
Adicionado suporte para o tipo de dados
JSONBem leituras baseadas em Arrow. -
Adicionado o parâmetro
write.insert.ignore_null_when_updatepara ignorar valores NULL durante operaçõesUPDATE. -
Adicionado suporte para relatórios de cobertura de testes JaCoCo.
-
Corrigido um erro ao gravar valores
dateanteriores a 1970. -
Adicionado suporte para o método de autenticação AKV4.
-
Adicionado o parâmetro
write.copy.disable_right_joinpara otimizar o desempenho de gravaçãoCOPY. -
Otimizada a lógica de verificação de tipos de colunas para gravações via catálogo.
-
Adicionado suporte para gravação de dados de baixa precisão em tipos de dados de alta precisão.
-
Adicionados prefixos como
appnameetaskidaos logs para simplificar a solução de problemas. -
Ativada a compressão Arrow LZ4 para operações
COPY OUT. -
Otimizada a formatação e validação de parâmetros.
-
Adicionado o parâmetro
remove_u0000para remover automaticamente caracteresU+0000de colunas de texto. -
Refatorado o Catálogo Hologres para mapear namespaces para schemas.
-
Adicionada a classe utilitária
RepartitionUtilpara fragmentação de dados. -
Documentação refatorada e links atualizados.
-
Introduzido o Catálogo Hologres, que permite leitura e gravação no Hologres usando tabelas externas.
-
Adicionado suporte para pushdown de predicado e pushdown de limite.
-
Ativado o modo em lote
bulk_readpara operações de leitura, melhorando o desempenho em uma ordem de magnitude. -
Desempenho de leitura otimizado.
-
Adicionado suporte para pushdown de predicado, pushdown de limite e poda de colunas.
-
Ativada a leitura de dados usando consultas
SELECT. -
Ativado o modo em lote para operações de leitura.
-
Corrigidos problemas relacionados à leitura.
-
Introduzido o modo de gravação
bulk_loadpara gravação em lote em tabelas sem chave primária. -
Adicionado o modo
bulk_load_on_conflictpara lidar com conflitos de chave primária em tabelas com chave primária. -
Desempenho de gravação otimizado.
-
Adicionado suporte para leitura de dados do Hologres.
-
Ativadas leituras paralelas por shard.
-
Adicionado suporte para inferência automática de schema.
-
Estabilizada a funcionalidade inicial de leitura.
-
Introduzido o modo de gravação
stream(COPYfixo). -
Adicionado suporte para o recurso
COPYfixo no Hologres v1.3. -
Throughput e latência de gravação otimizados.
Parâmetros
Parâmetros gerais
|
Parameter |
Default |
Required |
Description |
|
username |
None |
Yes |
|
|
password |
None |
Yes |
|
|
table |
None |
Yes |
O nome da tabela Hologres para leitura ou gravação. Nota
Ao ler dados, utilize o parâmetro |
|
jdbcurl |
None |
Yes |
A URL JDBC da API de dados em tempo real do Hologres, no formato |
|
enable_serverless_computing |
false |
No |
Define se deve ser usado um recurso de computação serverless. Este parâmetro aplica-se apenas a operações de leitura e gravação no modo |
|
serverless_computing_query_priority |
3 |
No |
A prioridade de execução para Serverless Computing. |
|
statement_timeout_seconds |
28800 (8 hours) |
No |
A duração do tempo limite de execução da consulta, em segundos. |
|
retry_count |
3 |
No |
O número de tentativas em caso de falha na conexão. |
|
direct_connect |
Uma conexão direta é usada por padrão, se suportada. |
No |
Define se a conexão deve ser feita diretamente ao FrontEnd do Hologres (nó de acesso). O throughput de rede do endpoint costuma ser o gargalo para operações de dados em lote. Por padrão, o conector usa uma conexão direta, se disponível, para melhorar o throughput. Defina como |
Parâmetros de gravação
O conector Hologres suporta o parâmetro SaveMode do Spark. Para SQL, isso corresponde a INSERT INTO ou INSERT OVERWRITE. Para um DataFrame, defina o SaveMode como Append ou Overwrite ao gravar dados. O modo Overwrite cria uma tabela temporária para a operação de gravação e substitui a tabela original após o sucesso. Utilize este modo apenas quando necessário.
|
Parameter |
Previous name |
Default |
Required |
Description |
|
write.mode |
copy_write_mode |
auto |
No |
O modo de gravação. Para uma comparação dos modos de gravação, consulte Modos de gravação em lote. Valores válidos: |
|
write.copy.max_buffer_size |
max_cell_buffer_size |
52428800 (50 MB) |
No |
O tamanho máximo do buffer local ao gravar no modo |
|
write.copy.dirty_data_check |
copy_write_dirty_data_check |
false |
No |
Define se deve verificar dados incorretos (dirty data). Se ativado, esse recurso identifica exatamente a linha que falhou na gravação. Contudo, isso afeta o desempenho de gravação. Mantenha este recurso desativado, exceto para solução de problemas. |
|
write.on_conflict_action |
INSERT_OR_REPLACE |
INSERT_OR_REPLACE |
No |
A ação a ser tomada quando uma operação de gravação encontra um conflito de chave primária na tabela de destino. |
|
write.stage.compression |
None |
false |
No |
Entra em vigor quando |
Os parâmetros a seguir entram em vigor apenas quando write.mode está definido como insert.
|
Parameter |
Previous name |
Default |
Required |
Description |
|
write.insert.dynamic_partition |
dynamic_partition |
false |
No |
Quando |
|
write.insert.batch_size |
write_batch_size |
512 |
No |
O tamanho máximo de lote para cada thread de gravação. Um commit em lote é acionado quando o número de operações |
|
write.insert.batch_byte_size |
write_batch_byte_size |
2097152 (2 MB) |
No |
O tamanho máximo de lote em bytes para cada thread de gravação. O valor padrão é 2 MB. Um commit em lote é acionado quando o tamanho em bytes dos dados |
|
write.insert.max_interval_ms |
write_max_interval_ms |
10000 |
No |
Um commit em lote é acionado se o tempo decorrido desde o último commit exceder este valor. |
|
write.insert.thread_size |
write_thread_size |
1 |
No |
O número de threads de gravação concorrentes. Cada thread usa uma conexão de banco de dados. |
|
write.rps_limit |
None |
-1 |
No |
O limite de taxa para gravações por tarefa, em linhas por segundo (RPS). O valor padrão -1 indica nenhum limite. |
Parâmetros de leitura
|
Parameter |
Previous name (v1.5.0 and earlier) |
Default |
Required |
Description |
|
read.mode |
bulk_read |
auto |
No |
O modo de leitura. Valores válidos: |
|
read.max_task_count |
max_partition_count |
80 |
No |
Especifica o número máximo de tarefas concorrentes para leitura de dados. O conector divide a tabela em múltiplas partições, e cada partição é processada por uma única tarefa Spark. Se a contagem de shards da tabela for menor que este valor, o número de partições será limitado à contagem de shards. |
|
read.copy.max_buffer_size |
/ |
52428800 (50 MB) |
No |
O tamanho máximo do buffer local ao ler no modo |
|
read.push_down_predicate |
push_down_predicate |
true |
No |
Define se o pushdown de predicado deve ser ativado. Quando ativado, operações como condições de filtro e poda de colunas são transferidas para a fonte de dados. |
|
read.push_down_limit |
push_down_limit |
true |
No |
Define se o pushdown de |
|
read.select.batch_size |
scan_batch_size |
256 |
No |
Entra em vigor quando |
|
read.select.timeout_seconds |
scan_timeout_seconds |
60 |
No |
Entra em vigor quando |
|
read.query |
query |
None |
No |
Use a Nota
|
|
read.split.strategy |
None |
auto |
No |
Define a estratégia para dividir os dados da tabela em múltiplas tarefas para leituras paralelas. Valores válidos: Nota
Suportado no conector v1.6.1 e posteriores. |
|
read.split.column |
None |
None |
No |
O nome da coluna de divisão. Este parâmetro é obrigatório quando |
|
read.split.lower_bound |
None |
None |
No |
O limite inferior de divisão é obrigatório quando |
|
read.split.upper_bound |
None |
None |
No |
O limite superior de divisão especifica o limite máximo para um shard baseado em intervalo. Este parâmetro é obrigatório quando |
|
read.split.num |
None |
None |
No |
O número de divisões. Este parâmetro é obrigatório quando |
Mapeamento de tipos de dados
|
Spark type |
Hologres type |
|
ShortType |
SMALLINT |
|
IntegerType |
INT |
|
LongType |
BIGINT |
|
StringType |
TEXT |
|
StringType |
JSON |
|
StringType |
JSONB |
|
DecimalType |
NUMERIC(38, 18) |
|
BooleanType |
BOOL |
|
DoubleType |
DOUBLE PRECISION |
|
FloatType |
FLOAT |
|
TimestampType |
TIMESTAMPTZ |
|
DateType |
DATE |
|
BinaryType |
BYTEA |
|
BinaryType |
ROARINGBITMAP |
|
ArrayType(IntegerType) |
INT4[] |
|
ArrayType(LongType) |
INT8[] |
|
ArrayType(FloatType) |
FLOAT4[] |
|
ArrayType(DoubleType) |
FLOAT8[] |
|
ArrayType(BooleanType) |
BOOLEAN[] |
|
ArrayType(StringType) |
TEXT[] |
Cálculo da contagem de conexões
O Hologres-Connector-Spark utiliza um determinado número de conexões JDBC para operações de leitura e gravação. A contagem de conexões depende dos seguintes fatores:
Calcule a contagem total de conexões para um job com as seguintes fórmulas:
|
Item |
Connections |
|
Consulta de metadados do catálogo |
1 |
|
Leitura de dados |
parallelism * 1 + 1 |
|
Gravação no modo COPY |
parallelism * 1 + 1 |
|
Gravação no modo INSERT |
parallelism * write_thread_size + 1 |
Este cálculo pressupõe que a capacidade do Spark para tarefas concorrentes excede o número de tarefas geradas pelo job.
A capacidade do Spark para tarefas concorrentes depende de parâmetros configurados pelo usuário, como spark.executor.instances, e da política de divisão de blocos de arquivos do Hadoop. Para mais informações, consulte Apache Hadoop.
Notas de versão do Conector Spark
|
Version |
Release date |
New features |
Bug fixes |
|
1.6.1 |
2026-02 |
|
|
|
1.6.0 |
2025-12 |
|
|
|
1.5.6 |
2025-11 |
|
|
|
1.5.5 |
2025-10 |
|
|
|
1.5.4 |
2025-09 |
|
|
|
1.5.2 |
2025-08 |
|
|
|
1.5.0 |
2025-06 |
|
|
|
1.4.2 |
2025-04 |
|
|
|
1.3.2 |
2025-02 |
|
|
|
1.3.0 |
2025-01 |
|
|