Consultar o Amazon Redshift usando o Azure Databricks

Você pode ler e escrever tabelas do Amazon Redshift com o Azure Databricks.

A fonte de dados Databricks Redshift usa o Amazon S3 para transferir dados de forma eficiente para dentro e para fora do Redshift e usa JDBC para acionar automaticamente os comandos e COPY apropriados UNLOAD no Redshift.

Utilização

Os exemplos a seguir demonstram a conexão com o driver Redshift. Substitua os valores de url parâmetro se estiver usando o driver JDBC PostgreSQL.

Depois de configurar suas credenciais da AWS, você pode usar a fonte de dados com a API de fonte de dados do Spark em Python, SQL, R ou Scala.

Python

# Read data from a table using Databricks Runtime 10.4 LTS and below
df = (spark.read
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("forward_spark_s3_credentials", True)
  .load()
)

# Read data from a table using Databricks Runtime 11.3 LTS and above
df = (spark.read
  .format("redshift")
  .option("host", "hostname")
  .option("port", "port") # Optional - will use default port 5439 if not specified.
  .option("user", "username")
  .option("password", "password")
  .option("database", "database-name")
  .option("dbtable", "schema-name.table-name") # if schema-name is not specified, default to "public".
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("forward_spark_s3_credentials", True)
  .load()
)

# Read data from a query
df = (spark.read
  .format("redshift")
  .option("query", "select x, count(*) <your-table-name> group by x")
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("forward_spark_s3_credentials", True)
  .load()
)

# After you have applied transformations to the data, you can use
# the data source API to write the data back to another table

# Write back to a table
(df.write
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .mode("error")
  .save()
)

# Write back to a table using IAM Role based authentication
(df.write
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("aws_iam_role", "arn:aws:iam::123456789000:role/redshift_iam_role")
  .mode("error")
  .save()
)

SQL

Leia os dados usando SQL no Databricks Runtime 10.4 LTS e abaixo:

DROP TABLE IF EXISTS redshift_table;
CREATE TABLE redshift_table
USING redshift
OPTIONS (
  dbtable '<table-name>',
  tempdir 's3a://<bucket>/<directory-path>',
  url 'jdbc:redshift://<database-host-url>',
  user '<username>',
  password '<password>',
  forward_spark_s3_credentials 'true'
);
SELECT * FROM redshift_table;

Leia os dados usando SQL no Databricks Runtime 11.3 LTS e superior:

DROP TABLE IF EXISTS redshift_table;
CREATE TABLE redshift_table
USING redshift
OPTIONS (
  host '<hostname>',
  port '<port>', /* Optional - will use default port 5439 if not specified. *./
  user '<username>',
  password '<password>',
  database '<database-name>'
  dbtable '<schema-name>.<table-name>', /* if schema-name not provided, default to "public". */
  tempdir 's3a://<bucket>/<directory-path>',
  forward_spark_s3_credentials 'true'
);
SELECT * FROM redshift_table;

Escreva dados usando SQL:

DROP TABLE IF EXISTS redshift_table;
CREATE TABLE redshift_table_new
USING redshift
OPTIONS (
  dbtable '<new-table-name>',
  tempdir 's3a://<bucket>/<directory-path>',
  url 'jdbc:redshift://<database-host-url>',
  user '<username>',
  password '<password>',
  forward_spark_s3_credentials 'true'
) AS
SELECT * FROM table_name;

A API SQL oferece suporte apenas à criação de novas tabelas e não à substituição ou acréscimo.

R

Leia os dados usando R no Databricks Runtime 10.4 LTS e abaixo:

df <- read.df(
   NULL,
   "com.databricks.spark.redshift",
   tempdir = "s3a://<your-bucket>/<your-directory-path>",
   dbtable = "<your-table-name>",
   url = "jdbc:redshift://<the-rest-of-the-connection-string>")

Leia os dados usando R no Databricks Runtime 11.3 LTS e superior:

df <- read.df(
  NULL,
  "redshift",
  host = "hostname",
  port = "port",
  user = "username",
  password = "password",
  database = "database-name",
  dbtable = "schema-name.table-name",
  tempdir = "s3a://<your-bucket>/<your-directory-path>",
  forward_spark_s3_credentials = "true",
  dbtable = "<your-table-name>")

