Altere os aplicativos Python e Perl para oferecer suporte à migração do banco de dados do Microsoft SQL Server para o Amazon Aurora Edição Compatível com PostgreSQL - Recomendações da AWS
ResumoPré-requisitos e limitaçõesArquiteturaFerramentasÉpicosRecursos relacionadosMais informações

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Altere os aplicativos Python e Perl para oferecer suporte à migração do banco de dados do Microsoft SQL Server para o Amazon Aurora Edição Compatível com PostgreSQL

Criado por Dwarika Patra (AWS) e Deepesh Jayaprakash (AWS)

Ambiente: PoC ou piloto

Origem: SQL Server

Destino: Aurora (compatível com PostgreSQL)

Tipo R: redefinir a plataforma

Workload: Microsoft; código aberto

Tecnologias: migração; bancos de dados

Serviços da AWS: Amazon Aurora

Resumo

Esse padrão descreve as alterações nos repositórios de aplicativos que podem ser necessárias quando você migra bancos de dados do Microsoft SQL Server para o Amazon Aurora Edição Compatível com PostgreSQL. O padrão pressupõe que esses aplicativos sejam baseados em Python ou em Perl e fornece instruções separadas para essas linguagens de script.

A migração de bancos de dados do SQL Server para o Aurora compatível com PostgreSQL envolve conversão de esquemas, conversão de objetos de banco de dados, migração de dados e carregamento de dados. Devido às diferenças entre o PostgreSQL e o SQL Server (relacionadas a tipos de dados, objetos de conexão, sintaxe e lógica), a tarefa de migração mais difícil envolve fazer as alterações necessárias na base de código para que ela funcione corretamente com o PostgreSQL.

Em um aplicativo baseado em Python, objetos e classes de conexão estão espalhados por todo o sistema. Além disso, a base de código do Python pode usar várias bibliotecas para se conectar ao banco de dados. Se a interface de conexão do banco de dados mudar, os objetos que executam as consultas em linha do aplicativo também precisarão de alterações.

Em um aplicativo baseado em Perl, as alterações envolvem objetos de conexão, drivers de conexão de banco de dados, instruções SQL em linha estáticas e dinâmicas e como o aplicativo lida com consultas dinâmicas complexas de DML e conjuntos de resultados.

Ao migrar seu aplicativo, você também pode considerar possíveis melhorias na AWS, como a substituição do servidor FTP pelo acesso ao Amazon Simple Storage Service (Amazon S3).

O processo de migração de aplicativos envolve os seguintes desafios:

  • Objetos de conexão. Se os objetos de conexão estiverem espalhados no código com várias bibliotecas e chamadas de função, talvez seja necessário encontrar uma maneira generalizada de alterá-los para oferecer suporte ao PostgreSQL.

  • Tratamento de erros ou exceções durante a recuperação ou atualizações de registros. Se você tiver operações condicionais de criação, leitura, atualização e exclusão (CRUD) no banco de dados que retornam variáveis, conjuntos de resultados ou data frames, quaisquer erros ou exceções podem resultar em erros de aplicativo com efeitos em cascata. Eles devem ser tratados com cuidado, com validações adequadas e pontos de economia. Um desses pontos de salvamento é chamar grandes consultas SQL em linha ou objetos de banco de dados dentro de blocos BEGIN...EXCEPTION...END.

  • Controle de transações e sua validação. Isso inclui confirmações e reversões manuais e automáticas. O driver do PostgreSQL para Perl exige que você sempre defina explicitamente o atributo de confirmação automática.

  • Tratamento de consultas SQL dinâmicas. Isso requer uma forte compreensão da lógica de consulta e testes iterativos para garantir que as consultas funcionem conforme o esperado.

  • Desempenho. Você deve garantir que as alterações no código não resultem na degradação do desempenho do aplicativo.

Esse padrão explica detalhadamente o processo de conversão.

Pré-requisitos e limitações

