Este documento faz parte de uma série que fornece informações importantes e orientações relacionadas a planejamento e execução de migrações de banco de dados Oracle® 11g/12c para o Cloud SQL para MySQL versão 5.7, instâncias de segunda geração. A série inclui as partes a seguir:
- Como migrar usuários do Oracle para o Cloud SQL para MySQL: terminologia e funcionalidade (este documento)
- Como migrar usuários do Oracle para o Cloud SQL para MySQL: tipos de dados, usuários e tabelas
- Como migrar usuários do Oracle para o Cloud SQL para MySQL: consultas, procedimentos armazenados, funções e gatilhos
- Como migrar usuários da Oracle para o Cloud SQL para MySQL: segurança, operações, monitoramento e geração de registros
Terminologia
Nesta seção, detalhamos as semelhanças e diferenças de terminologia de banco de dados entre o Oracle e o Cloud SQL para MySQL. Analisamos e comparamos os principais aspectos de cada plataforma de banco de dados. A comparação distingue as versões 11g e 12c do Oracle devido a diferenças de arquitetura (por exemplo, o Oracle 12c introduz o recurso multilocatário). A versão do Cloud SQL para MySQL mencionada aqui é a 5.7.x.
Diferenças de terminologia entre o Oracle 11g e o Cloud SQL para MySQL
Oracle 11g | Descrição | Cloud SQL para MySQL | Principais diferenças |
---|---|---|---|
instância | Uma única instância do Oracle 11g pode conter apenas um banco de dados. | instância | Uma instância do MySQL pode conter vários bancos de dados. |
banco de dados | Um banco de dados se qualifica como instância única (o nome do banco de dados é idêntico ao nome da instância). | banco de dados | Bancos de dados múltiplos ou únicos atendem a vários aplicativos. |
esquema | O esquema e os usuários são idênticos porque ambos são considerados proprietários de objetos de banco de dados (um usuário pode ser criado sem especificar ou ser alocado para um esquema). | esquema | Um esquema é chamado de banco de dados, enquanto objetos de banco de dados são criados em um determinado esquema/banco de dados. |
usuário | Idêntico ao esquema porque ambos são proprietários de objetos de banco de dados. Por exemplo, instância → banco de dados → esquemas/usuários → objetos de banco de dados. | usuário | Um usuário de banco de dados com permissões específicas para conectar ou modificar objetos de banco de dados em esquemas/bancos de dados específicos. Por exemplo, instância → bancos de dados/esquemas → objetos de banco de dados. |
papel | Conjunto definido de permissões de banco de dados que podem ser encadeadas como um grupo e atribuídas a usuários de banco de dados. | privilégios do MySQL | O MySQL 5.7 não é compatível com o gerenciamento de papéis. As permissões podem ser configuradas usando a cláusula GRANT para que os usuários tenham privilégios sobre objetos de banco de dados em níveis diferentes (READ/WRITE etc.). |
usuários administradores/do sistema | Usuários administradores do Oracle com o nível mais alto de acesso:SYS SYSTEM |
superusuários | Depois de implantado, o Cloud SQL para MySQL tem o usuário root@'%' (pode se conectar de qualquer host) e um outro usuário denominado mysql.sys , que só pode se conectar do host local. |
dicionário/metadados | O Oracle usa as tabelas de metadados a seguir:USER_TableName ALL_TableName DBA_TableName |
dicionário/metadados | O MySQL usa vários bancos de dados/esquemas para dicionário/metadados:MYSQL INFORMATION_SCHEMA PERFORMANCE_SCHEMA SYS |
visualizações dinâmicas do sistema | Visualizações dinâmicas do Oracle:V$ViewName |
visualizações dinâmicas do sistema | As visualizações dinâmicas do MySQL são encontradas em vários bancos de dados do sistema:INFORMATION_SCHEMA PERFORMANCE_SCHEMA SYS |
tablespace | As principais estruturas de armazenamento lógico dos bancos de dados Oracle. Cada tablespace pode conter um ou mais arquivos de dados. | tablespace | Assim como o Oracle, um tablespace MySQL é uma unidade lógica, mas representa uma única tabela, ao contrário do tablespace Oracle, que pode ter vários arquivos de dados (contém dados de várias tabelas). O MySQL aceita a criação de um novo tablespace com um arquivo de dados alocado e, em seguida, a criação de uma nova tabela anexada ao tablespace recém-criado. As configurações de tablespace, como dimensionamento e limites, são definidas por parâmetros de banco de dados, e não durante a criação do tablespace. |
arquivos de dados | Os elementos físicos de um banco de dados Oracle que armazenam os dados e são definidos em um tablespace específico. Um único arquivo de dados é definido pelos tamanhos inicial e máximo, podendo conter dados de várias tabelas. Os arquivos de dados do Oracle usam o sufixo .dbf (não obrigatório). |
arquivos de dados | O Cloud SQL para MySQL usa o parâmetro innodb_file_per_table com o valor "ON " (padrão), configuração que gera um novo arquivo de dados para cada tabela e um tablespace dedicado.Os arquivos de dados do MySQL usam arquivos .ibd (dados) e .frm (metadados). |
tablespace do sistema | Contém as tabelas do dicionário de dados e exibe objetos de todo o banco de dados Oracle. | tablespace do sistema | Assim como no Oracle, contém as tabelas de dicionário/metadados. Armazenado no tablespace innodb_system anexado ao arquivo de dados ibdata1 . |
tablespace temporário | Contém objetos de esquema válidos durante a sessão. Além disso, acomoda a execução de operações que não cabem na memória do servidor. | tablespace temporário | O objetivo é idêntico ao do Oracle, armazenado no tablespace innodb_temporary do MySQL anexado ao arquivo de dados ibtmp1 . |
tablespace Undo |
Um tipo especial de tablespace permanente do sistema usado pelo Oracle para gerenciar operações de reversão ao executar o banco de dados no modo de gerenciamento desfazer automaticamente (padrão). | tablespace Undo | Assim como no Oracle, o tablespace Undo do MySQL contém registros de desfazer para fins de reversão. Por padrão, essa opção é definida como OFF e mencionada como obsoleta para versões futuras do MySQL. |
ASM | O Gerenciamento automático de armazenamento do Oracle é um sistema de arquivos de banco de dados integrado de alto desempenho e gerenciador de disco executado automaticamente por um banco de dados Oracle configurado com ASM. | incompatível | O MySQL usa o termo mecanismos de armazenamento para descrever diferentes implementações de manipulação de dados, mas não é compatível com o Oracle ASM. O Cloud SQL para MySQL é compatível com muitos recursos para automação de armazenamento, como aumentos automáticos, desempenho e escalonabilidade. |
tabelas/visualizações | Objetos de banco de dados fundamentais criados pelo usuário. | tabelas/visualizações | Recurso idêntico ao do Oracle. |
visualizações materializadas | Definidas com instruções SQL específicas, podendo ser atualizadas de forma manual ou automática com base em configurações específicas. | incompatível com o MySQL | Como solução alternativa, é possível usar gatilhos/visualizações em vez de visualizações materializadas do Oracle. |
sequência | Gerador de valor exclusivo do Oracle. | incremento automático | O MySQL não é compatível com sequências do Oracle. Use AUTO_INCREMENT como solução alternativa à funcionalidade de geração automática de sequências. |
sinônimo | Objetos de banco de dados Oracle que funcionam como identificadores alternativos de outros objetos de banco de dados. | incompatível | O MySQL não é compatível com Oracle Synonym. Como solução alternativa, é possível usar visualizações ao definir as permissões apropriadas. |
particionamento | O Oracle fornece muitas soluções de particionamento para dividir tabelas grandes em partes gerenciadas menores. | particionamento | O MySQL aceita particionamento mais limitado para melhorar o desempenho, mantendo as operações de gerenciamento e manutenção de dados, como as partições do Oracle. |
banco de dados flashback | Recurso reservado do Oracle que pode ser usado para inicializar um banco de dados Oracle em um horário predefinido, permitindo consultar ou restaurar dados que foram modificados ou corrompidos por engano. | incompatível | Como solução alternativa, use os backups e a recuperação pontual do Cloud SQL para restaurar um banco de dados a um estado anterior (por exemplo, restaurar antes de uma queda de tabela). |
sqlplus | Interface de linha de comando do Oracle que permite consultar e gerenciar a instância do banco de dados. | mysql | Interface de linha de comando equivalente ao MySQL para consulta e gerenciamento. Pode ser conectado de qualquer cliente com as devidas permissões ao Cloud SQL. |
PL/SQL | Linguagem de procedimentos estendida para ANSI SQL. | MySQL | O MySQL tem a própria linguagem de procedimentos estendida, com sintaxe e implementação diferentes, sem nomes extras para essa linguagem estendida. |
pacote e corpo do pacote | Funcionalidade específica do Oracle para agrupar procedimentos e funções armazenados na mesma referência lógica. | incompatível | O MySQL é compatível com procedimentos e funções armazenados como objetos únicos com alocação de grupo. |
funções e procedimentos armazenados | Usa PL/SQL para implementar a funcionalidade de código. | funções e procedimentos armazenados | A criação de procedimentos e funções armazenados é aceita pelo MySQL com a implementação de linguagem de procedimentos proprietária. |
gatilho | Objeto Oracle usado para controlar a implementação de DML em tabelas. | gatilho | Recurso idêntico ao do Oracle. |
PFILE/SPFILE | Os parâmetros em nível de instância e banco de dados do Oracle são mantidos em um arquivo binário conhecido como SPFILE (nas versões anteriores, o arquivo era chamado PFILE ), que pode ser usado como arquivo de texto para definir parâmetros manualmente. |
sinalizações de banco de dados do Cloud SQL para MySQL | É possível definir ou modificar os parâmetros do Cloud SQL para MySQL com sinalizações de banco de dados. Não é possível alterar os parâmetros de banco de dados no Cloud SQL para MySQL usando a interface de linha de comando do cliente MySQL (por exemplo, mysql>
SET GLOBAL ... ). Só é possível alterar esses parâmetros usando sinalizações de banco de dados. |
SGA/PGA/AMM | Parâmetros de memória do Oracle que controlam a alocação de memória para a instância de banco de dados. |
INNODB_BUFFER_POOL_SIZE
|
O MySQL tem parâmetros de memória próprios. Um parâmetro equivalente seria INNODB_BUFFER_POOL_SIZE . No Cloud SQL para MySQL, esse parâmetro é predefinido pelo tipo de instância escolhido e o valor é alterado de acordo. |
cache de resultados | Reduz as operações de E/S do SQL recuperando linhas do cache do buffer, que podem ser gerenciadas com parâmetros de banco de dados e dicas no nível de sessão. | cache de consultas | Tem a mesma finalidade fundamental do cache de resultados do Oracle e pode ser gerenciado nos níveis de banco de dados e de sessão. |
dicas de banco de dados | Impacto controlado nas instruções SQL que influenciam o comportamento do otimizador para melhorar o desempenho. O Oracle tem mais de 50 dicas de banco de dados. | dicas de banco de dados | O MySQL é compatível com um conjunto limitado de dicas de banco de dados, em comparação com o Oracle (dicas do otimizador e dicas de índice). Observe que o MySQL usa dicas de banco de dados, sintaxe e nomenclatura diferentes. |
RMAN | Utilitário Recovery Manager do Oracle. Usado para fazer backups de banco de dados com funcionalidade estendida visando a compatibilidade com vários cenários de recuperação de desastres e muito mais (clonagem etc.). | backup do Cloud SQL para MySQL | O Cloud SQL para MySQL oferece dois métodos para aplicar backup completo: sob demanda e backups automáticos. |
Data Pump (EXPDP/IMPDP) | Utilitário de geração de despejo do Oracle que pode ser usado para muitos recursos, como exportação/importação, backup de banco de dados (em nível de esquema ou objeto), metadados de esquema, geração de arquivos SQL de esquema e muito mais. | mysqldump/mysqlimport |
Utilitário de despejo (exportação) do MySQL que pode ser conectado como um cliente (remotamente) e gerar um arquivo dump (SQL). Posteriormente, será possível compactar o arquivo dump e movê-lo para o Cloud Storage. O utilitário mysqldump é usado apenas na etapa de exportação. |
SQL*Loader | Ferramenta que permite fazer upload de dados de arquivos externos, como arquivos de texto, arquivos CSV e muito mais. | mysqlimport/ |
O utilitário mysqlimport permite carregar arquivos de texto ou CSV (o Oracle é compatível com mais formatos de arquivo) em uma tabela de banco de dados com uma estrutura correspondente. |
Data Guard | Solução de recuperação de desastres do Oracle que usa uma instância de espera, permitindo que os usuários executem operações "READ" da instância de espera. | alta disponibilidade e replicação do Cloud SQL para MySQL | Para conseguir recuperação de desastres ou alta disponibilidade, o Cloud SQL para MySQL oferece a arquitetura de réplica de failover e operações somente leitura (separação READ/WRITE) usando a réplica de leitura. |
Active Data Guard/Golden Gate | As principais soluções de replicação do Oracle, que podem atender a várias finalidades, como espera (DR), instância somente leitura, replicação bidirecional (várias origens), armazenamento de dados e muito mais. | réplica de leitura do Cloud SQL para MySQL | Réplica de leitura do Cloud SQL para MySQL para implementar clustering com separação READ/WRITE. No momento, não há compatibilidade com a configuração de várias origens, como replicação bidirecional do Golden Gate ou replicação heterogênea. |
RAC | Oracle Real Application Cluster. Solução de clustering proprietária da Oracle para fornecer alta disponibilidade implantando várias instâncias de banco de dados em uma única unidade de armazenamento. | incompatível | A arquitetura de várias origens ainda não é compatível com o Google Cloud SQL. Para conseguir a arquitetura de clustering com separação READ/WRITE e alta disponibilidade, use a alta disponibilidade do Cloud SQL e a réplica de leitura. |
Grid/Cloud Control (OEM) | Software Oracle para gerenciar e monitorar bancos de dados e outros serviços relacionados em um formato de app da Web. Esta ferramenta é útil para análise de banco de dados em tempo real para entender cargas de trabalho altas. | Console do Cloud SQL para MySQL, Cloud Monitoring | Use o Cloud SQL para MySQL para monitoramento, incluindo gráficos detalhados baseados em tempo e recursos. Use também o Cloud Monitoring para reter métricas de monitoramento e análises de registro específicas do MySQL como recursos avançados de monitoramento. |
registros REDO | Registros de transações do Oracle que consistem em dois (ou mais) arquivos definidos pré-alocados para armazenar todas as modificações de dados à medida que ocorrem. A finalidade do registro refazer é proteger o banco de dados em caso de falha na instância. | registros REDO | O MySQL também tem arquivos de registros redo (em inglês), que são usados durante a recuperação de falhas para corrigir dados gravados pelo mecanismo de registros redo de transações incompletas. |
registros Archive | Os registros Archive são compatíveis com operações de backup e replicação e muito mais. O Oracle grava em registros Archive (se ativados) após cada operação de chave de registro redo. | binlogs | Implementação do MySQL para retenção de registros de transação. Usados principalmente para fins de replicação (ativados por padrão com o Cloud SQL). |
arquivo de controle | O arquivo de controle do Oracle contém informações sobre o banco de dados, como arquivos de dados, nomes de registros redo e locais, o número sequencial de registro atual e informações sobre o checkpoint da instância. | MySQL | A arquitetura do MySQL não inclui um arquivo de controle semelhante ao da implementação do Oracle. Isso é controlado por parâmetros do MySQL e usando o comando SHOW MASTER STATUS para ver a posição atual do registro binário. |
SCN | O número de alteração do sistema (SCN, na sigla em inglês) do Oracle é o principal método para manter a consistência de dados em todos os componentes do banco de dados Oracle para atender ao modelo de transação ACID. | número sequencial do registro | A implementação do MySQL para consistência de banco de dados usa o número sequencial do registro (LSN, na sigla em inglês). |
AWR | O repositório automático de carga de trabalho (AWR, na sigla em inglês) do Oracle é um relatório detalhado que fornece informações detalhadas sobre o desempenho da instância do banco de dados Oracle, sendo considerado uma ferramenta de DBA para diagnósticos de desempenho. | performance_schema |
O MySQL não tem um relatório equivalente ao AWR do Oracle, mas o MySQL reúne dados de desempenho coletados por performance_schema . Uma solução alternativa seria usar os painéis de desempenho do MySQL Workbench (em inglês). |
DBMS_SCHEDULER |
Utilitário do Oracle usado para definir e cronometrar operações predefinidas. | EVENT_SCHEDULER |
Funcionalidade do programador interno do banco de dados MySQL. Por padrão, esse recurso é definido como OFF . |
criptografia de dados transparente | Criptografa dados armazenados em discos como proteção de dados em repouso. | padrão de criptografia avançada do Cloud SQL | O Cloud SQL para MySQL usa o padrão de criptografia avançada (AES-256) de 256 bits para proteção de segurança de dados em repouso, bem como para dados em trânsito. |
compactação avançada | Para melhorar o tamanho do armazenamento do banco de dados, reduzir os custos de armazenamento e melhorar o desempenho do banco de dados, o Oracle fornece recursos avançados de compactação de dados (tabelas/índices). | compactação de tabela InnoDB | Para oferecer compactação de tabela (em inglês), o MySQL cria uma tabela usando o parâmetro ROW_FORMAT definido como COMPRESSED . Leia mais sobre compactação de índice (em inglês). |
SQL Developer | GUI SQL gratuita do Oracle para gerenciar e executar instruções SQL e PL/SQL (também pode ser usada com o MySQL). | MySQL Workbench | GUI SQL gratuita do MySQL para gerenciar e executar instruções de código SQL e MySQL. |
registro de alertas | Registro principal do Oracle para operações e erros gerais de banco de dados. | registro de erros do MySQL | Usa o visualizador de registros do Cloud Logging para observar os registros de erros do MySQL. |
tabela DUAL |
Controle de tabela especial do Oracle principalmente para recuperar valores de pseudocolunas, como SYSDATE ou USER . |
tabela DUAL | O MySQL permite especificar DUAL como uma tabela em instruções SQL que não dependem de dados de tabela alguma. |
tabela externa | O Oracle permite que os usuários criem tabelas externas com dados de origem em arquivos fora do banco de dados. | incompatível | Sem equivalente direto. |
Listener | Processo de rede do Oracle com a tarefa de escutar conexões de banco de dados recebidas. | redes autorizadas do Cloud SQL | O MySQL aceita conexões de origens remotas quando permitido na página de configuração Redes autorizadas do Cloud SQL. |
TNSNAMES | Arquivo de configuração de rede do Oracle que define endereços de banco de dados para estabelecer conexões usando aliases de conexão. | não existe | O MySQL aceita conexões externas usando o nome de conexão da instância do Cloud SQL ou o endereço IP privado/público. O Cloud SQL Proxy é mais um método de acesso seguro para se conectar ao Cloud SQL para MySQL (instâncias de segunda geração) sem ter que permitir endereços IP específicos ou configurar SSL. |
porta padrão da instância | 1521 | porta padrão da instância | 3306 |
link do banco de dados | Objetos de esquema do Oracle que podem ser usados para interagir com objetos de banco de dados locais/remotos. | incompatível | Como solução alternativa, use o código do aplicativo para se conectar a e recuperar dados de um banco de dados remoto. |
Diferenças de terminologia entre o Oracle 12c e o Cloud SQL para MySQL
Oracle 12c | Descrição | Cloud SQL para MySQL | Principais diferenças |
---|---|---|---|
instância | Capacidade de vários locatários, introduzida na instância do Oracle 12c, capaz de conter vários bancos de dados como um banco de dados plugável (PDB, na sigla em inglês), ao contrário do Oracle 11g, em que uma instância do Oracle só pode receber um banco de dados. | instância | O Cloud SQL para MySQL pode conter vários bancos de dados com nomes diferentes, atendendo a vários serviços e aplicativos. |
CDB | Um banco de dados de contêiner de vários locatários (CDB, na sigla em inglês) é compatível com um ou mais PDBs, sendo possível criar objetos globais de CDB (o que afeta todos os PDBs), como papéis. | instância do MySQL | A instância do MySQL é comparável ao CDB do Oracle. Ambos fornecem uma camada de sistema para PDBs. |
PDB | É possível usar os bancos de dados plugáveis (PDBs) para isolar serviços de aplicativos e como uma coleção portátil de esquemas. | bancos de dados/esquemas do MySQL | Um banco de dados MySQL pode atender a vários serviços e aplicativos, bem como muitos usuários de banco de dados. |
sequências de sessão | Com o Oracle 12c, é possível criar sequências no nível da sessão (retornam valores exclusivos somente dentro de uma sessão) ou no nível global (por exemplo, ao usar tabelas temporárias). | incremento automático |
As sequências não são compatíveis com o MySQL, mas os usuários podem usar a propriedade de coluna AUTO_INCREMENT como solução alternativa. |
colunas de identidade | O tipo IDENTITY do Oracle 12c gera uma sequência e a associa a uma coluna de tabela sem a necessidade de criar manualmente um outro objeto de sequência. |
incremento automático | Use a propriedade de coluna AUTO_INCREMENT para simular a mesma funcionalidade da coluna de identidade do Oracle 12c, uma solução alternativa à funcionalidade de geração automática de sequências. |
fragmentação | A fragmentação do Oracle é uma solução em que um banco de dados Oracle é particionado em vários bancos de dados menores (fragmentos) para permitir escalonabilidade, disponibilidade e distribuição geográfica para ambientes OLTP. | incompatível (como recurso) | O MySQL não tem um recurso de fragmentação equivalente. A fragmentação pode ser implementada usando o MySQL (como plataforma de dados) com uma camada de aplicativo de suporte. |
banco de dados na memória | O Oracle fornece um pacote de recursos capazes de melhorar o desempenho do banco de dados para OLTP, bem como cargas de trabalho mistas. | incompatível | O MySQL não tem um recurso equivalente. Como alternativa, é possível usar o Memorystore. |
edição | Como parte dos recursos avançados de segurança do Oracle, a edição pode mascarar colunas para impedir a exibição de dados confidenciais por usuários e aplicativos. | incompatível | O MySQL não tem um recurso equivalente. |
Funcionalidade
Os bancos de dados Oracle 11g/12c e Cloud SQL para MySQL funcionam em diferentes arquiteturas (infraestrutura e linguagens de procedimentos estendidas), porém, têm os mesmos aspectos fundamentais de um banco de dados relacional. Eles são compatíveis com objetos de banco de dados, cargas de trabalho com simultaneidade de vários usuários e transações (compatibilidade com ACID). Eles também gerenciam contenções de bloqueio compatíveis com vários níveis de isolamento (com base nas necessidades de negócios) e atendem aos requisitos de aplicativos contínuos, como um armazenamento de dados relacional para operações de processamento transacional on-line (OLTP, na sigla em inglês) e processamento analítico on-line (OLAP, na sigla em inglês).
Na seção a seguir, fornecemos uma visão geral de algumas das principais diferenças funcionais entre o Oracle e o Cloud SQL para MySQL. Em alguns casos, quando necessário, incluímos comparações técnicas detalhadas.
Como criar e visualizar bancos de dados atuais
Oracle 11g/12c | Cloud SQL para MySQL 5.7 |
---|---|
Geralmente, você cria bancos de dados e visualiza os atuais usando o utilitário Database Creation Assistant (DBCA) do Oracle. Bancos de dados ou instâncias criados manualmente exigem que você especifique mais parâmetros:SQL> CREATE DATABASE ORADB USER SYS IDENTIFIED BY password USER SYSTEM IDENTIFIED BY password EXTENT MANAGEMENT LOCAL DEFAULT TEMPORARY TABLESPACE temp UNDO TABLESPACE undotbs1 DEFAULT TABLESPACE users; |
Use uma instrução no formato CREATE DATABASE Name; , como neste exemplo:
mysql> CREATE DATABASE MYSQLDB; |
Oracle 12c | Cloud SQL para MySQL 5.7 |
No Oracle 12c, é possível criar PDBs da semente, de um modelo de banco de dados de contêiner (CDB) ou clonando um PDB de um PDB atual. Você usa vários parâmetros:SQL> CREATE PLUGGABLE DATABASE PDB ADMIN USER usr IDENTIFIED BY passwd ROLES = (dba) DEFAULT TABLESPACE sales DATAFILE '/disk1/ora/dbs/db/db.dbf' SIZE 250M AUTOEXTEND ON FILE_NAME_CONVERT = ('/disk1/oracle/dbs/pdbseed/', '/disk1/oracle/dbs/salespdb/') STORAGE (MAXSIZE 2G) PATH_PREFIX = '/disk1/oracle/dbs/salespdb/'; |
Use uma instrução no formato CREATE DATABASE Name; , como neste exemplo:mysql> CREATE DATABASE MYSQLDB; |
Listar todos os PDBs:SQL> SHOW is PDBS; |
Listar todos os bancos de dados atuais:mysql> SHOW DATABASES; |
Conectar-se a um PDB diferente:SQL> ALTER SESSION SET CONTAINER=pdb; |
Conectar-se a um banco de dados diferente:mysql> use databaseName; mysql> \u databaseName; |
Abrir ou fechar um PDB específico (aberto/somente leitura):SQL> ALTER PLUGGABLE DATABASE pdb CLOSE; |
Incompatível com um único banco de dados. Todos os bancos de dados estão na mesma instância do Cloud SQL para MySQL, portanto, todos os bancos de dados estão ativos ou inativos. |
Como gerenciar um banco de dados pelo Console do Cloud SQL
No console do Google Cloud, acesse Armazenamento > SQL > Instância > Bancos de dados > Ver/criar.
Bancos de dados e esquemas do sistema
As instâncias do banco de dados Oracle recebem determinados esquemas do sistema (por exemplo, SYS/SYSTEM
) com o papel de proprietários de objetos de metadados do banco de dados.
Por outro lado, o MySQL contém vários bancos de dados do sistema (ao contrário dos esquemas do Oracle), que atendem à camada de metadados (observe que os nomes de bancos de dados diferenciam maiúsculas de minúsculas):
-
O banco de dados do sistema
mysql
contém tabelas que armazenam informações exigidas pelo servidor MySQL durante a execução, como as seguintes:- tabelas de privilégios do sistema
- tabelas de informações de objetos
- tabelas do sistema de registro
- tabelas do sistema de replicação
- tabelas do sistema do otimizador
- tabelas do sistema de fuso horário
-
INFORMATION_SCHEMA
funciona como catálogo do sistema e dicionário de dados do banco de dados principal. Ele fornece acesso aos metadados do banco de dados, que são informações internas do banco de dados sobre o servidor MySQL, como o nome de um banco de dados ou tabela, o tipo de dados da coluna e os privilégios de acesso. -
Um banco de dados do sistema que coleta informações estatísticas sobre a instância do MySQL. O banco de dados do sistema
performance_schema
contém métricas para monitorar a execução do servidor em um nível muito granular. O esquema oferece inspeção de execução interna do servidor no momento da execução, podendo funcionar como a principal origem para analisar problemas de desempenho do banco de dados.O
performance_schema
não é ativado por padrão como o uso do Cloud SQL para MySQL. Para ativar o esquema, use a ferramenta de linha de comandogcloud
:gcloud sql instances patch INSTANCE_NAME --database-flags performance_schema=on
Para concluir esta configuração, é necessário reinicializar a instância. Não é possível modificar o parâmetro
--database-flags
usando a página de sinalizações de banco de dados do Cloud SQL para MySQL no console do Google Cloud. -
O esquema
sys
existe no MySQL desde a versão 5.5.7 e contém principalmente visualizações das tabelas do sistemaperformance_schema
. Esse esquema oferece um conjunto de visualizações mais legível que resume os dados doperformance_schema
em um formato compreensível. O esquemasys
também contém vários procedimentos e funções armazenados para executar operações como a configuração deperformance_schema
e a geração de relatórios de diagnóstico.O esquema
sys
exibe informações somente quandoperformance_schema
está ativado.
Como visualizar metadados e visualizações dinâmicas do sistema
Nesta seção, fornecemos uma visão geral de algumas das tabelas de metadados e visualizações dinâmicas mais comuns do sistema que são usadas no Oracle e nos objetos de banco de dados correspondentes no Cloud SQL para MySQL versão 5.7.
O Oracle fornece centenas de visualizações e tabelas de metadados do sistema, enquanto o MySQL contém apenas algumas dezenas. Para cada caso, pode haver mais de um objeto de banco de dados, atendendo a uma finalidade específica.
O Oracle oferece vários níveis de objetos de metadados, cada um exigindo privilégios diferentes:
USER_TableName
: pode ser visualizado pelo usuário.ALL_TableName
: pode ser visualizado por todos os usuários.DBA_TableName
: pode ser visualizado apenas por usuários com o privilégio DBA, comoSYS
eSYSTEM
.
Para visualizações de desempenho dinâmico, o Oracle usa os prefixos V$
e GV$
. Para que um usuário do MySQL possa visualizar tabelas ou visualizações de metadados do sistema, ele precisa ter permissões específicas sobre os objetos do sistema. Para mais informações sobre segurança, consulte a seção Segurança.
Tipo de metadados | Tabela/visualização do Oracle | Tabela/visualização/exibição do MySQL (CMD do MySQL) |
---|---|---|
sessões abertas | V$SESSION |
SHOW PROCESSLIST INFORMATION_SCHEMA.PROCESSLIST performance_schema.threads |
transações em execução | V$TRANSACTION |
INFORMATION_SCHEMA.INNODB_TRX |
objetos de banco de dados | DBA_OBJECTS |
Incompatível. Consulte cada objeto pelo tipo. |
tabelas | DBA_TABLES |
INFORMATION_SCHEMA.TABLES INFORMATION_SCHEMA.INNODB_SYS_TABLES |
colunas de tabela | DBA_TAB_COLUMNS |
INFORMATION_SCHEMA.COLUMNS INFORMATION_SCHEMA.INNODB_SYS_COLUMNS |
privilégios de tabela e coluna | TABLE_PRIVILEGES DBA_COL_PRIVS ROLE_TAB_PRIVS |
INFORMATION_SCHEMA.COLUMN_PRIVILEGES |
partições | DBA_TAB_PARTITIONS DBA_TAB_SUBPARTITIONS |
INFORMATION_SCHEMA.PARTITIONS SHOW CREATE TABLE TableName SHOW TABLE STATUS LIKE 'TableName' |
visualizações | DBA_VIEWS |
INFORMATION_SCHEMA.VIEWS |
restrições | DBA_CONSTRAINTS |
INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS SHOW CREATE TABLE TableName |
índices | DBA_INDEXES DBA_PART_INDEXES |
INFORMATION_SCHEMA.STATISTICS INFORMATION_SCHEMA.INNODB_SYS_INDEXES INFORMATION_SCHEMA.KEY_COLUMN_USAGE |
visualizações materializadas | DBA_MVIEWS |
incompatível |
procedimentos armazenados | DBA_PROCEDURES |
INFORMATION_SCHEMA.ROUTINES |
funções armazenadas | DBA_PROCEDURES |
INFORMATION_SCHEMA.ROUTINES |
gatilhos | DBA_TRIGGERS |
INFORMATION_SCHEMA.TRIGGERS |
usuários | DBA_USERS |
mysql.user |
privilégios de usuário | DBA_SYS_PRIVS DBA_ROLE_PRIVS SESSION_PRIVS |
INFORMATION_SCHEMA.USER_PRIVILEGES |
jobs/ programador |
DBA_JOBS DBA_JOBS_RUNNING DBA_SCHEDULER_JOBS DBA_SCHEDULER_JOB_LOG |
INFORMATION_SCHEMA.EVENTS |
tablespaces | DBA_TABLESPACES |
INFORMATION_SCHEMA.INNODB_SYS_TABLESPACES |
arquivos de dados | DBA_DATA_FILES |
INFORMATION_SCHEMA.FILES INFORMATION_SCHEMA.INNODB_SYS_DATAFILES |
sinônimos | DBA_SYNONYMS |
Incompatível |
sequências | DBA_SEQUENCES |
incompatível |
links de banco de dados | DBA_DB_LINKS |
incompatível |
estatísticas | DBA_TAB_STATISTICS DBA_TAB_COL_STATISTICS DBA_SQLTUNE_STATISTICS DBA_CPU_USAGE_STATISTICS |
INFORMATION_SCHEMA.STATISTICS INFORMATION_SCHEMA.KEY_COLUMN_USAGE SHOW INDEXES FROM TableName |
bloqueios | DBA_LOCK DBA_DDL_LOCKS DBA_DML_LOCKS V$SESSION_BLOCKERS V$LOCKED_OBJECT |
INFORMATION_SCHEMA.INNODB_LOCKS INFORMATION_SCHEMA.INNODB_LOCK_WAITS INFORMATION_SCHEMA.INNODB_TRX performance_schema.metadata_locks performance_schema.rwlock_instances SHOW PROCESSLIST |
parâmetros de banco de dados | V$PARAMETER V$NLS_PARAMETERS SHOW PARAMETER Param |
performance_schema.global_variables performance_schema.session_variables INFORMATION_SCHEMA.CHARACTER_SETS SHOW VARIABLES LIKE '%variable%'; |
segmentos | DBA_SEGMENTS |
A tabela de segmentos é incompatível. Consulte cada objeto pelo tipo. |
papéis | DBA_ROLES DBA_ROLE_PRIVS USER_ROLE_PRIVS |
Roles not supported use instead: information_schema.COLUMN_PRIVILEGES information_schema.SCHEMA_PRIVILEGES information_schema.TABLE_PRIVILEGES information_schema.USER_PRIVILEGES mysql.columns_priv mysql.procs_priv mysql.proxies_priv mysql.tables_priv |
histórico da sessão | V$ACTIVE_SESSION_HISTORY DBA_HIST_* |
sys.statement_analysis performance_schema.events_stages_history performance_schema.events_stages_history_long performance_schema.events_statements_history performance_schema.events_statements_history_long performance_schema.events_transactions_history performance_schema.events_transactions_history_long performance_schema.events_waits_history performance_schema.events_waits_history_long |
versão | V$VERSION |
sys.version SHOW VARIABLES LIKE '%version%'; |
eventos de espera | V$WAITCLASSMETRIC V$WAITCLASSMETRIC_HISTORY V$WAITSTAT V$WAIT_CHAINS |
performance_schema.events_waits_current performance_schema.events_waits_history performance_schema.events_waits_history_long sys.innodb_lock_waits sys.io_global_by_wait_by_bytes sys.io_global_by_wait_by_latency sys.schema_table_lock_waits sys.wait_classes_global_by_avg_latency sys.wait_classes_global_by_latency sys.waits_by_host_by_latency sys.waits_by_user_by_latency sys.waits_global_by_latency |
ajuste e análise SQL |
V$SQL V$SQLAREA V$SESS_IO V$SYSSTAT V$STATNAME V$OSSTAT V$ACTIVE_SESSION_HISTORY V$SESSION_WAIT V$SESSION_WAIT_CLASS V$SYSTEM_WAIT_CLASS V$LATCH V$SYS_OPTIMIZER_ENV V$SQL_PLAN V$SQL_PLAN_STATISTICS |
performance_schema.events_statements_current performance_schema.events_statements_history performance_schema.events_statements_history_long sys.statement_analysis sys.host_summary_by_statement_latency sys.host_summary_by_statement_type sys.statements_with_errors_or_warnings sys.statements_with_full_table_scans sys.statements_with_runtimes_in_95th_percentile sys.statements_with_sorting sys.statements_with_temp_tables sys.user_summary_by_statement_latency sys.user_summary_by_statement_type slow-query-log general-log SHOW STATUS LIKE '%StatusName%'; |
ajuste de memória da instância |
V$SGA V$SGASTAT V$SGAINFO V$SGA_CURRENT_RESIZE_OPS V$SGA_RESIZE_OPS V$SGA_DYNAMIC_COMPONENTS V$SGA_DYNAMIC_FREE_MEMORY V$PGASTAT |
information_schema.INNODB_CMPMEM_RESET information_schema.INNODB_CMPMEM performance_schema.memory_summary_by_account_by_event_name performance_schema.memory_summary_by_host_by_event_name performance_schema.memory_summary_by_thread_by_event_name performance_schema.memory_summary_by_user_by_event_name performance_schema.memory_summary_global_by_event_name performance_schema.replication_group_member_stats performance_schema.replication_group_members sys.memory_by_host_by_current_bytes sys.memory_by_thread_by_current_bytes sys.memory_by_user_by_current_bytes sys.memory_global_by_current_bytes sys.memory_global_total |
Mecanismos de armazenamento do MySQL
Ao contrário de muitos outros RDBMS (incluindo o Oracle), o MySQL pode funcionar polimorficamente, graças ao sistema de armazenamento plugável. A arquitetura do mecanismo de armazenamento plugável do MySQL permite que um administrador de banco de dados selecione um mecanismo de armazenamento especializado para uma necessidade de aplicativo específica.
O componente do mecanismo de armazenamento conectável do MySQL no servidor de banco de dados MySQL é responsável por realizar as operações de E/S de dados, incluindo o armazenamento de dados nos discos ou buffers de memória. A arquitetura do mecanismo de armazenamento plugável oferece um conjunto padrão de serviços de gerenciamento e suporte comuns a todos os mecanismos de armazenamento subjacentes.
No MySQL versão 5.5 e posterior, o mecanismo de armazenamento padrão é o mecanismo de armazenamento InnoDB, enquanto o InnoDB também processa as tabelas temporárias. É possível configurar mecanismos de armazenamento durante a tabela CREATE
ou ALTER
, como no exemplo a seguir:
mysql> SHOW CREATE TABLE JOBS \G;
A saída é esta:
*************************** 1. row *************************** Table: JOBS Create Table: CREATE TABLE `JOBS` ( `JOB_ID` varchar(10) NOT NULL, `JOB_TITLE` varchar(35) NOT NULL, `MIN_SALARY` decimal(6,0) DEFAULT NULL, `MAX_SALARY` decimal(6,0) DEFAULT NULL, PRIMARY KEY (`JOB_ID`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8
Para mais informações, consulte diferentes mecanismos de armazenamento (em inglês) do MySQL.
Veja a configuração do mecanismo de armazenamento usando a consulta a seguir:
mysql> SHOW VARIABLES LIKE '%storage%';
A saída será semelhante a esta:
+----------------------------------+--------+ | Variable_name | Value | +----------------------------------+--------+ | default_storage_engine | InnoDB | | default_tmp_storage_engine | InnoDB | | disabled_storage_engines | | | enforce_storage_engine | Innodb | | internal_tmp_disk_storage_engine | InnoDB | +----------------------------------+--------+
Veja todos os mecanismos de armazenamento integrados:
mysql> SHOW STORAGE ENGINES;
A resposta será semelhante a:
+--------------------+---------+----------------------------------------------------------------+--------------+------+------------+ | Engine | Support | Comment | Transactions | XA | Savepoints | +--------------------+---------+----------------------------------------------------------------+--------------+------+------------+ | CSV | YES | CSV storage engine | NO | NO | NO | | PERFORMANCE_SCHEMA | YES | Performance Schema | NO | NO | NO | | MRG_MYISAM | YES | Collection of identical MyISAM tables | NO | NO | NO | | BLACKHOLE | YES | /dev/null storage engine (anything you write to it disappears) | NO | NO | NO | | MyISAM | YES | MyISAM storage engine | NO | NO | NO | | FEDERATED | NO | Federated MySQL storage engine | NULL | NULL | NULL | | MEMORY | YES | Hash based, stored in memory, useful for temporary tables | NO | NO | NO | | InnoDB | DEFAULT | Supports transactions, row-level locking, and foreign keys | YES | YES | YES | +--------------------+---------+----------------------------------------------------------------+--------------+------+------------+
O InnoDB é o mecanismo de armazenamento padrão, sendo o único que aceita transações (conformidade com ACID). Como o InnoDB é o único mecanismo de armazenamento que se aproxima da funcionalidade do Oracle, recomendamos que você o use em todos os momentos. O Cloud SQL para MySQL segunda geração é compatível apenas com o mecanismo de armazenamento InnoDB.
Parâmetros do sistema
Os bancos de dados Oracle e Cloud SQL para MySQL podem ser configurados especificamente para alcançar determinadas funcionalidades além da configuração padrão. Para alterar os parâmetros de configuração no Oracle, algumas permissões de administração são necessárias (principalmente as permissões do usuário SYS/SYSTEM
).
A seguir, veja um exemplo de alteração da configuração do Oracle usando a instrução ALTER SYSTEM
. Nele, o usuário altera o parâmetro "máximo de tentativas para logins com falha" somente no nível da configuração spfile
(modificação válida somente após uma reinicialização):
SQL> ALTER SYSTEM SET SEC_MAX_FAILED_LOGIN_ATTEMPTS=2 SCOPE=spfile;
No próximo exemplo, o usuário apenas solicita visualizar o valor do parâmetro do Oracle:
SQL> SHOW PARAMETER SEC_MAX_FAILED_LOGIN_ATTEMPTS;
A saída será semelhante a esta:
NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ sec_max_failed_login_attempts integer 2
A modificação do parâmetro do Oracle funciona em três escopos:
- SPFILE: as modificações de parâmetro são gravadas no
spfile
do Oracle. Requer uma reinicialização da instância para entrar em vigor. - MEMORY: as modificações de parâmetro são aplicadas à camada de memória somente enquanto nenhuma alteração de parâmetro estático é permitida.
- AMBOS: as modificações de parâmetro são aplicadas ao arquivo de parâmetros do servidor e à memória da instância, em que nenhuma alteração de parâmetro estático é permitida.
Sinalizações de configuração do Cloud SQL para MySQL
É possível modificar os parâmetros de sistema do Cloud SQL para MySQL usando as sinalizações de configuração no console do Google Cloud, na CLI gcloud ou no CURL. Consulte a lista completa de todos os parâmetros compatíveis com o Cloud SQL para MySQL que podem ser alterados.
Os parâmetros do MySQL podem ser divididos em vários escopos:
- Parâmetros dinâmicos: podem ser alterados no momento da execução.
- Parâmetros estáticos: exigem uma reinicialização da instância para entrar em vigor.
- Parâmetros globais: terão efeito global em todas as sessões atuais e futuras.
- Parâmetros de sessão: podem ser alterados no nível da sessão apenas durante a vida útil da sessão atual, isolada de outras sessões.
O parâmetro de memória do Cloud SQL para MySQL innodb_buffer_pool_size
(um dos parâmetros essenciais a considerar ao planejar e dimensionar um ambiente MySQL) é determinado pelo tipo de instância e não pode ser alterado com as sinalizações de configuração ou por qualquer outro método, por exemplo:
- O tipo de instância
db-n1-standard-1
tem 1,4 GB de alocação de memória. - O tipo de instância
db-n1-highmem-8
tem 38 GB de alocação de memória.
Exemplos de alteração de parâmetros do Cloud SQL para MySQL
Console
Use o console do Google Cloud para ativar o parâmetro event_scheduler
.
Acesse a página Editar instância do Cloud Storage.
Em Sinalizações, clique em Adicionar item e procure
event_scheduler
, como na captura de tela a seguir.
gcloud
Use a CLI gcloud para ativar o parâmetro
event_scheduler
:gcloud sql instances patch INSTANCE_NAME \ --database-flags event_scheduler=on
A saída é esta:
WARNING: This patch modifies database flag values, which may require your instance to be restarted. Check the list of supported flags - /sql/docs/mysql/flags - to see if your instance will be restarted when this patch is submitted. Do you want to continue (Y/n)?
Sessão do MySQL
Desative o modo AUTOCOMMIT
no nível da sessão. Essa alteração é válida para a sessão atual e só permanece em vigor durante a vida útil dela.
Mostre variáveis como
autocommit
:mysql> SHOW VARIABLES LIKE '%autoc%';
Aparecerá esta saída, em que
autocommit
éON
:+---------------+-------+ | Variable_name | Value | +---------------+-------+ | autocommit | ON | +---------------+-------+
Desative
autocommit
:mysql> SET autocommit=off;
Mostre variáveis como
autocommit
:mysql> SHOW VARIABLES LIKE '%autoc%';
Aparecerá esta saída, em que
autocommit
éOFF
:+---------------+-------+ | Variable_name | Value | +---------------+-------+ | autocommit | OFF | +---------------+-------+
Transações e níveis de isolamento
Nesta seção, descrevemos as principais diferenças entre o Oracle e o Cloud SQL para MySQL em relação a migrações em nível de isolamento e transação.
Modo de confirmação
Por padrão, o Oracle funciona no modo sem confirmação automática, em que é preciso determinar cada transação DML com instruções COMMIT/ROLLBACK
. Uma das diferenças fundamentais entre o Oracle e o MySQL é que o MySQL funciona, por padrão, no modo de confirmação automática, e cada transação DML é confirmada automaticamente com a especificação explícita de instruções COMMIT/ROLLBACK
.
Para forçar o MySQL a funcionar em um modo sem confirmação automática, há várias opções:
- Ao gerenciar transações dentro do escopo dos procedimentos armazenados, use a cláusula
START TRANSACTION
para entrar no mesmo modo transacional que o Oracle. Use a instrução a seguir para definir o parâmetro de sistema
autocommit
comoOFF
no nível da sessão e use as instruçõesCOMMIT/ROLLBACK
explicitamente em transações DML:mysql> SET autocommit=off;
Níveis de isolamento
O padrão ANSI/ISO SQL (SQL92) define quatro níveis de isolamento. Cada nível fornece uma abordagem diferente para manipular a execução simultânea de transações de banco de dados:
- Leitura não confirmada: uma transação processada atualmente pode ver dados não confirmados gerados pela outra transação. Se uma reversão for realizada, todos os dados serão restaurados ao estado anterior.
- Leitura confirmada: uma transação só vê alterações de dados que foram confirmadas. Alterações não confirmadas ("leituras sujas") não são possíveis.
- Leitura repetível: uma transação só pode ver as alterações feitas pela outra transação depois que ambas emitirem um
COMMIT
ou ambas forem revertidas. - Serializável: o nível de isolamento mais rigoroso/forte. Esse nível bloqueia todos os registros acessados e bloqueia o recurso para impedir que os registros sejam anexados à tabela.
Os níveis de isolamento de transação gerenciam a visibilidade dos dados alterados, como ocorre para outras transações em execução. Além disso, quando os mesmos dados são acessados por várias transações simultâneas, o nível selecionado de isolamento de transação afeta a interação de diferentes transações.
O Oracle é compatível com os níveis de isolamento a seguir:
- leitura confirmada (padrão);
- serializável;
- somente leitura (não faz parte do padrão ANSI/ISO SQL - SQL92).
Controle de simultaneidade de várias versões (MVCC, na sigla em inglês) do Oracle:
- O Oracle usa o mecanismo MVCC para fornecer consistência de leitura automática em todo o banco de dados e em todas as sessões.
- O Oracle depende do número de alteração do sistema (SCN, na sigla em inglês) da transação atual para ter uma visualização consistente do banco de dados. Portanto, todas as consultas de banco de dados só retornam dados confirmados em relação ao SCN no momento da execução.
- Os níveis de isolamento podem ser alterados nos níveis de transação e sessão.
Veja um exemplo de definição de níveis de isolamento:
-- Transaction Level
SQL> SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
SQL> SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
SQL> SET TRANSACTION READ ONLY;
-- Session Level
SQL> ALTER SESSION SET ISOLATION_LEVEL = SERIALIZABLE;
SQL> ALTER SESSION SET ISOLATION_LEVEL = READ COMMITTED;
Assim como o Oracle, o Cloud SQL para MySQL é compatível com os quatro níveis de isolamento de transação especificados no padrão ANSI SQL:92:
READ UNCOMMITTED
READ COMMITTED
REPEATABLE READ (default)
SERIALIZABLE
O nível de isolamento padrão do Cloud SQL para MySQL é REPEATABLE READ
. Os novos dados estarão disponíveis para as duas transações somente depois que ambas emitirem um comando COMMIT
. Esses níveis de isolamento podem ser alterados no nível SESSION
e no nível GLOBAL
. A modificação em nível global está atualmente em fase Beta usando sinalizações de configuração.
Para verificar os níveis de isolamento atuais nos níveis SESSION
e GLOBAL
, use a instrução a seguir:
mysql> SELECT @@GLOBAL.tx_isolation, @@tx_isolation;
A saída é esta:
+-----------------------+-----------------+ | @@GLOBAL.tx_isolation | @@tx_isolation | +-----------------------+-----------------+ | REPEATABLE-READ | REPEATABLE-READ | +-----------------------+-----------------+
É possível modificar a sintaxe do nível de isolamento da seguinte maneira:
SET [SESSION] TRANSACTION ISOLATION LEVEL [READ WRITE | READ ONLY]
| REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED | SERIALIZABLE]
Também é possível modificar o nível de isolamento no nível SESSION
:
mysql> SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-- Verify
mysql> SELECT @@GLOBAL.tx_isolation, @@tx_isolation;
A saída é esta:
+-----------------------+------------------+ | @@GLOBAL.tx_isolation | @@tx_isolation | +-----------------------+------------------+ | REPEATABLE-READ | READ-UNCOMMITTED | +-----------------------+------------------+
Estrutura de transações do Cloud SQL para MySQL
Sintaxe de transações (em inglês):
START TRANSACTION [transaction_characteristic [, transaction_characteristic] ...] |
---|
É possível implementar as transações com START TRANSACTION
ou BEGIN
.
A opção WITH CONSISTENT SNAPSHOT
inicia uma transação READ
consistente, que é efetivamente igual à emissão de um START TRANSACTION
, seguido por um SELECT
de qualquer tabela. A cláusula WITH CONSISTENT SNAPSHOT
que inicia um READ
consistente (uma operação READ
que usa informações de snapshot para apresentar resultados de consulta com base em um momento específico) não altera o nível de isolamento de transações e só é compatível com o nível de isolamento REPEATABLE READ
.
Um READ
consistente usa informações de snapshot para disponibilizar os resultados da consulta com base em um momento específico, independentemente das modificações realizadas por transações simultâneas. Se os dados consultados tiverem sido alterados por outra transação, os dados originais serão reconstruídos com o registro undo. Isso ajudará a evitar problemas de bloqueio que reduzam a simultaneidade.
Com o nível de isolamento REPEATABLE READ
, o snapshot é baseado no horário da execução da primeira operação READ
. Com o nível de isolamento READ COMMITTED
, o snapshot é redefinido para o horário de cada operação READ
consistente.
Veja um exemplo de definição de nível de transação e isolamento:
mysql> SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
mysql> START TRANSACTION;
mysql> INSERT INTO tbl1 VALUES (1, 'A');
mysql> UPDATE tbl2 SET col1 = 'Done' WHERE KeyColumn = 1;
mysql> COMMIT;