Scala

// Read data from a table using Databricks Runtime 10.4 LTS and below
val df = spark.read
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("forward_spark_s3_credentials", True)
  .load()

// Read data from a table using Databricks Runtime 11.3 LTS and above
val df = spark.read
  .format("redshift")
  .option("host", "hostname")
  .option("port", "port") /* Optional - will use default port 5439 if not specified. */
  .option("user", "username")
  .option("password", "password")
  .option("database", "database-name")
  .option("dbtable", "schema-name.table-name") /* if schema-name is not specified, default to "public". */
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("forward_spark_s3_credentials", true)
  .load()

// Read data from a query
val df = spark.read
  .format("redshift")
  .option("query", "select x, count(*) <your-table-name> group by x")
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("forward_spark_s3_credentials", True)
  .load()

// After you have applied transformations to the data, you can use
// the data source API to write the data back to another table

// Write back to a table
df.write
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .mode("error")
  .save()

// Write back to a table using IAM Role based authentication
df.write
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("aws_iam_role", "arn:aws:iam::123456789000:role/redshift_iam_role")
  .mode("error")
  .save()

Recomendações para trabalhar com Redshift

A execução da consulta pode extrair grandes quantidades de dados para o S3. Se você planeja executar várias consultas nos mesmos dados no Redshift, o Databricks recomenda salvar os dados extraídos usando o Delta Lake.

Configuração

Autenticação no S3 e Redshift

A fonte de dados envolve várias conexões de rede, ilustradas no diagrama a seguir:

                            ┌───────┐
       ┌───────────────────>│  S3   │<─────────────────┐
       │    IAM or keys     └───────┘    IAM or keys   │
       │                        ^                      │
       │                        │ IAM or keys          │
       v                        v               ┌──────v────┐
┌────────────┐            ┌───────────┐         │┌──────────┴┐
│  Redshift  │            │  Spark    │         ││   Spark   │
│            │<──────────>│  Driver   │<────────>| Executors │
└────────────┘            └───────────┘          └───────────┘
               JDBC with                  Configured
               username /                     in
               password                     Spark
        (SSL enabled by default)

A fonte de dados lê e grava dados no S3 ao transferir dados de/para o Redshift. Como resultado, ele requer credenciais da AWS com acesso de leitura e gravação a um bucket do S3 (especificado usando o tempdir parâmetro configuration).

As seções a seguir descrevem as opções de configuração de autenticação de cada conexão:

• Motorista de faísca para Redshift
• Faísca para S3
• Redshift para S3

Motorista de faísca para Redshift

O driver Spark se conecta ao Redshift via JDBC usando um nome de usuário e senha. O Redshift não suporta o uso de funções do IAM para autenticar essa conexão. Por padrão, essa conexão usa criptografia SSL; para obter mais detalhes, consulte Criptografia.

Faísca para S3

O S3 atua como intermediário para armazenar dados em massa ao ler ou gravar no Redshift. O Spark se conecta ao S3 usando as interfaces do Hadoop FileSystem e diretamente usando o cliente S3 do Amazon Java SDK.

• Definir chaves no Hadoop conf: você pode especificar chaves da AWS usando as propriedades de configuração do Hadoop. Se sua tempdir configuração apontar para um s3a:// sistema de arquivos, você poderá definir as propriedades e fs.s3a.access.key em um arquivo de configuração XML do Hadoop ou chamar fs.s3a.secret.key para configurar a sc.hadoopConfiguration.set() configuração global do Hadoop do Spark. Se você usar um s3n:// sistema de arquivos, poderá fornecer as chaves de configuração herdadas, conforme mostrado no exemplo a seguir.

  Scala

  Por exemplo, se você estiver usando o sistema de s3a arquivos, adicione:

  sc.hadoopConfiguration.set("fs.s3a.access.key", "<your-access-key-id>")
  sc.hadoopConfiguration.set("fs.s3a.secret.key", "<your-secret-key>")
  

  Para o sistema de arquivos herdado s3n , adicione:

  sc.hadoopConfiguration.set("fs.s3n.awsAccessKeyId", "<your-access-key-id>")
  sc.hadoopConfiguration.set("fs.s3n.awsSecretAccessKey", "<your-secret-key>")
  

  Python

  O comando a seguir depende de alguns internos do Spark, mas deve funcionar com todas as versões do PySpark e é improvável que mude no futuro:

    sc._jsc.hadoopConfiguration().set("fs.s3a.access.key", "<your-access-key-id>")
    sc._jsc.hadoopConfiguration().set("fs.s3a.secret.key", "<your-secret-key>")
  