Pré-requisitos

  • Conhecimento prático das sintaxes Python e Perl.

  • Habilidades básicas em SQL Server e PostgreSQL.

  • Compreensão da arquitetura de seu aplicativo existente.

  • Acesso ao código do aplicativo, ao banco de dados do SQL Server e ao banco de dados do PostgreSQL.

  • Acesso ao ambiente de desenvolvimento Windows ou Linux (ou outro Unix) com credenciais para desenvolver, testar e validar alterações em aplicativos.

  • Em um aplicativo baseado em Python, bibliotecas do Python padrão que seu aplicativo pode exigir, como Pandas  para lidar com data frames e psycopg2 ou SQLAlchemy para conexões de banco de dados.

  • Para um aplicativo baseado em Perl, são necessários pacotes Perl com bibliotecas ou módulos dependentes. O módulo rede abrangente de arquivos do Perl (CPAN) pode oferecer suporte à maioria dos requisitos do aplicativo.

  • Todas as bibliotecas ou módulos personalizados dependentes necessários. 

  • Credenciais do banco de dados para acesso de leitura ao SQL Server e acesso de leitura e gravação ao Aurora.

  • PostgreSQL para validar e depurar alterações de aplicativos com serviços e usuários.

  • Acesso a ferramentas de desenvolvimento durante a migração de aplicativos, como Visual Studio Code, Sublime Text ou pgAdmin.

Limitações

  • Algumas versões, módulos, bibliotecas e pacotes do Python ou Perl não são compatíveis com o ambiente de nuvem.

  • Algumas bibliotecas e estruturas de terceiros usadas para o SQL Server não podem ser substituídas para oferecer suporte à migração do PostgreSQL. 

  • As variações de desempenho podem exigir alterações em seu aplicativo, nas consultas em linha do Transact-SQL (T-SQL), nas funções do banco de dados e nos procedimentos armazenados.

  • PostgreSQL suporta nomes em minúsculas para nomes de tabelas, nomes de colunas e outros objetos de banco de dados. 

  • Alguns tipos de dados, como colunas UUID, são armazenados somente em letras minúsculas. Os aplicativos Python e Perl devem lidar com essas diferenças de maiúsculas e minúsculas. 

  • As diferenças na codificação de caracteres devem ser tratadas com o tipo de dados correto para as colunas de texto correspondentes no banco de dados do PostgreSQL.                                

Versões do produto

  • Python 3.6 ou superior (use a versão compatível com seu sistema operacional)

  • Perl 5.8.3 ou superior (use a versão compatível com seu sistema operacional)

  • Edição 4.2 ou superior do Aurora compatível com PostgreSQL (veja detalhes)

Arquitetura

Pilha de tecnologia de origem

  • Linguagem de script (programação de aplicativos): Python 2.7 ou superior ou Perl 5.8 

  • Banco de dados: Microsoft SQL Server versão 13

  • Sistema operacional: Red Hat Enterprise Linux (RHEL) 7 

Pilha de tecnologias de destino

  • Linguagem de script (programação de aplicativos): Python 3.6 ou superior ou Perl 5.8 ou superior 

  • Banco de dados: Aurora 4.2 compatível com PostgreSQL

  • Sistema operacional: RHEL 7 

Arquitetura de migração 

Migração de um aplicativo do Perl ou Python com o SQL Server para o Aurora compatível com PostgreSQL

Ferramentas

Ferramentas e serviços da AWS

  • A Edição compatível com PostgreSQL do Amazon Aurora é um mecanismo de banco de dados relacional totalmente gerenciado, compatível com PostgreSQL e compatível com ACID que combina a velocidade e a confiabilidade de bancos de dados comerciais de alta tecnologia com a economia de bancos de dados de código aberto. O Aurora PostgreSQL é um substituto imediato do PostgreSQL e torna mais fácil e econômico configurar, operar e escalar suas implantações novas e existentes do PostgreSQL.

  • A AWS Command Line Interface (AWS CLI) é uma ferramenta de código aberto que permite que você interaja com serviços da AWS usando comandos no shell da linha de comando.

Outras ferramentas

Épicos

TarefaDescriçãoHabilidades necessárias

