# Noções básicas da arquitetura e da configuração do Babelfish
Você gerencia o cluster de banco de dados de edição compatível com Aurora PostgreSQL que executa o Babelfish da mesma forma que faria com qualquer cluster de banco de dados do Aurora. Ou seja, você se beneficia da escalabilidade, alta disponibilidade com compatibilidade com failover e replicação integrada fornecida por um cluster de banco de dados do Aurora. Para saber mais sobre esses recursos, consulte [Como gerenciar a performance e a escalabilidade de clusters de banco de dados do Aurora](Aurora.Managing.Performance.md), [Alta disponibilidade do Amazon Aurora](Concepts.AuroraHighAvailability.md) e [Replicação com o Amazon Aurora](Aurora.Replication.md). Você também tem acesso a muitas outras ferramentas e utilitários da AWS, inclusive o seguinte:
+ O Amazon CloudWatch é um serviço de monitoramento e capacidade de observação que fornece dados e informações úteis. Para ter mais informações, consulte [Monitorar métricas do Amazon Aurora com o Amazon CloudWatch](monitoring-cloudwatch.md).
+ O Performance Insights é um recurso de ajuste e monitoramento de performance do banco de dados que ajuda você a avaliar rapidamente a carga em seu banco de dados. Para saber mais, consulte [Monitorar a carga de banco de dados com o Performance Insights no Amazon Aurora](USER_PerfInsights.md).
+ Os bancos de dados globais do Aurora abrangem várias Regiões da AWS, permitindo leituras globais de baixa latência e fornecendo recuperação rápida de qualquer interrupção que possa afetar toda uma Região da AWS. Para ter mais informações, consulte [Usar o Amazon Aurora Global Database](aurora-global-database.md).
+ A aplicação automática de patches de software mantém seu banco de dados atualizado com os patches de segurança e os recursos mais recentes quando estes se tornam disponíveis.
+ Os eventos do Amazon RDS notificam você por e-mail ou mensagem SMS sobre eventos importantes do banco de dados, como um failover automatizado. Para ter mais informações, consulte [Monitorar eventos do Amazon Aurora](working-with-events.md).
A seguir, você pode aprender sobre a arquitetura do Babelfish e como os bancos de dados do SQL Server migrados são processados pelo Babelfish. Ao criar seu cluster de banco de dados do Babelfish, você precisa tomar algumas decisões antecipadamente sobre um único ou vários bancos de dados, agrupamentos e outros detalhes.
**Topics**
+ [Arquitetura do Babelfish](babelfish-architecture.md)
+ [Configurações de grupo de parâmetros de cluster de banco de dados para o Babelfish](babelfish-configuration.md)
+ [Noções básicas sobre agrupamentos no Babelfish para Aurora PostgreSQL](babelfish-collations.md)
+ [Gerenciar o tratamento de erros do Babelfish com hatches de escape](babelfish-strict.md)
# Arquitetura do Babelfish
Quando você cria um cluster do Aurora PostgreSQL com o Babelfish habilitado, o Aurora provisiona o cluster com um banco de dados PostgreSQL denominado `babelfish_db`. Esse banco de dados é o local onde residem todos os objetos e estruturas do SQL Server migrados.
**nota**
Em um cluster do Aurora PostgreSQL, o nome do banco de dados `babelfish_db` é reservado para Babelfish. A criação de seu próprio banco de dados “babelfish\$1db” em um cluster de banco de dados do Babelfish impede o Aurora de provisionar com êxito o Babelfish.
Quando você se conecta à porta do TDS, a sessão é colocada no banco de dados `babelfish_db`. No T-SQL, a estrutura parece semelhante a uma conexão com uma instância do SQL Server. É possível ver os bancos de dados `master`, `msdb` e `tempdb` e o catálogo `sys.databases`. É possível criar bancos de dados de usuário adicionais e alternar entre eles com a instrução USE. Quando você cria um banco de dados de usuários do SQL Server, ele é nivelado no banco de dados PostgreSQL `babelfish_db`. Seu banco de dados retém a sintaxe entre bancos de dados e uma semântica igual ou semelhante àquelas fornecidas pelo SQL Server.
## Utilizar o Babelfish com um único banco de dados ou vários bancos de dados
Ao criar um cluster do Aurora PostgreSQL para uso com o Babelfish, você escolhe entre utilizar um único banco de dados SQL Server em seus próprios bancos de dados SQL Server ou em vários bancos de dados SQL Server juntos. Sua escolha afeta como os nomes dos esquemas do SQL Server dentro do banco de dados `babelfish_db` aparecem no Aurora PostgreSQL. O modo de migração é armazenado no parâmetro `migration_mode`. Você não deve alterar esse parâmetro depois de criar seu cluster, pois pode perder o acesso a todos os objetos SQL criados anteriormente.
No modo single-db, os nomes do esquema do banco de dados SQL Server permanecem os mesmos no banco de dados `babelfish_db` do PostgreSQL. Se você optar por migrar somente um único banco de dados, os nomes dos esquemas do banco de dados de usuário migrado poderão ser referenciados no PostgreSQL com os mesmos nomes usados no SQL Server. Por exemplo, os esquemas `smith` e `dbo` e residem no banco de dados `dbA` *.*
![\[\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/AuroraUserGuide/images/babelfish_single_db_mode.png)
Ao se conectar via TDS, é possível executar `USE dba` para ver esquemas `dbo` e `dev` do T-SQL, como você faria no SQL Server. Os nomes de esquema inalterados também são visíveis no PostgreSQL.
No modo de vários bancos de dados, os nomes dos esquemas dos bancos de dados de usuários se tornam `dbname_schemaname` quando acessados do PostgreSQL. Os nomes dos esquemas permanecem os mesmos quando acessados do T-SQL.
![\[\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/AuroraUserGuide/images/babelfish_multi_db_mode.png)
Como mostrado na imagem, o modo de vários bancos de dados e o modo de banco de dados único são os mesmos que do SQL Server ao se conectar pela porta TDS e usar o T-SQL. Por exemplo, `USE dbA` lista os esquemas `dbo` e `dev` assim como acontece no SQL Server. Os nomes dos esquemas mapeados, como `dba_dbo` e `dba_dev`, são visíveis a partir do PostgreSQL.
Cada banco de dados ainda contém seus esquemas. O nome de cada banco de dados é anexado ao nome do esquema do SQL Server utilizando um sublinhado como delimitador, por exemplo:
+ `dba` contém `dba_dbo` e `dba_dev`.
+ `dbb` contém `dbb_dbo` e `dbb_test`.
+ `dbc` contém `dbc_dbo` e `dbc_prod`.
No interior do banco de dados `babelfish_db`, o usuário T-SQL ainda precisa executar `USE dbname` para alterar o contexto do banco de dados e, portanto, a aparência permanece semelhante à do SQL Server.
## Escolher um modo de migração
Cada modo de migração tem vantagens e desvantagens. Escolha o modo de migração com base no número de bancos de dados de usuários que você possui e seus planos de migração. Depois de criar um cluster para uso com o Babelfish, você não deve alterar o modo de migração, pois pode perder o acesso a todos os objetos SQL criados anteriormente. Ao escolher um modo de migração, considere os requisitos dos seus bancos de dados de usuários e clientes.
Quando você cria um cluster para uso com o Babelfish, o Aurora PostgreSQL cria os bancos de dados do sistema, `master` e `tempdb`. Se você tiver criado ou modificado objetos nos bancos de dados do sistema (`master` ou `tempdb`), certifique-se de recriar esses objetos no novo cluster. Ao contrário do SQL Server, o Babelfish não reinicializa `tempdb` após uma reinicialização do cluster.
Utilize o modo de migração de banco de dados único nos seguintes casos:
+ Se estiver migrando um único banco de dados do SQL Server. No modo de banco de dados único, os nomes de esquemas migrados, quando acessados do PostgreSQL, são idênticos aos nomes de esquemas originais do SQL Server. Isso reduzirá as alterações de código nas consultas SQL existentes se você quiser otimizá-las para execução com uma conexão PostgreSQL.
+ Se o seu objetivo final for uma migração completa para o Aurora PostgreSQL nativo. Antes de migrar, consolide seus esquemas em um único esquema (`dbo`) e depois migre para um único cluster para reduzir as alterações necessárias.
Utilize o modo de migração de vários bancos de dados nos seguintes casos:
+ Se você quiser a experiência padrão do SQL Server com vários bancos de dados de usuários na mesma instância.
+ Se vários bancos de dados de usuários precisarem ser migrados juntos.
# Configurações de grupo de parâmetros de cluster de banco de dados para o Babelfish
Ao criar um cluster de banco de dados do Aurora PostgreSQL e escolher **Turn on Babelfish** (Ativar Babelfish), um grupo de parâmetros de cluster de banco de dados é criado para você automaticamente ao escolher **Create new** (Criar). Esse grupo de parâmetros de cluster de banco de dados é baseado no grupo de parâmetros de cluster de banco de dados do Aurora PostgreSQL para a versão do Aurora PostgreSQL escolhida para a instalação, por exemplo, o Aurora PostgreSQL versão 14. Ele é nomeado usando o seguinte padrão geral:
```
custom-aurora-postgresql14-babelfish-compat-3
```
Você pode alterar as configurações a seguir durante o processo de criação do cluster, mas algumas delas não podem ser alteradas depois de armazenadas no grupo de parâmetros personalizado, então escolha com cuidado:
+ Banco de dados único ou vários bancos de dados
+ Localidade de agrupamentos padrão
+ Nome do agrupamento
+ Grupo de parâmetros de banco de dados
Para usar um grupo de parâmetros de cluster de banco de dados do Aurora PostgreSQL versão 13 ou superior, edite o grupo e defina o parâmetro `babelfish_status` como `on`. Especifique todas as opções do Babelfish antes de criar o cluster do Aurora PostgreSQL. Para saber mais, consulte [Grupos de parâmetros para Amazon Aurora](USER_WorkingWithParamGroups.md).
Os parâmetros a seguir controlam as preferências do Babelfish. Salvo indicação em contrário na Descrição, os parâmetros podem ser modificados. O valor padrão está incluído na descrição. Para ver os valores permitidos para qualquer parâmetro, faça o seguinte:
**nota**
Ao associar um novo grupo de parâmetros de banco de dados a uma instância de banco de dados, os parâmetros estáticos e dinâmicos modificados serão aplicados somente após a reinicialização da instância de banco de dados. No entanto, se você modificar parâmetros dinâmicos no grupo de parâmetros de banco de dados depois de associá-lo à instância de banco de dados, essas alterações serão aplicadas imediatamente sem uma reinicialização.
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Escolha **Parameter groups** (Grupos de parâmetros) no menu de navegação.
1. Escolha o grupo de parâmetros do cluster de banco de dados `default.aurora-postgresql14` na lista.
1. Insira o nome de um parâmetro no campo de pesquisa. Por exemplo, insira `babelfishpg_tsql.default_locale` no campo de pesquisa para exibir esse parâmetro e seu valor padrão e configurações permitidas.
**nota**
Os bancos de dados globais do Babelfish para Aurora PostgreSQL funcionarão em regiões secundárias somente se os parâmetros a seguir estiverem ativados nessas regiões.
| Parameter | Descrição | Aplicar tipo | É modificável |
| --- | --- | --- | --- |
| babelfishpg\$1tsql.apg\$1enable\$1correlated\$1scalar\$1transform | Permite que o planejador transforme a subconsulta escalar correlacionada no Babelfish. (Padrão: ativado) (Permitido: ativado, desativado) | dinâmico | true |
| babelfishpg\$1tsql.apg\$1enable\$1subquery\$1cache | Permite o uso de cache para subconsultas escalares correlacionadas. (Padrão: ativado) (Permitido: ativado, desativado) | dinâmico | true |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1scale | Define a escala padrão do tipo numérico a ser enviada nos metadados da coluna TDS se o mecanismo não especificar uma. (Padrão: 8) (Permitido: 0 a 38) | dinâmico | true |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1precision | Um valor inteiro que define a precisão padrão do tipo numérico a ser enviada nos metadados da coluna do TDS se o mecanismo não especificar uma. (Padrão: 38) (Permitido: 1 a 38) | dinâmico | true |
| babelfishpg\$1tds.tds\$1default\$1packet\$1size | Um valor inteiro que define o tamanho do pacote padrão para conectar clientes do SQL Server. (Padrão: 4096) (Permitido: 512 a 32767) | dinâmico | true |
| babelfishpg\$1tds.tds\$1default\$1protocol\$1version | Um valor inteiro que define uma versão padrão do protocolo TDS para conectar clientes. (Padrão: DEFAULT) (Permitido: TDSv7.0, TDSv7.1, TDSv7.1.1, TDSv7.2, TDSv7.3A, TDSv7.3B, TDSv7.4, DEFAULT) | dinâmico | true |
| babelfishpg\$1tds.default\$1server\$1name | Uma string que identifica o nome padrão do servidor do Babelfish. (Padrão: Microsoft SQL Server) (Permitido: null) | dinâmico | true |
| babelfishpg\$1tds.tds\$1debug\$1log\$1level | Um valor inteiro que define o nível de registro em log no TDS; 0 desativa o registro em log. (Padrão: 1) (Permitido: 0, 1, 2, 3) | dinâmico | true |
| babelfishpg\$1tds.listen\$1addresses | Uma string que define o nome do host ou um ou mais endereços IP nos quais ouvir o TDS. Esse parâmetro não pode ser modificado após a criação do cluster de banco de dados do Babelfish. (Padrão: \$1) (Permitido: null) | – | false |
| babelfishpg\$1tds.port | Um valor inteiro que especifica a porta TCP utilizada para solicitações na sintaxe do SQL Server. (Padrão: 1433) (Permitido: 1 a 65535) | estático | true |
| babelfishpg\$1tds.tds\$1ssl\$1encrypt | Um valor booliano que ativa (0) ou desativa (1) a criptografia de dados que atravessam a porta do ouvinte do TDS. Para obter informações detalhadas sobre como utilizar o SSL para conexões de cliente, consulte [Configurações SSL e conexões do cliente do Babelfish](#babelfish-ssl). (Padrão: 0) (Permitido: 0, 1) | dinâmico | true |
| babelfishpg\$1tds.tds\$1ssl\$1max\$1protocol\$1version | Uma string que especifica a versão mais alta do protocolo SSL/TLS a ser utilizada na sessão do TDS. (Padrão: “TLSv1.2”) (Permitido: “TLSv1”, “TLSv1.1”, “TLSv1.2”) | dinâmico | true |
| babelfishpg\$1tds.tds\$1ssl\$1min\$1protocol\$1version | Uma string que especifica a versão mínima do protocolo SSL/TLS a ser utilizada na sessão do TDS. (Padrão: “TLSv1.2” do Aurora PostgreSQL versão 16, “TLSv1.1” para versões anteriores ao Aurora PostgreSQL versão 16) (Permitido: “TLSv1”, “TLSv1.1”, “TLSv1.2”). | dinâmico | true |
| babelfishpg\$1tds.unix\$1socket\$1directories | Uma string que identifica o diretório de soquetes Unix do servidor do TDS. Esse parâmetro não pode ser modificado após a criação do cluster de banco de dados do Babelfish. (Padrão: /tmp) (Permitido: null) | – | false |
| babelfishpg\$1tds.unix\$1socket\$1group | Uma string que identifica o grupo de soquetes Unix do servidor do TDS. Esse parâmetro não pode ser modificado após a criação do cluster de banco de dados do Babelfish. (Padrão: rdsdb) (Permitido: null) | – | false |
| babelfishpg\$1tsql.default\$1locale | Uma string que especifica a localidade padrão usada para agrupamentos do Babelfish. A localidade padrão é apenas a localidade e não inclui qualificadores. Defina esse parâmetro ao provisionar um cluster de banco de dados do Babelfish. Depois que o cluster de banco de dados for provisionado, as alterações nesse parâmetro serão ignoradas. (Padrão: en\$1US) (Permitido: consulte [tabelas](babelfish-collations.md)) | estático | true |
| babelfishpg\$1tsql.migration\$1mode | Uma lista não modificável que especifica a compatibilidade com bancos de dados de usuário único ou vários usuários. Defina esse parâmetro ao provisionar um cluster de banco de dados do Babelfish. Após o provisionamento do cluster de banco de dados, não é possível modificar o valor desse parâmetro. (Padrão: multi-db do Aurora PostgreSQL versão 16, single-db para versões anteriores à versão 16 do Aurora PostgreSQL) (Permitidos: single-db, multi-db, null) | estático | true |
| babelfishpg\$1tsql.server\$1collation\$1name | A string que especifica o nome do agrupamento utilizado para ações em nível de servidor. Defina esse parâmetro ao provisionar um cluster de banco de dados do Babelfish. Após o provisionamento do cluster de banco de dados, não modifique o valor desse parâmetro. (Padrão: bbf\$1unicode\$1general\$1ci\$1as) (Permitido: consulte [tabelas](babelfish-collations.md)) | estático | true |
| babelfishpg\$1tsql.version | Uma string que define a saída da variável @@VERSION. Não modifique esse valor para clusters de bancos de dados Aurora PostgreSQL. (Padrão: null) (Permitido: padrão) | dinâmico | true |
| rds.babelfish\$1status | Uma string que define o estado da funcionalidade do Babelfish. Quando esse parâmetro está definido como `datatypesonly`, o Babelfish está desativado, mas os tipos de dados do SQL Server ainda estão disponíveis. (Padrão: desativado) (Permitido: ativado, desativado, datatypesonly) | estático | true |
| unix\$1socket\$1permissions | Um número inteiro que define as permissões de soquete Unix do servidor do TDS. Esse parâmetro não pode ser modificado após a criação do cluster de banco de dados do Babelfish. (Padrão: 0700) (Permitido: 0 a 511) | – | false |
## Configurações SSL e conexões do cliente do Babelfish
Para exigir conexões SSL/TLS com o cluster de bancos de dados do Babelfish para Aurora PostgreSQL, use o parâmetro `rds.force_ssl`.
+ Para exigir conexões SSL/TLS, defina o valor do parâmetro `rds.force_ssl` como 1 (ativado).
+ Para desativar as conexões SSL/TLS obrigatórias, defina o valor do parâmetro `rds.force_ssl` como 0 (desativado).
O valor padrão desse parâmetro depende da versão do Aurora PostgreSQL:
+ Para o Aurora PostgreSQL versões 17 e posteriores: o valor padrão é 1 (ativado).
+ Para o Aurora PostgreSQL versões 16 e posteriores: o valor padrão é 0 (desativado).
**nota**
Quando você realiza uma atualização de versão principal do Aurora PostgreSQL versão 16 ou anterior para a versão 17 ou posterior, o valor padrão do parâmetro muda de 0 (desativado) para 1 (ativado). Essa alteração pode causar falhas de conectividade em aplicações que não estão configuradas para SSL. Você pode reverter para o comportamento padrão anterior definindo esse parâmetro como 0 (desativado).
Para obter detalhes específicos do driver, consulte [Conectar-se a um cluster de banco de dados do Babelfish](babelfish-connect.md).
Quando um cliente se conecta à porta do TDS (`1433` padrão), o Babelfish compara a configuração do Secure Sockets Layer (SSL) enviada durante o handshake do cliente com a configuração do parâmetro SSL do Babelfish (`tds_ssl_encrypt`). O Babelfish então determina se uma conexão é permitida. Em caso positivo, o comportamento de criptografia pode ser aplicado ou não, dependendo das configurações de parâmetros e do suporte à criptografia oferecido pelo cliente.
A seguinte tabela mostra como o Babelfish se comporta para cada combinação.
| Configuração SSL do cliente | Configuração SSL do Babelfish | rds.force\$1ssl | Conexão permitida? | Valor retornado ao cliente |
| --- | --- | --- | --- | --- |
| ENCRYPT\$1ON | Any | Any | Permitido, a conexão inteira é criptografada | ENCRYPT\$1ON |
| ENCRYPT\$1OFF | tds\$1ssl\$1encrypt=1 | Any | Permitido, a conexão inteira é criptografada | ENCRYPT\$1REQ |
| ENCRYPT\$1OFF | tds\$1ssl\$1encrypt=0 | rds.force\$1ssl=0 | Permitida, o pacote de login é criptografado | ENCRYPT\$1OFF |
| ENCRYPT\$1OFF | tds\$1ssl\$1encrypt=0 | rds.force\$1ssl=1 | Não, conexão encerrada | ENCRYPT\$1OFF |
| ENCRYPT\$1NOT\$1SUP | tds\$1ssl\$1encrypt=0 | rds.force\$1ssl=0 | Sim | ENCRYPT\$1NOT\$1SUP |
| ENCRYPT\$1NOT\$1SUP | tds\$1ssl\$1encrypt=1 | Any | Não, conexão encerrada | ENCRYPT\$1REQ |
| ENCRYPT\$1NOT\$1SUP | tds\$1ssl\$1encrypt=0 | rds.force\$1ssl=1 | Não, conexão encerrada | ENCRYPT\$1NOT\$1SUP |
| ENCRYPT\$1CLIENT\$1CERT | Any | Any | Não, conexão encerrada | Sem suporte |
# Noções básicas sobre agrupamentos no Babelfish para Aurora PostgreSQL
Ao criar um cluster de banco de dados do Aurora PostgreSQL com o Babelfish, você escolhe um agrupamento para seus dados. Um *agrupamento* especifica a ordem de classificação e os padrões de bits que produzem o texto ou os caracteres em determinada linguagem humana escrita. Um agrupamento inclui regras que comparam dados de determinado conjunto de padrões de bits. O agrupamento está relacionado à localização. Localidades diferentes afetam o mapeamento de caracteres, a ordem de classificação e similares. Os atributos de agrupamento são refletidos nos nomes de vários agrupamentos. Para obter informações sobre atributos, consulte [Babelfish collation attributes table](#bfish-collation-attributes-table).
O Babelfish mapeia agrupamentos do SQL Server para agrupamentos comparáveis que são fornecidos pelo Babelfish. O Babelfish predefine agrupamentos Unicode com comparações de string culturalmente sensíveis e ordens de classificação. O Babelfish também fornece uma maneira de converter os agrupamentos no banco de dados SQL Server para o agrupamento Babelfish de correspondência mais próxima. Agrupamentos específicos de localidade são fornecidos para diferentes idiomas e regiões.
Alguns agrupamentos definem uma página de código que corresponde a uma codificação no lado do cliente. O Babelfish converte automaticamente da codificação do servidor na codificação do cliente, dependendo do agrupamento de cada coluna de saída.
O Babelfish é compatível com os agrupamentos listados na [Babelfish supported collations table](#bfish-collations-table). O Babelfish mapeia agrupamentos do SQL Server para agrupamentos comparáveis que são fornecidos pelo Babelfish.
O Babelfish usa a versão 153.80 da biblioteca de agrupamentos International Components for Unicode (ICU). Para obter mais informações sobre agrupamentos ICU, consulte [Collation](https://unicode-org.github.io/icu/userguide/collation/) (Agrupamento)) na documentação da ICU. Para saber mais sobre o PostgreSQL e agrupamentos, consulte [Collation Support](https://www.postgresql.org/docs/current/collation.html) (Compatibilidade com agrupamentos) na documentação do PostgreSQL.
**Topics**
+ [Parâmetros de cluster de banco de dados que controlam o agrupamento e a localidade](#babelfish-collations.parameters)
+ [Agrupamentos determinísticos e não determinísticos no Babelfish](#babelfish-collations.deterministic-nondeterministic)
+ [Agrupamentos permitidos no nível do banco de dados no Babelfish](#babelfish-collations.database-level)
+ [Agrupamentos de servidor e objetos no Babelfish](#babelfish-collations.reference-tables-supported-collations)
+ [Comportamento padrão de agrupamentos no Babelfish](#babelfish-collations-default)
+ [Gerenciar agrupamentos](collation.managing.md)
+ [Limitações de agrupamentos e diferenças de comportamento](collation.limitations.md)
## Parâmetros de cluster de banco de dados que controlam o agrupamento e a localidade
Os parâmetros a seguir afetam o comportamento do agrupamento.
**babelfishpg\$1tsql.default\$1locale**
Esse parâmetro especifica a localidade padrão usada pelo agrupamento. Esse parâmetro é utilizado em combinação com os atributos listados na [Babelfish collation attributes table](#bfish-collation-attributes-table) para personalizar agrupamentos para um idioma e uma região específicos. O valor padrão desse parâmetro é `en-US`.
A localidade padrão aplica-se a todos os nomes de agrupamentos do Babelfish que começam com “BBF” e a todos os agrupamentos do SQL Server mapeados para agrupamentos do Babelfish. Alterar a configuração para esse parâmetro em um cluster de banco de dados do Babelfish existente não afeta a localidade dos agrupamentos existentes. Para ver a lista de agrupamentos, consulte a [Babelfish supported collations table](#bfish-collations-table).
**babelfishpg\$1tsql.server\$1collation\$1name**
Esse parâmetro especifica o agrupamento padrão para o servidor (instância de cluster de banco de dados do Aurora PostgreSQL) e do banco de dados. O valor padrão é `sql_latin1_general_cp1_ci_as`. `server_collation_name` deve ser um agrupamento `CI_AS`, pois no T-SQL o agrupamento de servidor determina como os identificadores são comparados.
Ao criar seu cluster de banco de dados do Babelfish, escolha o **Collation name** (Nome do agrupamento) na lista selecionável. Estes incluem os agrupamentos listados na [Babelfish supported collations table](#bfish-collations-table). Não modifique `server_collation_name` depois que o banco de dados Babelfish for criado.
As configurações escolhidas ao criar seu cluster de banco de dados do Babelfish para Aurora PostgreSQL são armazenadas no grupo de parâmetros do cluster de banco de dados associado ao cluster para esses parâmetros e definem seu comportamento de agrupamento.
## Agrupamentos determinísticos e não determinísticos no Babelfish
O Babelfish oferece suporte para agrupamentos determinísticos e não determinísticos:
+ Um *agrupamento determinístico* avalia caracteres que têm sequências de bytes idênticas como iguais. Isso significa que `x` e `X` não são iguais em um agrupamento determinístico. Agrupamentos determinísticos fazem distinção de maiúsculas e minúsculas (CS) e dialetos (AS).
+ Um *agrupamento não determinístico* não precisa de correspondência idêntica. Um agrupamento não determinístico avalia `x` e `X` como iguais. Agrupamentos não determinísticos não fazem distinção de maiúsculas e minúsculas (CI) e de acentos (IA).
Na tabela a seguir, você pode encontrar algumas diferenças de comportamento entre o Babelfish e o PostgreSQL ao usar agrupamentos não determinísticos.
| Babelfish | PostgreSQL |
| --- | --- |
| É compatível com a cláusula LIKE para agrupamentos CI\$1AS. | Não é compatível com a cláusula LIKE em agrupamentos não determinísticos. |
| É compatível com a cláusula LIKE somente nos seguintes agrupamentos de IA do Babelfish versão 4.2.0: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/AuroraUserGuide/babelfish-collations.html) | Não é compatível com a cláusula LIKE em agrupamentos não determinísticos. |
Para obter uma lista de outras limitações e diferenças de comportamento do Babelfish em comparação com o SQL Server e o PostgreSQL, consulte [Limitações de agrupamentos e diferenças de comportamento](collation.limitations.md).
O Babelfish e o SQL Server seguem uma convenção de nomenclatura para agrupamentos que descrevem os atributos de agrupamento, conforme mostrado na tabela a seguir.
| Atributo | Descrição |
| --- | --- |
| AI | Não tem distinção entre dialetos. |
| AS | Tem distinção entre dialetos. |
| BIN2 | O BIN2 solicita que os dados sejam classificados em ordem de pontos de código. A ordem dos pontos de código Unicode é a mesma ordem de caracteres de codificações UTF-8, UTF-16 e UCS-2. A ordem de pontos de código é um agrupamento determinístico rápido. |
| CI | Não tem distinção entre maiúsculas e minúsculas. |
| CS | Tem distinção entre maiúsculas e minúsculas. |
| PREF | Para classificar letras maiúsculas antes de letras minúsculas, utilize um agrupamento PREF. Se a comparação não diferenciar maiúsculas de minúsculas, a versão em maiúsculas de uma letra será classificada antes da versão em minúscula, caso não haja outra distinção. A biblioteca ICU oferece suporte à preferência de maiúsculas com `colCaseFirst=upper`, mas não para agrupamentos CI\$1AS. PREF só pode ser aplicado a agrupamentos determinísticos `CS_AS`. |
## Agrupamentos permitidos no nível do banco de dados no Babelfish
Os seguintes agrupamentos são permitidos no nível do banco de dados no Babelfish:
+ bbf\$1unicode\$1bin2
+ bbf\$1unicode\$1cp1\$1ci\$1ai
+ bbf\$1unicode\$1cp1\$1ci\$1as
+ bbf\$1unicode\$1cp1250\$1ci\$1ai
+ bbf\$1unicode\$1cp1250\$1ci\$1as
+ bbf\$1unicode\$1cp1257\$1ci\$1ai
+ bbf\$1unicode\$1cp1257\$1ci\$1as
+ estonian\$1ci\$1ai
+ estonian\$1ci\$1as
+ finnish\$1swedish\$1ci\$1ai
+ finnish\$1swedish\$1ci\$1as
+ french\$1ci\$1ai
+ french\$1ci\$1as
+ latin1\$1general\$1bin2
+ latin1\$1general\$1ci\$1ai
+ latin1\$1general\$1ci\$1as
+ latin1\$1general\$190\$1bin2
+ latin1\$1general\$1100\$1bin2
+ latin1\$1general\$1140\$1bin2
+ modern\$1spanish\$1ci\$1ai
+ modern\$1spanish\$1ci\$1as
+ polish\$1ci\$1ai
+ polish\$1ci\$1as
+ sql\$1latin1\$1general\$1cp1\$1ci\$1ai
+ sql\$1latin1\$1general\$1cp1\$1ci\$1as
+ sql\$1latin1\$1general\$1cp1250\$1ci\$1as
+ sql\$1latin1\$1general\$1cp1251\$1ci\$1as
+ sql\$1latin1\$1general\$1cp1257\$1ci\$1as
+ traditional\$1spanish\$1ci\$1ai
+ traditional\$1spanish\$1ci\$1as
**nota**
Para usar um agrupamento diferente no nível do banco de dados, certifique-se de que ele corresponda ao agrupamento no nível do servidor. Para ter mais informações, consulte [Agrupamentos de servidor e objetos no Babelfish](#babelfish-collations.reference-tables-supported-collations).
## Agrupamentos de servidor e objetos no Babelfish
Use os seguintes agrupamentos como um agrupamento de servidor ou um agrupamento de objetos.
| ID de agrupamento | Observações |
| --- | --- |
| bbf\$1unicode\$1general\$1ci\$1as | Oferece suporte à comparação sem distinção entre maiúsculas e minúsculas e operador LIKE. |
| bbf\$1unicode\$1cp1\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1252.txt), também conhecido como CP1252. |
| bbf\$1unicode\$1CP1250\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1250.txt) utilizado para representar textos em idiomas da Europa Central e do Leste Europeu que utilizam o script latino. |
| bbf\$1unicode\$1CP1251\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1251.txt) para linguagens que utilizam o script cirílico. |
| bbf\$1unicode\$1cp1253\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1253.txt) utilizado para representar o grego moderno. |
| bbf\$1unicode\$1cp1254\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1254.txt) que é compatível com o idioma turco. |
| bbf\$1unicode\$1cp1255\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1255.txt) que é compatível com o idioma hebraico. |
| bbf\$1unicode\$1cp1256\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1256.txt) utilizado para escrever idiomas que utilizam o script árabe. |
| bbf\$1unicode\$1cp1257\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1257.txt) utilizado para suporte aos idiomas estoniano, letão e lituano. |
| bbf\$1unicode\$1cp1258\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1258.txt) utilizado para escrever caracteres em vietnamita. |
| bbf\$1unicode\$1cp874\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit874.txt) utilizado para escrever caracteres em tailandês. |
| sql\$1latin1\$1general\$1cp1250\$1ci\$1as | [Codificação de caracteres de byte único não determinística](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1250.txt) utilizado para representar caracteres latinos. |
| sql\$1latin1\$1general\$1cp1251\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1251.txt) que oferece suporte a caracteres latinos. |
| sql\$1latin1\$1general\$1cp1\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1252.txt) que oferece suporte a caracteres latinos. |
| sql\$1latin1\$1general\$1cp1253\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1253.txt) que oferece suporte a caracteres latinos. |
| sql\$1latin1\$1general\$1cp1254\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1254.txt) que oferece suporte a caracteres latinos. |
| sql\$1latin1\$1general\$1cp1255\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1255.txt) que oferece suporte a caracteres latinos. |
| sql\$1latin1\$1general\$1cp1256\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1256.txt) que oferece suporte a caracteres latinos. |
| sql\$1latin1\$1general\$1cp1257\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1257.txt) que oferece suporte a caracteres latinos. |
| sql\$1latin1\$1general\$1cp1258\$1ci\$1as | [Agrupamento não determinístico](https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit1258.txt) que oferece suporte a caracteres latinos. |
| chinese\$1prc\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma chinês (RPC). |
| cyrillic\$1general\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma cirílico. |
| finnish\$1swedish\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma finlandês. |
| french\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma francês. |
| japanese\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma japonês. Compatível com o Babelfish 2.1.0 e versões posteriores. |
| korean\$1wansung\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma coreano (com classificação de dicionário). |
| latin1\$1general\$1ci\$1as | Agrupamento não determinístico que oferece suporte a caracteres latinos. |
| modern\$1spanish\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma espanhol moderno. |
| polish\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma polonês. |
| thai\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma tailandês. |
| traditional\$1spanish\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma espanhol (tipo tradicional). |
| turkish\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma turco. |
| ukrainian\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma ucraniano. |
| vietnamese\$1ci\$1as | Agrupamento não determinístico que é compatível com o idioma vietnamita. |
Os seguintes agrupamentos podem ser utilizados como agrupamentos de objetos.
| Dialeto | Opções determinísticas | Opções não determinísticas |
| --- | --- | --- |
| Árabe | Arabic\$1CS\$1AS | Arabic\$1CI\$1AS Arabic\$1CI\$1AI |
| Alfabeto árabe | BBF\$1Unicode\$1CP1256\$1CS\$1AS BBF\$1Unicode\$1Pref\$1CP1256\$1CS\$1AS | BBF\$1Unicode\$1CP1256\$1CI\$1AI BBF\$1Unicode\$1CP1256\$1CS\$1AI |
| Binário | latin1\$1general\$1bin2 BBF\$1Unicode\$1BIN2 | – |
| Idiomas da Europa Central e do Leste Europeu que utilizam o alfabeto latino | BBF\$1Unicode\$1CP1250\$1CS\$1AS BBF\$1Unicode\$1Pref\$1CP1250\$1CS\$1AS | BBF\$1Unicode\$1CP1250\$1CI\$1AI BBF\$1Unicode\$1CP1250\$1CS\$1AI |
| Chinês | Chinese\$1PRC\$1CS\$1AS | Chinese\$1PRC\$1CI\$1AS Chinese\$1PRC\$1CI\$1AI |
| Cyrillic\$1General | Cyrillic\$1General\$1CS\$1AS | Cyrillic\$1General\$1CI\$1AS Cyrillic\$1General\$1CI\$1AI |
| Alfabeto cirílico | BBF\$1Unicode\$1CP1251\$1CS\$1AS BBF\$1Unicode\$1Pref\$1CP1251\$1CS\$1AS | BBF\$1Unicode\$1CP1251\$1CI\$1AI BBF\$1Unicode\$1CP1251\$1CS\$1AI |
| Estoniano | Estonian\$1CS\$1AS | Estonian\$1CI\$1AS Estonian\$1CI\$1AI |
| Estoniano, letão e lituano | BBF\$1Unicode\$1CP1257\$1CS\$1AS BBF\$1Unicode\$1Pref\$1CP1257\$1CS\$1AS | BBF\$1Unicode\$1CP1257\$1CI\$1AI BBF\$1Unicode\$1CP1257\$1CS\$1AI |
| Finnish\$1Swedish | Finnish\$1Swedish\$1CS\$1AS | Finnish\$1Swedish\$1CI\$1AS Finnish\$1Swedish\$1CI\$1AI |
| Francês | French\$1CS\$1AS | French\$1CI\$1AS French\$1CI\$1AI |
| Grego | Greek\$1CS\$1AS | Greek\$1CI\$1AS Greek\$1CI\$1AI |
| Hebraico | BBF\$1Unicode\$1CP1255\$1CS\$1AS BBF\$1Unicode\$1Pref\$1CP1255\$1CS\$1AS Hebrew\$1CS\$1AS | BBF\$1Unicode\$1CP1255\$1CI\$1AI BBF\$1Unicode\$1CP1255\$1CS\$1AI Hebrew\$1CI\$1AS Hebrew\$1CI\$1AI |
| Japonês (Babelfish 2.1.0 e posteriores) | Japanese\$1CS\$1AS | Japanese\$1CI\$1AI Japanese\$1CI\$1AS |
| Korean\$1Wamsung | Korean\$1Wamsung\$1CS\$1AS | Korean\$1Wamsung\$1CI\$1AS Korean\$1Wamsung\$1CI\$1AI |
| Caracteres latinos para a página de código CP1252 | latin1\$1general\$1cs\$1as BBF\$1Unicode\$1General\$1CS\$1AS BBF\$1Unicode\$1General\$1Pref\$1CS\$1AS BBF\$1Unicode\$1Pref\$1CP1\$1CS\$1AS BBF\$1Unicode\$1CP1\$1CS\$1AS | latin1\$1general\$1ci\$1as latin1\$1general\$1ci\$1ai latin1\$1general\$1cs\$1ai BBF\$1Unicode\$1General\$1CI\$1AI BBF\$1Unicode\$1General\$1CS\$1AI BBF\$1Unicode\$1CP1\$1CI\$1AI BBF\$1Unicode\$1CP1\$1CS\$1AI |
| Grego moderno | BBF\$1Unicode\$1CP1253\$1CS\$1AS BBF\$1Unicode\$1Pref\$1CP1253\$1CS\$1AS | BBF\$1Unicode\$1CP1253\$1CI\$1AI BBF\$1Unicode\$1CP1253\$1CS\$1AI |
| Modern\$1Spanish | Modern\$1Spanish\$1CS\$1AS | Modern\$1Spanish\$1CI\$1AS Modern\$1Spanish\$1CI\$1AI |
| Mongol | Mongolian\$1CS\$1AS | Mongolian\$1CI\$1AS Mongolian\$1CI\$1AI |
| Polonês | Polish\$1CS\$1AS | polish\$1ci\$1as Polish\$1CI\$1AI |
| Tailandês | BBF\$1Unicode\$1CP874\$1CS\$1AS BBF\$1Unicode\$1Pref\$1CP874\$1CS\$1AS Thai\$1CS\$1AS | BBF\$1Unicode\$1CP874\$1CI\$1AI BBF\$1Unicode\$1CP874\$1CS\$1AI Thai\$1CI\$1AS, Thai\$1CI\$1AI |
| Traditional\$1Spanish | Traditional\$1Spanish\$1CS\$1AS | Traditional\$1Spanish\$1CI\$1AS Traditional\$1Spanish\$1CI\$1AI |
| Turco | BBF\$1Unicode\$1CP1254\$1CS\$1AS BBF\$1Unicode\$1Pref\$1CP1254\$1CS\$1AS Turkish\$1CS\$1AS | BBF\$1Unicode\$1CP1254\$1CI\$1AI BBF\$1Unicode\$1CP1254\$1CS\$1AI Turkish\$1CI\$1AS, Turkish\$1CI\$1AI |
| Ucraniano | Ukranian\$1CS\$1AS | Ukranian\$1CI\$1AS Ukranian\$1CI\$1AI |
| Vietnamita | BBF\$1Unicode\$1CP1258\$1CS\$1AS BBF\$1Unicode\$1Pref\$1CP1258\$1CS\$1AS Vietnamese\$1CS\$1AS | BBF\$1Unicode\$1CP1258\$1CI\$1AI BBF\$1Unicode\$1CP1258\$1CS\$1AI Vietnamese\$1CI\$1AS Vietnamese\$1CI\$1AI |
## Comportamento padrão de agrupamentos no Babelfish
Antes, o agrupamento padrão dos tipos de dados agrupáveis era `pg_catalog.default`. Os tipos de dados e os objetos que dependem desses tipos de dados seguem um agrupamento que diferencia maiúsculas de minúsculas. Essa condição pode afetar os objetos T-SQL do conjunto de dados com agrupamento que não diferencia maiúsculas de minúsculas. A partir do Babelfish 2.3.0, o agrupamento padrão para os tipos de dados agrupáveis (exceto TEXT e NTEXT) é o mesmo que o agrupamento no parâmetro `babelfishpg_tsql.server_collation_name`. Quando você atualiza para o Babelfish 2.3.0, o agrupamento padrão é escolhido automaticamente no momento da criação do cluster de banco de dados, o que não cria nenhum impacto visível.
# Gerenciar agrupamentos
A biblioteca ICU fornece rastreamento de versão de agrupamento para garantir que os índices que dependem de agrupamentos possam ser reindexados quando uma nova versão do ICU estiver disponível. Para ver se o banco de dados atual tem agrupamentos que precisam ser atualizados, você pode usar a seguinte consulta depois de se conectar usando `psql` ou `pgAdmin`:
```
SELECT pg_describe_object(refclassid, refobjid,
refobjsubid) AS "Collation",
pg_describe_object(classid, objid, objsubid) AS "Object"
FROM pg_depend d JOIN pg_collation c ON refclassid = 'pg_collation'::regclass
AND refobjid = c.oid WHERE c.collversion <> pg_collation_actual_version(c.oid)
ORDER BY 1, 2;
```
Essa consulta retorna o seguinte resultado:
```
Collation | Object
-----------+--------
(0 rows)
```
Neste exemplo, nenhum agrupamento precisa ser atualizado.
Para obter uma lista dos agrupamentos predefinidos em seu banco de dados do Babelfish, você pode usar `psql` ou `pgAdmin` com a seguinte consulta:
```
SELECT * FROM pg_collation;
```
Agrupamentos predefinidos são armazenados na tabela `sys.fn_helpcollations`. É possível utilizar o seguinte comando para exibir informações sobre um agrupamento (como os sinalizadores lcid, style e collate). Para obter uma lista de todos os agrupamentos usando `sqlcmd`, conecte-se à porta T-SQL (1433, por padrão) e execute a seguinte consulta:
```
1> :setvar SQLCMDMAXVARTYPEWIDTH 40
2> :setvar SQLCMDMAXFIXEDTYPEWIDTH 40
3> SELECT * FROM fn_helpcollations()
4> GO
name description
---------------------------------------- ----------------------------------------
arabic_cs_as Arabic, case-sensitive, accent-sensitive
arabic_ci_ai Arabic, case-insensitive, accent-insensi
arabic_ci_as Arabic, case-insensitive, accent-sensiti
bbf_unicode_bin2 Unicode-General, case-sensitive, accent-
bbf_unicode_cp1250_ci_ai Default locale, code page 1250, case-ins
bbf_unicode_cp1250_ci_as Default locale, code page 1250, case-ins
bbf_unicode_cp1250_cs_ai Default locale, code page 1250, case-sen
bbf_unicode_cp1250_cs_as Default locale, code page 1250, case-sen
bbf_unicode_pref_cp1250_cs_as Default locale, code page 1250, case-sen
bbf_unicode_cp1251_ci_ai Default locale, code page 1251, case-ins
bbf_unicode_cp1251_ci_as Default locale, code page 1251, case-ins
bbf_unicode_cp1254_ci_ai Default locale, code page 1254, case-ins
...
(124 rows affected)
```
As linhas 1 e 2 mostradas no exemplo restringem a saída apenas para fins de legibilidade da documentação.
```
1> SELECT SERVERPROPERTY('COLLATION')
2> GO
serverproperty
---------------------------------------------------------------------------
sql_latin1_general_cp1_ci_as
(1 rows affected)
1>
```
# Limitações de agrupamentos e diferenças de comportamento
O Babelfish usa a biblioteca ICU para suporte a agrupamentos. O PostgreSQL é construído com uma versão específica do ICU e pode corresponder no máximo uma versão de um agrupamento. Variações entre versões são inevitáveis, assim como pequenas variações ao longo do tempo à medida que os idiomas evoluem. Na lista a seguir, você pode encontrar algumas limitações conhecidas e variações de comportamento dos agrupamentos do Babelfish:
+ **Índices e dependência de tipo de agrupamento**: um índice em um tipo definido pelo usuário que depende da biblioteca de agrupamentos International Components for Unicode (ICU) (biblioteca utilizada pelo Babelfish) não é invalidado quando a versão da biblioteca é alterada.
+ **Função COLLATIONPROPERTY**: propriedades de agrupamento são implementadas apenas para os agrupamentos BBF do Babelfish compatíveis. Para obter mais informações, consulte [Babelfish supported collations table](babelfish-collations.md#bfish-collations-table).
+ **Diferenças de regras de classificação Unicode**: agrupamentos SQL para o SQL Server classificam dados codificados em Unicode (`nchar` e `nvarchar`) de forma diferente dos dados que não são codificados em Unicode (`char` e `varchar`). Os bancos de dados do Babelfish são sempre codificados em UTF-8 e sempre aplicam regras de classificação Unicode de maneira consistente, independentemente do tipo de dados, portanto, a ordem de classificação para `char` ou `varchar` é a mesmo que para `nchar` ou `nvarchar`.
+ **Agrupamentos de igualdade secundária e comportamento da classificação**: o agrupamento padrão ICU de igualdade secundária Unicode (`CI_AS`) classifica sinais de pontuação e outros caracteres não alfanuméricos antes dos caracteres numéricos e os caracteres numéricos antes dos caracteres alfabéticos. No entanto, a ordem de pontuação e outros caracteres especiais é diferente.
+ **Agrupamentos terciários, solução alternativa para ORDER BY**: agrupamentos SQL, como `SQL_Latin1_General_Pref_CP1_CI_AS`, são compatíveis com a função `TERTIARY_WEIGHTS` e a capacidade de classificar strings que se comparam igualmente em um agrupamento `CI_AS` para classificação inicialmente em maiúsculas: `ABC`, `ABc`, `AbC`, `Abc`, `aBC`, `aBc`, `abC` e finalmente `abc`. Assim, a função `DENSE_RANK OVER (ORDER BY column)` analítica avalia essas strings como tendo a mesma classificação, mas as ordena em maiúsculas primeiro dentro de uma partição.
Você pode obter um resultado semelhante com o Babelfish adicionando uma cláusula `COLLATE` à cláusula `ORDER BY` que especifica um agrupamento `CS_AS` terciário que especifica `@colCaseFirst=upper`. No entanto, o modificador `colCaseFirst` aplica-se somente a strings com igualdade terciária (em vez de igualdade secundária, como um agrupamento `CI_AS`). Por isso, você não pode emular agrupamentos SQL terciários utilizando um único agrupamento ICU.
Como solução alternativa, convém aplicações que utilizam o agrupamento `SQL_Latin1_General_Pref_CP1_CI_AS` de forma a utilizar o agrupamento `BBF_SQL_Latin1_General_CP1_CI_AS` primeiro. Em seguida, adicione `COLLATE BBF_SQL_Latin1_General_Pref_CP1_CS_AS` a qualquer cláusula `ORDER BY` para essa coluna.
+ **Expansão de caracteres**: uma expansão de caracteres trata um único caractere como igual a uma sequência de caracteres em nível primário. O agrupamento padrão do SQL Server `CI_AS` é compatível com a expansão de caracteres. Os agrupamentos de ICU são compatíveis com a expansão de caracteres somente para agrupamentos que não distinguem dialetos.
Quando a expansão de caracteres for necessária, utilize um agrupamento `AI` para comparações. No entanto, esses agrupamentos atualmente não têm suporte pelo operador LIKE.
+ **Codificação char e varchar**: quando agrupamentos SQL são utilizados para tipos de dados `char` ou `varchar`, a ordem de classificação dos caracteres antes de ASCII 127 é determinada pela página de código específica desse agrupamento SQL. Para agrupamentos SQL, as strings declaradas como `char` ou `varchar` podem ser classificadas de maneira diferente de strings declaradas como `nchar` ou `nvarchar`.
O PostgreSQL codifica todas as strings com a codificação do banco de dados, para que todos os caracteres sejam convertidos em UTF-8 e classificados utilizando regras Unicode.
Como os agrupamentos SQL classificam tipos de dados nchar e nvarchar utilizando regras Unicode, o Babelfish codifica todas as strings no servidor utilizando UTF-8. O Babelfish classifica strings nchar e nvarchar da mesma maneira que classifica strings char e varchar, utilizando regras Unicode.
+ **Caractere suplementar**: as funções do SQL Server `NCHAR`, `UNICODE` e `LEN` são compatíveis com caracteres para pontos de código fora do Unicode Basic Multilingual Plane (BMP). Em contraste, agrupamentos não SC utilizam caracteres de pares substitutos para lidar com caracteres suplementares. Para tipos de dados Unicode, o SQL Server pode representar até 65.535 caracteres utilizando UCS-2 ou o intervalo Unicode completo (1.114.111 caracteres) se forem utilizados caracteres suplementares.
+ **Agrupamentos que fazem distinção do Kana (KS)**: um agrupamento que faz distinção do Kana (KS) é aquele que trata caracteres Kana japoneses `Hiragana` e `Katakana` de forma diferente. O ICU é compatível com o padrão de agrupamento japonês `JIS X 4061`. O agora obsoleto modificador de localidade `colhiraganaQ [on | off]` pode fornecer a mesma funcionalidade que agrupamentos KS. No entanto, agrupamentos KS com o mesmo nome que os do SQL Server atualmente não têm suporte pelo Babelfish.
+ **Agrupamentos sensíveis à largura (WS)**: quando um caractere de byte único (meia largura) e o mesmo caractere representado como um caractere de byte duplo (largura total) são tratados de maneiras diferentes, o agrupamento é chamado de *sensível à largura (WS)*. Agrupamentos WS com o mesmo nome que os do SQL Server atualmente não têm suporte pelo Babelfish.
+ **Agrupamentos que fazem distinção do seletor de variação (VSS)**: agrupamentos que fazem distinção do seletor de variação (VSS) distinguem entre seletores de variação ideográfica em agrupamentos `Japanese_Bushu_Kakusu_140` e `Japanese_XJIS_140` do japonês. Uma sequência de variação é composta por um caractere base mais um seletor de variação adicional. Se você não selecionar a opção `_VSS`, o seletor de variação não será considerado na comparação.
Atualmente, agrupamentos VSS não têm suporte pelo Babelfish.
+ **Agrupamentos BIN e BIN2**: um agrupamento BIN2 classifica os caracteres de acordo com a ordem de pontos de código. A ordem binária byte a byte do UTF-8 preserva a ordem dos pontos de código Unicode e, portanto, é provável que esse também seja o agrupamento com a melhor performance. Se a ordem de pontos de código Unicode funcionar para uma aplicação, considere utilizar um agrupamento BIN2. No entanto, o uso de um agrupamento BIN2 pode resultar na exibição de dados no cliente em uma ordem culturalmente inesperada. Como novos mapeamentos para caracteres em minúsculas são adicionados ao Unicode com o passar do tempo, a função `LOWER` pode operar de maneira diferente em diferentes versões do ICU. Esse é um caso especial do problema mais geral de versionamento de agrupamentos, e não algo específico do agrupamento BIN2.
O Babelfish fornece o agrupamento `BBF_Latin1_General_BIN2` com a distribuição do Babelfish para agrupar em ordem de pontos de código Unicode. Em um agrupamento BIN, somente o primeiro caractere é classificado como um wchar. Os caracteres restantes são classificados byte a byte, efetivamente na ordem de pontos de código, de acordo com a codificação. Essa abordagem não segue regras de agrupamento Unicode e não tem suporte pelo Babelfish.
+ **Agrupamentos não determinísticos e limitação CHARINDEX**: para versões do Babelfish anteriores à versão 2.1.0, você não pode usar CHARINDEX com agrupamentos não determinísticos. Por padrão, o Babelfish usa um agrupamento que não faz distinção de maiúsculas e minúsculas (não determinístico). Usar CHARINDEX para versões anteriores do Babelfish gera o seguinte erro de tempo de execução:
```
nondeterministic collations are not supported for substring searches
```
**nota**
Essa limitação e solução alternativa se aplicam somente ao Babelfish versão 1.x (versões 13.x do Aurora PostgreSQL). O Babelfish 2.1.0 e versões posteriores não têm esse problema.
Para contornar este problema, execute um dos seguintes procedimentos:
+ Converta explicitamente a expressão em um agrupamento que diferencie letras maiúsculas de minúsculas e deixe em minúsculas ambos os argumentos aplicando LOWER ou UPPER. Por exemplo, `SELECT charindex('x', a) FROM t1` transforma-se no seguinte:
```
SELECT charindex(LOWER('x'), LOWER(a COLLATE sql_latin1_general_cp1_cs_as)) FROM t1
```
+ Crie a função f\$1charindex do SQL e substitua chamadas CHARINDEX por chamadas para a seguinte função:
```
CREATE function f_charindex(@s1 varchar(max), @s2 varchar(max)) RETURNS int
AS
BEGIN
declare @i int = 1
WHILE len(@s2) >= len(@s1)
BEGIN
if LOWER(@s1) = LOWER(substring(@s2,1,len(@s1))) return @i
set @i += 1
set @s2 = substring(@s2,2,999999999)
END
return 0
END
go
```
# Gerenciar o tratamento de erros do Babelfish com hatches de escape
O Babelfish imita o comportamento do SQL para fluxo de controle e estado de transações sempre que possível. Quando o Babelfish encontra um erro, ele retorna um código de erro semelhante ao código de erro do SQL Server. Se o Babelfish não conseguir mapear o erro para um código do SQL Server, ele retornará um código de erro fixo (`33557097`) e realizará ações específicas com base no tipo de erro, da seguinte forma:
+ Se for um erro de tempo de compilação, o Babelfish reverterá a transação.
+ No caso de erros de tempo de execução, o Babelfish encerrará o lote e reverterá a transação.
+ Para um erro de protocolo entre o cliente e o servidor, a transação não será revertida.
Se um código de erro não puder ser mapeado para um código equivalente, e o código de um erro semelhante estiver disponível, o código do erro será mapeado para esse código alternativo. Por exemplo, os comportamentos que causam os códigos `8143` e `8144` do SQL Server são ambos mapeados para `8143`.
Erros que não podem ser mapeados não respeitam uma construção `TRY... CATCH`.
Você pode usar `@@ERROR` para retornar um código de erro do SQL Server ou a função `@@PGERROR` para retornar um código de erro do PostgreSQL. Também pode utilizar a função `fn_mapped_system_error_list` para retornar uma lista de códigos de erro mapeados. Para obter informações sobre códigos de erro do PostgreSQL, consulte o [site do PostgreSQL](https://www.postgresql.org/docs/current/errcodes-appendix.html).
## Modificar as configurações do hatch de escape do Babelfish
Para lidar com instruções que podem falhar, o Babelfish define certas opções denominadas hatches de escape. Um *hatch de escape* é uma opção que especifica o comportamento do Babelfish quando ele se depara com um recurso ou uma sintaxe sem suporte.
Você pode utilizar o procedimento armazenado `sp_babelfish_configure` para controlar as configurações de um hatch de escape. Use o script para definir o hatch de escape como `ignore` ou `strict`. Se estiver definido como `strict`, o Babelfish retornará um erro que você precisará corrigir antes de continuar.
Para aplicar as alterações à sessão atual e no nível do cluster, inclua a palavra-chave `server`.
O uso é o seguinte:
+ Para listar todos os hatches de escape e seu status, além de informações de uso, execute `sp_babelfish_configure`.
+ Para listar os hatches de escape nomeados e seus valores, seja para a sessão atual ou em todo o cluster, execute o comando `sp_babelfish_configure 'hatch_name'`, em que `hatch_name` é o identificador de um ou mais hatches de escape. *hatch\$1name* pode utilizar curingas SQL, como "%".
+ Para definir um ou mais hatches de escape para o valor especificado, execute `sp_babelfish_configure ['hatch_name' [, 'strict'|'ignore' [, 'server']]`. Para tornar as configurações permanentes em todo o cluster, inclua a palavra-chave `server`, conforme mostrado a seguir:
```
EXECUTE sp_babelfish_configure 'escape_hatch_unique_constraint', 'ignore', 'server'
```
Para configurá-las apenas para a sessão atual, não use `server`.
+ Para redefinir todos os hatches de escape para seus valores padrão, execute `sp_babelfish_configure 'default'` (Babelfish 1.2.0 e posterior).
A string que identifica o hatch (ou os hatches) pode conter curingas SQL. Por exemplo, o seguinte define todos os hatches de escape de sintaxe como `ignore` para o cluster do Aurora PostgreSQL.
```
EXECUTE sp_babelfish_configure '%', 'ignore', 'server'
```
Na tabela a seguir, você pode encontrar descrições e valores padrão para os hatches de escape predefinidos do Babelfish.
| Hatch de escape | Descrição | Padrão |
| --- | --- | --- |
| escape\$1hatch\$1checkpoint | Permite o uso da instrução CHECKPOINT no código processual, mas a instrução CHECKPOINT não está implementada no momento. | ignorar |
| escape\$1hatch\$1constraint\$1name\$1for\$1default | Controla o comportamento do Babelfish relacionado a nomes de restrições padrão. | ignorar |
| escape\$1hatch\$1database\$1misc\$1options | Controla o comportamento do Babelfish relacionado às seguintes opções em CREATE DATABASE: CONTAINMENT, DB\$1CHAINING, TRUSTWORTHY, PERSISTENT\$1LOG\$1BUFFER. | ignorar |
| escape\$1hatch\$1for\$1replication | Controla o comportamento do Babelfish relacionado à cláusula [NOT] FOR REPLICATION ao criar ou modificar uma tabela. | strict |
| escape\$1hatch\$1fulltext | Controla o comportamento do Babelfish relacionado a recursos FULLTEXT, como DEFAULT\$1FULLTEXT\$1LANGUAGE in CREATE/ALTER DATABASE, CREATE FULLTEXT INDEX ou sp\$1fulltext\$1database. | ignorar |
| escape\$1hatch\$1ignore\$1dup\$1key | Controla o comportamento do Babelfish relacionado a CREATE/ALTER TABLE e CREATE INDEX. Quando IGNORE\$1DUP\$1KEY=ON, é gerado um erro quando definido como `strict` (o padrão) ou o erro é ignorado quando definido como `ignore` (Babelfish versão 1.2.0 e posterior). | strict |
| escape\$1hatch\$1index\$1clustering | Controla o comportamento do Babelfish relacionado às palavras-chave CLUSTERED ou NONCLUSTERED para índices e restrições PRIMARY KEY ou UNIQUE. Quando CLUSTERED é ignorado, o índice ou a restrição ainda é criado como se NONCLUSTERED tivesse sido especificada. | ignorar |
| escape\$1hatch\$1index\$1columnstore | Controla o comportamento do Babelfish relacionado à cláusula COLUMNSTORE. Se você especificar `ignore`, o Babelfish criará um índice normal de árvore B. | strict |
| escape\$1hatch\$1join\$1hints | Controla o comportamento de palavras-chave em um operador JOIN: LOOP, HASH, MERGE, REMOTE, REDUCE, REDISTRIBUTE, REPLICATE. | ignorar |
| escape\$1hatch\$1language\$1non\$1english | Controla o comportamento do Babelfish relacionado a idiomas diferentes do inglês para mensagens na tela. No momento, o Babelfish oferece suporte apenas a `us_english` para mensagens na tela. SET LANGUAGE pode utilizar uma variável contendo o nome do idioma e, portanto, o idioma real que está sendo definido apenas pode ser detectado em tempo de execução. | strict |
| escape\$1hatch\$1login\$1hashed\$1password | Quando ignorada, suprime o erro para a palavra-chave `HASHED` para `CREATE LOGIN` e `ALTER LOGIN`. | strict |
| escape\$1hatch\$1login\$1misc\$1options | Quando ignorada, suprime o erro para outras palavras-chave além de `HASHED`, `MUST_CHANGE`, `OLD_PASSWORD` e `UNLOCK`para `CREATE LOGIN` e `ALTER LOGIN`. | strict |
| escape\$1hatch\$1login\$1old\$1password | Quando ignorada, suprime o erro para a palavra-chave `OLD_PASSWORD` para `CREATE LOGIN` e `ALTER LOGIN`. | strict |
| escape\$1hatch\$1login\$1password\$1must\$1change | Quando ignorada, suprime o erro para a palavra-chave `MUST_CHANGE` para `CREATE LOGIN` e `ALTER LOGIN`. | strict |
| escape\$1hatch\$1login\$1password\$1unlock | Quando ignorada, suprime o erro para a palavra-chave `UNLOCK` para `CREATE LOGIN` e `ALTER LOGIN`. | strict |
| escape\$1hatch\$1nocheck\$1add\$1constraint | Controla o comportamento do Babelfish relacionado à cláusula WITH CHECK ou NOCHECK para restrições. | strict |
| escape\$1hatch\$1nocheck\$1existing\$1constraint | Controla o comportamento do Babelfish relacionado a restrições FOREIGN KEY ou CHECK. | strict |
| escape\$1hatch\$1query\$1hints | Controla o comportamento do Babelfish relacionado a dicas de consultas. Quando essa opção é definida como ignore, o servidor ignora as dicas que usam a cláusula OPTION (...) para especificar aspectos de processamento de consultas. Exemplos incluem SELECT FROM... OPTION(MERGE JOIN HASH, MAXRECURSION 10)). | ignorar |
| escape\$1hatch\$1rowversion | Controla o comportamento dos tipos de dados ROWVERSION e TIMESTAMP. Para ter mais informações, consulte [Usar recursos do Babelfish com implementação limitada](babelfish-compatibility.tsql.limited-implementation.md). | strict |
| escape\$1hatch\$1schemabinding\$1function | Controla o comportamento do Babelfish referente à cláusula WITH SCHEMABINDING. Por padrão, a cláusula WITH SCHEMABINDING é ignorada ao ser especificada com o comando CREATE ou ALTER FUNCTION. | ignorar |
| escape\$1hatch\$1schemabinding\$1procedure | Controla o comportamento do Babelfish referente à cláusula WITH SCHEMABINDING. Por padrão, a cláusula WITH SCHEMABINDING é ignorada ao ser especificada com o comando CREATE ou ALTER PROCEDURE. | ignorar |
| escape\$1hatch\$1rowguidcol\$1column | Controla o comportamento do Babelfish relacionado à cláusula ROWGUIDCOL ao criar ou modificar uma tabela. | strict |
| escape\$1hatch\$1schemabinding\$1trigger | Controla o comportamento do Babelfish referente à cláusula WITH SCHEMABINDING. Por padrão, a cláusula WITH SCHEMABINDING é ignorada ao ser especificada com o comando CREATE ou ALTER TRIGGER. | ignorar |
| escape\$1hatch\$1schemabinding\$1view | Controla o comportamento do Babelfish referente à cláusula WITH SCHEMABINDING. Por padrão, a cláusula WITH SCHEMABINDING é ignorada ao ser especificada com o comando CREATE ou ALTER VIEW. | ignorar |
| escape\$1hatch\$1session\$1settings | Controla o comportamento do Babelfish em relação a instruções SET em nível de sessão incompatíveis. | ignorar |
| escape\$1hatch\$1showplan\$1all | Controla o comportamento do Babelfish com relação a SET SHOWPLAN\$1ALL e SET STATISTICS PROFILE. Quando definidos para serem ignorados, eles se comportam como SET BABELFISH\$1SHOWPLAN\$1ALL e SET BABELFISH\$1STATISTICS PROFILE; quando definidos para serem estritos, são ignorados silenciosamente. | strict |
| escape\$1hatch\$1storage\$1on\$1partition | Controla o comportamento do Babelfish relacionado à cláusula `ON partition_scheme column ` ao definir o particionamento. Atualmente, o Babelfish não implementa particionamento. | strict |
| escape\$1hatch\$1storage\$1options | Hatch de escape em qualquer opção de armazenamento utilizada em CREATE, ALTER DATABASE, TABLE, INDEX. Isso inclui cláusulas (LOG) ON, TEXTIMAGE\$1ON e FILESTREAM\$1ON que definem locais de armazenamento (partições e grupos de arquivos) para tabelas, índices e restrições e também para um banco de dados. Essa configuração de hatch de escape aplica-se a todas essas cláusulas (incluindo ON [PRIMARY] e ON “DEFAULT”). A exceção é quando uma partição é especificada para uma tabela ou um índice com ON partition\$1scheme (coluna). | ignorar |
| escape\$1hatch\$1table\$1hints | Controla o comportamento de dicas de tabelas especificadas utilizando a cláusula WITH (...). | ignorar |
| escape\$1hatch\$1unique\$1constraint | Quando definido como estrito, uma diferença semântica obscura entre o SQL Server e o PostgreSQL no tratamento de valores NULL em colunas indexadas pode gerar erros. A diferença semântica só surge em casos de uso não realistas, para que você possa definir esse hatch de escape como “ignorar” para evitar ver o erro. Obsoleto nas seguintes versões: 3.6.0 e versões posteriores, 4.2.0 e versões posteriores. | strict |