Redshift para S3

Defina a forward_spark_s3_credentials opção para true encaminhar automaticamente as credenciais de chave da AWS que o Spark está usando para se conectar ao S3 sobre JDBC para Redshift. A consulta JDBC incorpora essas credenciais, portanto, o Databricks recomenda que você habilite a criptografia SSL da conexão JDBC.

Encriptação

• Protegendo o JDBC: a menos que qualquer configuração relacionada ao SSL esteja presente na URL do JDBC, a fonte de dados por padrão habilita a criptografia SSL e também verifica se o servidor Redshift é confiável (ou seja, sslmode=verify-full). Para isso, um certificado de servidor é baixado automaticamente dos servidores da Amazon na primeira vez que é necessário. Caso isso falhe, um arquivo de certificado pré-empacotado é usado como um fallback. Isso vale para os drivers JDBC Redshift e PostgreSQL.

  No caso de haver algum problema com este recurso, ou você simplesmente quer desativar o SSL, você pode chamar .option("autoenablessl", "false") o seu DataFrameReader ou DataFrameWriter.

  Se desejar especificar configurações personalizadas relacionadas a SSL, siga as instruções na documentação do Redshift: Usando SSL e certificados de servidor em Java e opções de configuração do driver JDBC Todas as opções relacionadas a SSL presentes no JDBC url usado com a fonte de dados têm precedência (ou seja, a configuração automática não será acionada).

• Criptografando dados UNLOAD armazenados no S3 (dados armazenados ao ler do Redshift): De acordo com a documentação do Redshift sobre Descarregamento de dados para o S3, "UNLOAD criptografa automaticamente arquivos de dados usando a criptografia do lado do servidor do Amazon S3 (SSE-S3)."

  O Redshift também suporta criptografia do lado do cliente com uma chave personalizada (consulte: Descarregando arquivos de dados criptografados), mas a fonte de dados não tem a capacidade de especificar a chave simétrica necessária.

• Criptografando dados COPY armazenados no S3 (dados armazenados ao gravar no Redshift): De acordo com a documentação do Redshift sobre como carregar arquivos de dados criptografados do Amazon S3:

Você pode usar o comando para carregar arquivos de dados que foram carregados no Amazon S3 usando criptografia do lado do servidor com chaves de criptografia gerenciadas pela AWS (SSE-S3 ou SSE-KMS), criptografia do lado do COPY cliente ou ambas. O COPY não oferece suporte à criptografia do lado do servidor do Amazon S3 com uma chave fornecida pelo cliente (SSE-C).

Parâmetros

O mapa de parâmetros ou OPTIONS fornecidos no Spark SQL suportam as seguintes configurações:

Opções de configuração adicionais

Configurando o tamanho máximo de colunas de cadeia de caracteres

Ao criar tabelas Redshift, o comportamento padrão é criar TEXT colunas para colunas de cadeia de caracteres. O Redshift armazena TEXT colunas como VARCHAR(256), portanto, essas colunas têm um tamanho máximo de 256 caracteres (fonte).

Para dar suporte a colunas maiores, você pode usar o campo de metadados de maxlength coluna para especificar o comprimento máximo de colunas de cadeia de caracteres individuais. Isso também é útil para implementar otimizações de desempenho que economizam espaço, declarando colunas com um comprimento máximo menor do que o padrão.

Python

df = ... # the dataframe you'll want to write to Redshift

# Specify the custom width of each column
columnLengthMap = {
  "language_code": 2,
  "country_code": 2,
  "url": 2083,
}

# Apply each column metadata customization
for (colName, length) in columnLengthMap.iteritems():
  metadata = {'maxlength': length}
  df = df.withColumn(colName, df[colName].alias(colName, metadata=metadata))