Siga estas etapas de conversão de código para migrar seu aplicativo para o PostgreSQL.

  1. Defina drivers e bibliotecas ODBC específicos do banco de dados para o PostgreSQL. Por exemplo, você pode usar um dos módulos CPAN para Perl e pyodbc, psycopg2 ou SQLAlchemy para Python.

  2. Converta objetos de banco de dados usando essas bibliotecas para se conectar ao Aurora compatível com PostgreSQL.

  3. Aplique alterações de código nos módulos de aplicativos existentes para obter instruções T-SQL compatíveis.

  4. Reescreva chamadas de função específicas do banco de dados e procedimentos armazenados no código do aplicativo.

  5. Gerencie as alterações nas variáveis do seu aplicativo e seus tipos de dados que são usados para consultas SQL em linha.

  6. Gerencie funções específicas de banco de dados incompatíveis.

  7. end-to-end Teste completo do código de aplicativo convertido para migração de banco de dados.

  8. Compare os resultados do Microsoft SQL Server com o aplicativo que você migrou para o PostgreSQL.

  9. Realize testes comparativos de desempenho de aplicativos entre o Microsoft SQL Server e o PostgreSQL.

  10. Revise os procedimentos armazenados ou as instruções T-SQL em linha chamadas pelo aplicativo para melhorar o desempenho.

Os épicos a seguir fornecem instruções detalhadas para algumas dessas tarefas de conversão para aplicativos Python e Perl.

Desenvolvedor de aplicativos

Use uma lista de verificação para cada etapa da migração.

Adicione o seguinte à sua lista de verificação para cada etapa da migração do aplicativo, incluindo a etapa final:

  • Revise a documentação do PostgreSQL para garantir que todas as suas alterações sejam compatíveis com o padrão do PostgreSQL.

  • Verifique os valores inteiros e flutuantes das colunas.

  • Identifique o número de linhas inseridas, atualizadas e extraídas, junto com os nomes das colunas e os carimbos de data/hora. Você pode usar um utilitário diff ou escrever um script para automatizar essas verificações.

  • Conclua as verificações de desempenho de grandes instruções SQL em linha e verifique o desempenho geral do aplicativo.

  • Verifique o tratamento correto de erros nas operações do banco de dados e na saída normal do programa usando vários blocos try/catch.

  • Verifique se os processos de registro adequados em log estão em vigor.

Desenvolvedor de aplicativos
TarefaDescriçãoHabilidades necessárias

Analise sua base de código Python existente.

Sua análise deve incluir o seguinte para facilitar o processo de migração do aplicativo:

  • Identifique todos os objetos de conexão no código.

  • Identifique todas as consultas SQL em linha incompatíveis (como instruções T-SQL e procedimentos armazenados) e analise as alterações necessárias.

  • Revise a documentação do seu código e acompanhe o fluxo de controle para entender a funcionalidade do código. Isso será útil posteriormente, quando você testar o aplicativo para comparações de desempenho ou carga.

  • Entenda a finalidade do aplicativo para que você possa testá-lo com eficácia após a conversão do banco de dados. A maioria dos aplicativos do Python candidatos à conversão com migrações de banco de dados são feeds que carregam dados de outras fontes em tabelas de banco de dados ou extratores que recuperam dados das tabelas e os transformam em diferentes formatos de saída (como CSV, JSON ou arquivos simples) adequados para criar relatórios ou fazer chamadas de API para realizar validações. 

Desenvolvedor de aplicativos

Converta suas conexões de banco de dados para suportar o PostgreSQL.

A maioria dos aplicativos Python usa a biblioteca pyodbc para se conectar aos bancos de dados do SQL Server da seguinte maneira.

import pyodbc
....
try:
    conn_string = "Driver=ODBC Driver 17 for SQL
    Server;UID={};PWD={};Server={};Database={}".format (conn_user, conn_password,
    conn_server, conn_database)
    conn = pyodbc.connect(conn_string)
    cur = conn.cursor()
    result = cur.execute(query_string)
    for row in result:
    print (row)
except Exception as e:
    print(str(e))

Converta a conexão do banco de dados para suportar o PostgreSQL da seguinte maneira.

import pyodbc
import psycopg2
....
try:
    conn_string = ‘postgresql+psycopg2://’+
    conn_user+’:’+conn_password+’@’+conn_server+’/’+conn_database
    conn = pyodbc.connect(conn_string, connect_args={‘options’:’-csearch_path=dbo’})
    cur = conn.cursor()
    result = cur.execute(query_string)
    for row in result:
    print (row)
except Exception as e:
    print(str(e))
Desenvolvedor de aplicativos

Altere as consultas SQL em linha para PostgreSQL.

Converta suas consultas SQL em linha em um formato compatível com PostgreSQL. Por exemplo, a consulta do SQL Server a seguir recupera uma string de uma tabela.