df.write \
  .format("com.databricks.spark.redshift") \
  .option("url", jdbcURL) \
  .option("tempdir", s3TempDirectory) \
  .option("dbtable", sessionTable) \
  .save()

Scala

Aqui está um exemplo de atualização de campos de metadados de várias colunas usando a API Scala do Spark:

import org.apache.spark.sql.types.MetadataBuilder

// Specify the custom width of each column
val columnLengthMap = Map(
  "language_code" -> 2,
  "country_code" -> 2,
  "url" -> 2083
)

var df = ... // the dataframe you'll want to write to Redshift

// Apply each column metadata customization
columnLengthMap.foreach { case (colName, length) =>
  val metadata = new MetadataBuilder().putLong("maxlength", length).build()
  df = df.withColumn(colName, df(colName).as(colName, metadata))
}

df.write
  .format("com.databricks.spark.redshift")
  .option("url", jdbcURL)
  .option("tempdir", s3TempDirectory)
  .option("dbtable", sessionTable)
.save()

Definir um tipo de coluna personalizada

Se você precisar definir manualmente um tipo de coluna, poderá usar os metadados da redshift_type coluna. Por exemplo, se desejar substituir o correspondente de Spark SQL Schema -> Redshift SQL tipo para atribuir um tipo de coluna definido pelo usuário, faça o seguinte:

Python

# Specify the custom type of each column
columnTypeMap = {
  "language_code": "CHAR(2)",
  "country_code": "CHAR(2)",
  "url": "BPCHAR(111)",
}

df = ... # the dataframe you'll want to write to Redshift

# Apply each column metadata customization
for colName, colType in columnTypeMap.items():
  metadata = {'redshift_type': colType}
  df = df.withColumn(colName, df[colName].alias(colName, metadata=metadata))

Scala

import org.apache.spark.sql.types.MetadataBuilder

// Specify the custom type of each column
val columnTypeMap = Map(
  "language_code" -> "CHAR(2)",
  "country_code" -> "CHAR(2)",
  "url" -> "BPCHAR(111)"
)

var df = ... // the dataframe you'll want to write to Redshift

// Apply each column metadata customization
columnTypeMap.foreach { case (colName, colType) =>
  val metadata = new MetadataBuilder().putString("redshift_type", colType).build()
  df = df.withColumn(colName, df(colName).as(colName, metadata))
}

Configurar a codificação de colunas

Ao criar uma tabela, use o campo de metadados de encoding coluna para especificar uma codificação de compactação para cada coluna (consulte Amazon docs para codificações disponíveis).

Definição de descrições em colunas

O Redshift permite que as colunas tenham descrições anexadas que devem aparecer na maioria das ferramentas de consulta (usando o COMMENT comando). Você pode definir o campo de metadados da description coluna para especificar uma descrição para colunas individuais.

Pushdown de consulta no Redshift

O otimizador Spark empurra os seguintes operadores para o Redshift:

• Filter
• Project
• Sort
• Limit
• Aggregation
• Join

Dentro Project e Filter, suporta as seguintes expressões:

• A maioria dos operadores lógicos booleanos
• Comparações
• Operações aritméticas básicas
• Moldes numéricos e de cordas
• A maioria das funções de cadeia de caracteres
• Subconsultas escalares, se puderem ser empurradas inteiramente para baixo no Redshift.

Dentro Aggregationdo , ele suporta as seguintes funções de agregação:

• AVG
• COUNT
• MAX
• MIN
• SUM
• STDDEV_SAMP
• STDDEV_POP
• VAR_SAMP
• VAR_POP

combinada com a DISTINCT cláusula, se for caso disso.

Dentro Joindo , ele suporta os seguintes tipos de junções:

• INNER JOIN
• LEFT OUTER JOIN
• RIGHT OUTER JOIN
• LEFT SEMI JOIN
• LEFT ANTI JOIN
• Subconsultas que são reescritas Join pelo otimizador, por exemplo WHERE EXISTS, , WHERE NOT EXISTS

O pushdown pode ser mais benéfico em consultas com LIMIT. Uma consulta como essa SELECT * FROM large_redshift_table LIMIT 10 poderia levar muito tempo, pois toda a tabela seria primeiro descarregada para o S3 como um resultado intermediário. Com pushdown, o LIMIT é executado em Redshift. Em consultas com agregações, empurrar a agregação para baixo no Redshift também ajuda a reduzir a quantidade de dados que precisam ser transferidos.

O pushdown de consulta no Redshift está ativado por padrão. Ele pode ser desativado definindo spark.databricks.redshift.pushdown como false. Mesmo quando desativado, o Spark ainda pressiona os filtros e executa a eliminação de colunas no Redshift.

Instalação do driver Redshift

A fonte de dados Redshift também requer um driver JDBC compatível com Redshift. Como o Redshift é baseado no sistema de banco de dados PostgreSQL, você pode usar o driver JDBC PostgreSQL incluído no Databricks Runtime ou o driver JDBC Redshift recomendado pela Amazon. Nenhuma instalação é necessária para usar o driver JDBC PostgreSQL. A versão do driver JDBC PostgreSQL incluída em cada versão do Databricks Runtime está listada nas notas de versão do Databricks Runtime.

Para instalar manualmente o driver JDBC Redshift:

1. Baixe o driver da Amazon.
2. Carregue o driver em seu espaço de trabalho do Azure Databricks. Consulte Bibliotecas.
3. Instale a biblioteca no cluster.

Garantias transacionais

Esta seção descreve as garantias transacionais da fonte de dados Redshift para o Spark.

Informações gerais sobre as propriedades Redshift e S3

Para obter informações gerais sobre garantias transacionais do Redshift, consulte o capítulo Gerenciando operações de gravação simultâneas na documentação do Redshift. Em resumo, o Redshift fornece isolamento serializável de acordo com a documentação para o comando Redshift START :

[embora] você possa usar qualquer um dos quatro níveis de isolamento de transação, o Amazon Redshift processa todos os níveis de isolamento como serializáveis.

De acordo com a documentação do Redshift:

O Amazon Redshift oferece suporte a um comportamento de confirmação automática padrão no qual cada comando SQL executado separadamente é confirmado individualmente.

Assim, comandos individuais gostam COPY e UNLOAD são atômicos e transacionais, embora explícitos BEGIN e END só devem ser necessários para impor a atomicidade de múltiplos comandos ou consultas.

Ao ler e gravar no Redshift, a fonte de dados lê e grava dados no S3. Tanto o Spark quanto o Redshift produzem saída particionada e a armazenam em vários arquivos no S3. De acordo com a documentação do modelo de consistência de dados do Amazon S3, as operações de listagem de bucket do S3 são eventualmente consistentes, portanto, os arquivos devem ir para comprimentos especiais para evitar dados ausentes ou incompletos devido a essa fonte de consistência eventual.

Garantias da fonte de dados Redshift para o Spark

Acrescentar a uma tabela existente

Ao inserir linhas no Redshift, a fonte de dados usa o comando COPY e especifica manifestos para proteger contra determinadas operações do S3 eventualmente consistentes. Como resultado, spark-redshift os acréscimos às tabelas existentes têm as mesmas propriedades atômicas e transacionais que os comandos regulares do Redshift COPY .

Criar uma nova tabela (SaveMode.CreateIfNotExists)

A criação de uma nova tabela é um processo de duas etapas, que consiste em um CREATE TABLE comando seguido por um comando COPY para acrescentar o conjunto inicial de linhas. Ambas as operações são realizadas na mesma transação.

Substituir uma tabela existente

Por padrão, a fonte de dados usa transações para executar substituições, que são implementadas excluindo a tabela de destino, criando uma nova tabela vazia e anexando linhas a ela.

Se a configuração preterida usestagingtable for definida como false, a fonte de dados confirmará o DELETE TABLE comando antes de acrescentar linhas à nova tabela, sacrificando a atomicidade da operação de substituição, mas reduzindo a quantidade de espaço de preparo de que o Redshift precisa durante a substituição.

Consultar tabela Redshift

As consultas usam o comando Redshift UNLOAD para executar uma consulta e salvar seus resultados no S3 e usam manifestos para se proteger contra certas operações do S3 eventualmente consistentes. Como resultado, as consultas da fonte de dados Redshift para o Spark devem ter as mesmas propriedades de consistência que as consultas regulares do Redshift.