dtype = “type1”
stm = ‘“SELECT TOP 1 searchcode FROM TypesTable (NOLOCK)
WHERE code=”’ + “’” + str(dtype) + “’”
# For Microsoft SQL Server Database Connection
engine = create_engine(‘mssql+pyodbc:///?odbc_connect=%s’ % urllib.parse.quote_plus(conn_string), connect_args={‘connect_timeout’:login_timeout})
conn = engine_connect()
rs = conn.execute(stm)
for row in rs:
    print(row)

Após a conversão, a consulta SQL em linha compatível com PostgreSQL tem a seguinte aparência.

dtype = “type1”
stm = ‘“SELECT searchcode FROM TypesTable
WHERE code=”’ + “’” + str(dtype) + “’ LIMIT 1”
# For PostgreSQL Database Connection
engine = create_engine(‘postgres+psycopg2://%s’ %conn_string, connect_args={‘connect_timeout’:login_timeout})
conn = engine.connect()
rs = conn.execute(stm)
for row in rs:
    print(row)
Desenvolvedor de aplicativos

Gerencie consultas SQL dinâmicas.

O SQL dinâmico pode estar presente em um script ou em vários scripts do Python. Exemplos anteriores mostraram como usar a função string replace (substituição de strings) do Python para inserir variáveis para estruturar consultas SQL dinâmicas. Uma abordagem alternativa é anexar a string de consulta com variáveis sempre que aplicável. 

No exemplo a seguir, a string de consulta é estruturada dinamicamente com base nos valores retornados por uma função.

query = ‘“SELECT id from equity e join issues i on e.permId=i.permId where e.id’”
query += get_id_filter(ids) + “ e.id is NOT NULL

Esses tipos de consultas dinâmicas são muito comuns durante a migração do aplicativo. Siga estas etapas para lidar com consultas dinâmicas:

  • Verifique a sintaxe geral (por exemplo, a sintaxe da declaração SELECT com uma cláusula JOIN).

  • Verifique todas as variáveis ou nomes de colunas usados na consulta, como i e id.

  • Verifique as funções, argumentos e valores de retorno usados na consulta (por exemplo, get_id_filter e o argumento ids).

Desenvolvedor de aplicativos

Gerencie conjuntos de resultados, variáveis e data frames.

No Microsoft SQL Server, você usa métodos Python, como fetchone() ou fetchall() para recuperar o conjunto de resultados do banco de dados. Você também pode usar fetchmany(size) e especificar o número de registros a serem retornados do conjunto de resultados. Para fazer isso, você pode usar o objeto de conexão pyodbc, conforme mostrado no exemplo a seguir.

pyodbc (Microsoft SQL Server)

import pyodbc 
server = 'tcp:myserver.database.windows.net' 
database = 'exampledb' 
username = 'exampleusername' 
password = 'examplepassword' 
conn = pyodbc.connect('DRIVER={ODBC Driver 17 for SQL Server};SERVER='+server+';DATABASE='+database+';UID='+username+';PWD='+ password)
cursor = conn.cursor()
cursor.execute("SELECT * FROM ITEMS") 
row = cursor.fetchone() 
while row: 
    print(row[0])
    row = cursor.fetchone()

No Aurora, para realizar tarefas semelhantes, como conectar-se ao PostgreSQL e buscar conjuntos de resultados, você pode usar psycopg2 ou SQLAlchemy. Essas bibliotecas do Python fornecem o módulo de conexão e o objeto cursor para percorrer os registros do banco de dados do PostgreSQL, conforme mostrado no exemplo a seguir.

psycopg2 (Aurora compatível com PostgreSQL)

import psycopg2
query = "SELECT * FROM ITEMS;"
//Initialize variables
host=dbname=user=password=port=sslmode=connect_timeout=""
connstring = "host='{host}' dbname='{dbname}' user='{user}' \
password='{password}'port='{port}'".format(host=host,dbname=dbname,\
user=user,password=password,port=port) 
conn = psycopg2.connect(connstring)
cursor = conn.cursor()
cursor.execute(query)
column_names = [column[0] for column in cursor.description]
print("Column Names: ", column_names)
print("Column values: "
for row in cursor:
    print("itemid :", row[0])
    print("itemdescrption :", row[1])
    print("itemprice :", row[3]))

SQLAlchemy (Aurora compatível com PostgreSQL)

from sqlalchemy import create_engine
from pandas import DataFrame
conn_string = 'postgresql://core:database@localhost:5432/exampledatabase'
engine = create_engine(conn_string)
conn = engine.connect()
dataid = 1001
result = conn.execute("SELECT * FROM ITEMS")
df = DataFrame(result.fetchall())
df.columns = result.keys()
df = pd.DataFrame()
engine.connect()
df = pd.read_sql_query(sql_query, engine, coerce_float=False)
print(“df=”, df)
Desenvolvedor de aplicativos

Teste seu aplicativo durante e após a migração.

Testar o aplicativo do Python migrado é um processo contínuo. Como a migração inclui alterações no objeto de conexão (psycopg2 ou SQLAlchemy), tratamento de erros, novos atributos (data frames), alterações de SQL em linha, funcionalidades de cópia em massa (bcp em vez de COPY) e alterações semelhantes, ela deve ser testada cuidadosamente durante e após a migração do aplicativo. Verifique se existe:

  • Condições e tratamento de erros 

  • Qualquer incompatibilidade de registro após a migração

  • Registre atualizações ou exclusões

  • Tempo necessário para executar o aplicativo 

Desenvolvedor de aplicativos
TarefaDescriçãoHabilidades necessárias

Analise sua base de código Perl existente.

Sua análise deve incluir o seguinte para facilitar o processo de migração do aplicativo. Você deve identificar:

  • Qualquer código INI ou baseado em configuração

  • Drivers Perl do Open Database Connectivity (ODBC) padrão específico do banco de dados ou qualquer driver personalizado

  • Alterações de código necessárias para consultas em linha e T-SQL

  • Interações entre vários módulos do Perl (por exemplo, um único objeto de conexão do Perl ODBC que é chamado ou usado por vários componentes funcionais)

  • Tratamento do conjunto de dados e do conjunto de resultados

  • Bibliotecas do Perl externas e dependentes

  • Todas as APIs usadas no aplicativo

  • Compatibilidade da versão do Perl e compatibilidade de drivers com o Aurora compatível com PostgreSQL

Desenvolvedor de aplicativos

Converta as conexões do aplicativo do Perl e do módulo do DBI para suportar o PostgreSQL.

Os aplicativos baseados em Perl geralmente usam o módulo do Perl DBI, que é um módulo padrão de acesso ao banco de dados para a linguagem de programação Perl. Você pode usar o mesmo módulo do DBI com drivers diferentes para SQL Server e PostgreSQL.

Para obter mais informações sobre os módulos do Perl, instalações e outras instruções necessários, consulte a documentação do DBD::Pg. O exemplo a seguir se conecta ao Aurora compatível com PostgreSQL em exampletest-aurorapg-database.cluster-sampleclusture.us-east-.rds.amazonaws.com.

#!/usr/bin/perl
use DBI;
use strict;
my $driver = "Pg";
my $hostname = “exampletest-aurorapg-database-sampleclusture.us-east.rds.amazonaws.com”
my $dsn = "DBI:$driver: dbname = $hostname;host = 127.0.0.1;port = 5432";
my $username = "postgres";
my $password = "pass123";
$dbh = DBI->connect("dbi:Pg:dbname=$hostname;host=$host;port=$port;options=$options",
      $username,
      $password,
      {AutoCommit => 0, RaiseError => 1, PrintError => 0}
      );
Desenvolvedor de aplicativos

Altere as consultas SQL em linha para PostgreSQL.

Seu aplicativo pode ter consultas SQL em linha com SELECT, DELETE, UPDATE e declarações semelhantes que incluam cláusulas de consulta que o PostgreSQL não suporta. Por exemplo, palavras-chave de consulta como TOP e NOLOCK não são suportadas no PostgreSQL. Os exemplos a seguir mostram como você pode gerenciar variáveis TOP, NOLOCK e booleanas.

No SQL Server:

$sqlStr = $sqlStr
. "WHERE a.student_id in (SELECT TOP $numofRecords c_student_id   \
FROM active_student_record b WITH (NOLOCK) \
INNER JOIN student_contributor c WITH (NOLOCK) on c.contributor_id = b.c_st)

Para o PostgreSQL, converta para:

$sqlStr = $sqlStr
. "WHERE a.student_id in (SELECT TOP $numofRecords c_student_id  \
FROM active_student_record b INNER JOIN student_contributor c  \
on c.contributor_id = b.c_student_contr_id WHERE b_current_1 is true \
LIMIT $numofRecords)"
Desenvolvedor de aplicativos

Gerencie consultas SQL dinâmicas e variáveis do Perl.

As consultas SQL dinâmicas são instruções SQL criadas no runtime do aplicativo. Essas consultas são estruturadas dinamicamente quando o aplicativo está em execução, dependendo de determinadas condições, portanto, o texto completo da consulta não é conhecido até o runtime. Um exemplo é um aplicativo de análise financeira que analisa as 10 principais ações diariamente, e essas ações mudam todos os dias. As tabelas SQL são criadas com base nos melhores desempenhos e os valores não são conhecidos até o runtime.

Digamos que as consultas SQL em linha deste exemplo sejam passadas para uma função de encapsulamento para obter o conjunto de resultados em uma variável e, em seguida, uma variável use uma condição para determinar se a tabela existe:

  • Se a tabela existir, não a crie; faça algum processamento.

  • Se a tabela não existir, crie a tabela e também faça algum processamento.

Este é um exemplo de manipulação de variáveis, seguido pelas consultas SQL Server e PostgreSQL para este caso de uso.

my $tableexists = db_read( arg 1, $sql_qry, undef, 'writer');
my $table_already_exists = $tableexists->[0]{table_exists};
if ($table_already_exists){
# do some thing
}
else {
# do something else
}

SQL Server:

my $sql_qry = “SELECT OBJECT_ID('$backendTable', 'U') table_exists", undef, 'writer')";

PostgreSQL:

my $sql_qry = “SELECT TO_REGCLASS('$backendTable', 'U') table_exists", undef, 'writer')";

O exemplo a seguir usa uma variável do Perl em SQL em linha, que executa uma instrução SELECT com uma JOIN para buscar a chave primária da tabela e a posição da coluna chave.

SQL Server:

my $sql_qry = "SELECT column_name', character_maxi mum_length \
FROM INFORMATION_SCHEMA.COLUMNS \
WHERE TABLE_SCHEMA='$example_schemaInfo' \
AND TABLE_NAME='$example_table' \
AND DATA_TYPE IN ('varchar','nvarchar');";

PostgreSQL:

my $sql_qry = "SELECT c1.column_name, c1.ordinal_position \
FROM information_schema.key_column_usage AS c LEFT \
JOIN information_schema.table_constraints AS t1 \
ON t1.constraint_name = c1.constraint_name \
WHERE t1.table_name = $example_schemaInfo'.'$example_table’ \
AND t1.constraint_type = 'PRIMARY KEY' ;";
Desenvolvedor de aplicativos
TarefaDescriçãoHabilidades necessárias

Converta estruturas adicionais do SQL Server em PostgreSQL.

As alterações a seguir se aplicam a todos os aplicativos, independentemente da linguagem de programação.

  • Qualifique os objetos do banco de dados que seu aplicativo usa com nomes de esquema novos e apropriados.

  • Use operadores LIKE para correspondência com distinção entre maiúsculas e minúsculas com o atributo de agrupamento no PostgreSQL.

  • Manipule funções específicas de banco de dados não suportadas como os operadores DATEDIFF, DATEADD, GETDATE, CONVERT e CAST. Para funções equivalentes compatíveis com PostgreSQL, consulte Funções SQL nativas ou integradas na seção Informações adicionais. 

  • Manipule valores booleanos em declarações de comparação.

  • Manipule os valores de retorno das funções. Podem ser conjuntos de registros, data frames, variáveis e valores booleanos. Trate-os de acordo com os requisitos do seu aplicativo e para oferecer suporte ao PostgreSQL.

  • Manipule blocos anônimos (como BEGIN TRAN) com novas funções do PostgreSQL definidas pelo usuário.

  • Converta inserções em massa para linhas. O equivalente do PostgreSQL do utilitário de cópia em massa (bcp) do SQL Server, que é chamado de dentro do aplicativo, é COPY.

  • Converta operadores de concatenação de colunas. O SQL Server usa + para concatenação de strings, mas o PostgreSQL usa ||.

Desenvolvedor de aplicativos
TarefaDescriçãoHabilidades necessárias

Aproveite os serviços da AWS para aprimorar o desempenho.

Ao migrar para a nuvem AWS, você pode refinar o design do aplicativo e do banco de dados para aproveitar os serviços da AWS. Por exemplo, se as consultas do seu aplicativo do Python, que está conectado a um servidor de banco de dados compatível com o Aurora PostgreSQL, estiverem demorando mais do que as consultas originais do Microsoft SQL Server, considere criar um feed de dados históricos diretamente para um bucket do Amazon Simple Storage Service (Amazon S3) a partir do servidor Aurora e usar consultas SQL baseadas no Amazon Athena para gere relatórios e consultas de dados analíticos para seus painéis de usuário.

Desenvolvedor de aplicativos, arquiteto de nuvem

Recursos relacionados

Mais informações

Tanto o Microsoft SQL Server quanto o Aurora compatível com PostgreSQL são compatíveis com o ANSI SQL. No entanto, você ainda deve estar ciente de quaisquer incompatibilidades na sintaxe, nos tipos de dados da coluna, nas funções específicas do banco de dados nativo, nas inserções em massa e na diferenciação de maiúsculas e minúsculas ao migrar seu aplicativo do Python ou Perl do SQL Server para o PostgreSQL.

As seções a seguir fornecem mais informações sobre possíveis inconsistências.

Comparação de tipos de dados

Alterações no tipo de dados do SQL Server para o PostgreSQL podem levar a diferenças significativas nos dados resultantes com os quais os aplicativos operam. Para obter uma comparação dos tipos de dados, consulte a tabela no site da Sqlines.

Funções SQL nativas ou integradas

O comportamento de algumas funções difere entre os bancos de dados SQL Server e PostgreSQL. A tabela a seguir oferece uma comparação.

Microsoft SQL Server

Descrição

PostgreSQL

CAST 

Converte um valor de um tipo de dados para outro.

PostgreSQL type :: operator

GETDATE()

Retorna a data e hora do sistema de banco de dados atual, em um formato YYYY-MM-DD hh:mm:ss.mmm.

CLOCK_TIMESTAMP

DATEADD

Adiciona um intervalo de hora/data a uma data.

Expressão INTERVAL

CONVERT

Converte um valor em um formato de dados específico.

TO_CHAR

DATEDIFF

Retorna a diferença entre duas datas.

DATE_PART

TOP

Limita o número de linhas em um conjunto de SELECT resultados.

LIMIT/FETCH

Blocos anônimos

Uma consulta SQL estruturada é organizada em seções como declaração, executáveis e tratamento de exceções. A tabela a seguir compara as versões do Microsoft SQL Server e PostgreSQL de um bloco anônimo simples. Para blocos anônimos complexos, recomendamos que você chame uma função de banco de dados personalizada em seu aplicativo.

Microsoft SQL Server

PostgreSQL

my $sql_qry1=
my $sql_qry2 =
my $sqlqry = "BEGIN TRAN
$sql_qry1 $sql_qry2
if @\@error !=0 ROLLBACK
TRAN
else COMIT TRAN";
my $sql_qry1=
my $sql_qry2 =
my $sql_qry = " DO \$\$
BEGIN
$header_sql $content_sql
END
\$\$";

 

Outras diferenças

  • Inserções de linhas em massa: o equivalente do PostgreSQL do utilitário bcp do Microsoft SQL Server é COPY.

  • Sensibilidade a maiúsculas e minúsculas: os nomes das colunas diferenciam maiúsculas de minúsculas no PostgreSQL, portanto, é necessário converter os nomes das colunas do SQL Server para letras minúsculas ou maiúsculas. Isso se torna um fator quando você extrai ou compara dados ou coloca nomes de colunas em conjuntos de resultados ou variáveis. O exemplo a seguir identifica colunas nas quais os valores podem ser armazenados em maiúsculas ou minúsculas.

my $sql_qry = "SELECT $record_id FROM $exampleTable WHERE LOWER($record_name) = \'failed transaction\'";

  • Concatenação: o SQL Server usa + como operador para concatenação de strings, enquanto o PostgreSQL usa ||.

  • Validação: você deve testar e validar consultas e funções SQL em linha antes de usá-las no código do aplicativo para PostgreSQL.

  • Inclusão da biblioteca ORM: você também pode procurar incluir ou substituir a biblioteca de conexão de banco de dados existente por bibliotecas ORM do Python, como SQLAlchemy e PynomoDB. Isso ajudará a consultar e manipular facilmente dados de um banco de dados usando um paradigma orientado a objetos.