Problemas e soluções comuns

O bucket do S3 e o cluster do Redshift estão em regiões diferentes da AWS

Por padrão, as cópias do S3 <-> Redshift não funcionam se o bucket do S3 e o cluster do Redshift estiverem em regiões diferentes da AWS.

Se você tentar ler uma tabela Redshift quando o bucket do S3 estiver em uma região diferente, poderá ver um erro como:

ERROR: S3ServiceException:The S3 bucket addressed by the query is in a different region from this cluster.,Status 301,Error PermanentRedirect.

Da mesma forma, tentar gravar no Redshift usando um bucket do S3 em uma região diferente pode causar o seguinte erro:

error:  Problem reading manifest file - S3ServiceException:The S3 bucket addressed by the query is in a different region from this cluster.,Status 301,Error PermanentRedirect

• Gravações: O comando Redshift COPY suporta a especificação explícita da região do bucket do S3, para que você possa fazer com que as gravações no Redshift funcionem corretamente nesses casos, adicionando region 'the-region-name' à extracopyoptions configuração. Por exemplo, com um bucket na região Leste dos EUA (Virgínia) e a API Scala, use:

  .option("extracopyoptions", "region 'us-east-1'")
  

  Como alternativa, você pode usar a awsregion configuração:

  .option("awsregion", "us-east-1")
  

• Leia: O comando Redshift UNLOAD também suporta especificação explícita da região do bucket do S3. Você pode fazer com que as leituras funcionem corretamente adicionando a região à awsregion configuração:

  .option("awsregion", "us-east-1")
  

Erro de autenticação ao usar uma senha com caracteres especiais na URL JDBC

Se você estiver fornecendo o nome de usuário e a senha como parte da URL JDBC e a senha contiver caracteres especiais, como ;, ?ou &, você poderá ver a seguinte exceção:

java.sql.SQLException: [Amazon](500310) Invalid operation: password authentication failed for user 'xyz'

Isso é causado por caracteres especiais no nome de usuário ou senha que não estão sendo escapados corretamente pelo driver JDBC. Certifique-se de especificar o nome de usuário e a senha usando as opções user DataFrame correspondentes e password. Para obter mais informações, consulte Parâmetros.

A consulta Spark de longa duração trava indefinidamente mesmo que a operação Redshift correspondente seja concluída

Se você estiver lendo ou gravando grandes quantidades de dados de e para o Redshift, sua consulta do Spark poderá travar indefinidamente, mesmo que a página AWS Redshift Monitoring mostre que a operação correspondente LOAD foi UNLOAD concluída e que o cluster está ocioso. Isso é causado pela conexão entre Redshift e Spark timing out. Para evitar isso, verifique se o sinalizador JDBC está ativado tcpKeepAlive e TCPKeepAliveMinutes definido como um valor baixo (por exemplo, 1).

Para obter informações adicionais, consulte Configuração do driver JDBC do Amazon Redshift.

Carimbo de data/hora com semântica de fuso horário

Ao ler dados, tanto o Redshift TIMESTAMPTIMESTAMPTZ quanto os tipos de dados são mapeados para o Spark TimestampType, e um valor é convertido em Tempo Universal Coordenado (UTC) e é armazenado como o carimbo de data/hora UTC. Para um Redshift TIMESTAMP, o fuso horário local é assumido, pois o valor não tem nenhuma informação de fuso horário. Ao gravar dados em uma tabela do Redshift, um Spark TimestampType é mapeado para o tipo de dados do Redshift TIMESTAMP .

Guia de migração

A fonte de dados agora exige que você defina forward_spark_s3_credentials explicitamente antes que as credenciais do Spark S3 sejam encaminhadas para o Redshift. Essa alteração não terá impacto se você usar os mecanismos de aws_iam_role autenticação ou temporary_aws_* . No entanto, se você confiava no comportamento padrão antigo, agora deve definir forward_spark_s3_credentials explicitamente para true continuar usando seu mecanismo de autenticação Redshift para S3 anterior. Para obter uma discussão sobre os três mecanismos de autenticação e suas compensações de segurança, consulte a seção Autenticação no S3 e Redshift deste documento.