Como migrar usuários do Oracle para o Cloud SQL para MySQL: consultas, procedimentos armazenados, funções e gatilhos

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
• 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 (este documento)
• Como migrar usuários da Oracle para o Cloud SQL para MySQL: segurança, operações, monitoramento e geração de registros

Consultas

O Oracle e o Cloud SQL para MySQL são compatíveis com o padrão ANSI SQL. Geralmente, é simples migrar instruções SQL usando apenas elementos de sintaxe básicos (por exemplo, não especificando funções escalares ou qualquer outro recurso estendido do Oracle). Na seção a seguir, discutimos elementos comuns de consulta do Oracle e os equivalentes correspondentes do Cloud SQL para MySQL.

Sintaxe básica de SELECT e FROM

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

SELECT 1 FROM DUAL

SELECT 1
OR
SELECT 1 FROM DUAL

SELECT COL1 AS C1

SELECT COL1 AS C1
OR
SELECT COL1 C1

Leia mais detalhes sobre a sintaxe SELECT do MySQL.

• Visualizações in-line
  • As visualizações in-line (também conhecidas como tabelas derivadas) são instruções SELECT, localizadas na cláusula FROM e usadas como uma subconsulta.
  • As visualizações in-line podem ajudar a simplificar consultas complexas, removendo cálculos compostos ou eliminando operações de junção, ao mesmo tempo em que compilam várias consultas separadas em uma única consulta simplificada.
  • Observação de conversão: as visualizações in-line do Oracle não exigem o uso de aliases, enquanto o MySQL exige aliases específicos para cada visualização in-line.

A tabela a seguir apresenta um exemplo de conversão do Oracle para MySQL, como uma visualização in-line.

SQL> SELECT FIRST_NAME,
            DEPARTMENT_ID,
            SALARY,
            DATE_COL
     FROM EMPLOYEES,
          (SELECT SYSDATE AS DATE_COL FROM DUAL);

FIRST_NAME           DEPARTMENT_ID     SALARY DATE_COL
-------------------- ------------- ---------- ---------
Steven                          90      24000 30-JUL-19
Neena                           90      17000 30-JUL-19
Lex                             90      17000 30-JUL-19

mysql> SELECT FIRST_NAME,
              DEPARTMENT_ID,
              SALARY,
              DATE_COL
       FROM EMPLOYEES, (SELECT SYSDATE() AS DATE_COL FROM DUAL);


ERROR 1248 (42000): Every derived table must have its own alias

mysql> SELECT FIRST_NAME,
              DEPARTMENT_ID,
              SALARY,
              DATE_COL
       FROM EMPLOYEES, (SELECT SYSDATE() AS DATE_COL FROM DUAL) AS A1;

+-------------+---------------+----------+---------------------+
| FIRST_NAME  | DEPARTMENT_ID | SALARY   | DATE_COL            |
+-------------+---------------+----------+---------------------+
| Steven      |            90 | 23996.00 | 2019-07-30 09:28:00 |
| Neena       |            90 | 22627.00 | 2019-07-30 09:28:00 |
| Lex         |            90 | 22627.00 | 2019-07-30 09:28:00 |

Instruções JOIN

As instruções JOIN do Oracle são compatíveis com as instruções JOIN do MySQL, exceto a cláusula FULL JOIN. Além disso, as instruções JOIN do MySQL aceitam o uso de sintaxe alternativa, como a cláusula USING, a cláusula WHERE em vez da cláusula ON e o uso de SUBQUERY na instrução JOIN.

Na tabela a seguir, veja um exemplo de conversão JOIN.

INNER JOIN

SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

CROSS JOIN

SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E CROSS JOIN DEPARTMENTS D

FULL JOIN

LEFT JOIN
[ OUTER ]

SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E LEFT JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

RIGHT JOIN
[ OUTER ]

SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E RIGHT JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

SUBQUERY

SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E JOIN (SELECT * FROM DEPARTMENTS)D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

UNION, UNION ALL, INTERSECT e MINUS

O MySQL não é compatível com as funções INTERSECT e MINUS do Oracle, exceto as funções UNION e UNION ALL:

• UNION: anexa os conjuntos de resultados de duas ou mais instruções SELECT e elimina registros duplicados.
• UNION ALL: anexa os conjuntos de resultados de duas ou mais instruções SELECT sem eliminar registros duplicados.
• INTERSECT: retorna a interseção de duas ou mais instruções SELECT somente se houver um registro nos dois conjuntos de dados.
• MINUS: compara duas ou mais instruções SELECT, retornando apenas linhas distintas da primeira consulta que não são retornadas pelas outras instruções.

Observações sobre a conversão

Ao converter as funções INTERSECT e MINUS do Oracle em MySQL, use as instruções JOIN e IN e EXISTS como uma solução alternativa.

Exemplos

UNION

SELECT COL1 FROM TBL1
UNION
SELECT COL1 FROM TBL2

SELECT COL1 FROM TBL1
UNION
SELECT COL1 FROM TBL2

UNION ALL

SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2

SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2

INTERSECT

SELECT COL1 FROM TBL1
INTERSECT
SELECT COL1 FROM TBL2

SELECT COL1 FROM TBL1
WHERE COL1 IN
(SELECT COL1 FROM TBL2)

MINUS

SELECT COL1 FROM TBL1
MINUS
SELECT COL1 FROM TBL2

SELECT A.COL1
FROM TBL1 A LEFT JOIN TBL2 B
ON USING(COL1)
WHERE B.COL1 IS NULL

Funções escalares (de linha única) e de grupo

O MySQL fornece uma extensa lista de funções escalares (de linha única) e de agregação. Algumas das funções do MySQL são semelhantes às versões equivalentes do Oracle (por nome e funcionalidade ou com um nome diferente, mas com funcionalidade semelhante). Ainda que as funções do MySQL possam ter nomes idênticos aos equivalentes do Oracle, elas podem exibir funcionalidades diferentes.

As tabelas a seguir descrevem onde o Oracle e o MySQL são equivalentes por nome e funcionalidade (especificados por "Sim") e onde uma conversão é recomendada (todos os casos, exceto "Sim").

Funções de caracteres

CONCAT(str1,str2)

CONCAT('A', 1) = A1

CONCAT

CONCAT('A', 1) = A1

LOWER/UPPER

LOWER('SQL') = sql

LOWER/UPPER

LOWER('SQL') = sql

LPAD/RPAD(expr1,n,expr2)

LPAD('A',3,'*') = **A

LPAD/RPAD

LPAD('A',3,'*') = **A

SUBSTR(char,p,n)

SUBSTR('MySQL', 3, 3)
= SQL

SUBSTR(char,p,n)

SUBSTR('MySQL', 3, 3)
= SQL

INSTR(index,str)

INSTR('MySQL', 'y')
= 2

INSTR

INSTR('MySQL', 'y')
= 2

REPLACE(char,str1,str2)

REPLACE('ORADB', 'ORA', 'MySQL')


= MySQLDB

REPLACE(char,str1,str2)

REPLACE('ORADB', 'ORA', 'MySQL')


= MySQLDB

TRIM(str)

TRIM(both '-' FROM '-MySQL-')
= MySQL


TRIM('  MySQL ')
= MySQL

TRIM(str)

TRIM(both '-' FROM '-MySQL-')
= MySQL


TRIM('  MySQL ')
= MySQL

LTRIM/RTRIM(str)

LTRIM('   MySQL', ' ')
= MySQL

LTRIM/RTRIM(str)

LTRIM('   MySQL')
= MySQL

ASCII(char)

ASCII('A') = 65

ASCII(char)

ASCII('A') = 65

CHR(char)

CHR(65) = A

CHAR(char)

CHAR(65) = A

LENGTH(str)

LENGTH ('MySQL') = 5

LENGTH(str)

LENGTH('MySQL') = 5

REGEXP_REPLACE(str1,expr,str2)

REGEXP_REPLACE('John', '[hn].', '1') = Jo1

REGEXP_SUBSTR(str,expr)

REGEXP_SUBSTR('https://console.cloud.google.com/sql/instances','https://([[:alnum:]]+\.?){3,4}/?')
= https://console.cloud.google.com/

REGEXP_COUNT(str,expr)

REGEXP_INSTR(index,expr)

REVERSE(str)

REVERSE('MySQL')
= LQSyM

REVERSE

REVERSE('MySQL')
= LQSyM

Funções numéricas

ABS(n)

ABS(-4.6) = 4.6

ABS

ABS(-4.6) = 4.6

CEIL(n)

CEIL(21.4) = 22

CEIL

CEIL(21.4) = 22

FLOOR(n)

FLOOR(-23.7) = -24

FLOOR

FLOOR(-23.7) = -24

MOD(m,n)

MOD(10, 3) = 1

MOD(m,n)

MOD(10,3) = 1

ROUND(m,n)

ROUND(1.39,1) = 1.4

ROUND

ROUND(1.39,1) = 1.4

TRUNC(n1, n2)

TRUNC(99.999) = 99
TRUNC(99.999,0) = 99

TRUNCATE(n1, n2)

TRUNCATE(99.999,0) = 99

Funções de data e hora

SYSDATE

SELECT SYSDATE
FROM DUAL
= 31-JUL-2019

SYSDATE()

SELECT SYSDATE()
FROM DUAL;
= 2019-01-31 10:01:01.0

SYSTIMESTAMP

SELECT SYSTIMESTAMP FROM DUAL
= 01-JAN-19 07.37.11.622187000 AM +00:00

CURRENT_TIMESTAMP

SELECT CURRENT_TIMESTAMP
FROM DUAL
= 2019-01-31 06:55:07

LOCAL_TIMESTAMP

SELECT LOCAL_TIMESTAMP
FROM DUAL
= 01-JAN-19 10.01.10.123456 PM

LOCAL_TIMESTAMP

SELECT LOCAL_TIMESTAMP
FROM DUAL
= 2019-01-01 10:01:01.0

CURRENT_DATE

SELECT CURRENT_DATE
FROM DUAL
= 31-JAN-19

CURRENT_DATE

SELECT CURRENT_DATE
FROM DUAL
= 2019-01-31

CURRENT_TIMESTAMP

SELECT CURRENT_TIMESTAMP
FROM DUAL
= 31-JAN-19 06.54.35.543146 AM +00:00

CURRENT_TIMESTAMP

SELECT CURRENT_TIMESTAMP
FROM DUAL
= 2019-01-31 06:55:07

ADD_MONTHS

ADD_MONTHS(SYSDATE, 1)
= 31-JAN-19

ADDDATE

ADDDATE(SYSDATE(), 1)
= 2019-08-01 06:42:49.0

EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019

EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019

LAST_DAY

LAST_DAY('01-JAN-2019')
= 31-JAN-19

LAST_DAY

LAST_DAY('2019-01-01')
= 2019-01-31

MONTH_BETWEEN

MONTHS_BETWEEN(
SYSDATE, SYSDATE-60)
= 1.96

PERIOD_DIFF(date1,date2)

PERIOD_DIFF(
'201903', '201901')
= 2

TO_CHAR(
SYSDATE,'DD-MM-YYYY HH24:MI:SS')
= 01-01-2019 10:01:01

DATE_FORMAT

DATE_FORMAT(
SYSDATE(),'%d-%m-%Y %H:%i:%s')
= 01-01-2019 10:01:01

Funções de codificação e decodificação

DECODE

CASE

DUMP

ORA_HASH

MD5/SHA

Funções de conversão

CAST

CAST('1' as int) + 1
= 2

CAST

CAST('1' AS SIGNED) + 1
= 2

CONVERT

CONVERT('Ä Ê Í Õ Ø A B C D E ', 'US7ASCII', 'WE8ISO8859P1')
= ?? ?? ?? A B C

CONVERT

CONVERT('Ä Ê Í A B C ' USING utf8)
= Ä Ê Í A B C

TO_CHAR(22.73,'$99.9')
= $22.7

FORMAT

CONCAT('$',
FORMAT(22.73, 1))
= $22.7

TO_DATE

TO_DATE(
'2019/01/01', 'yyyy-mm-dd')
= 01-JAN-2019

STR_TO_DATE

STR_TO_DATE(
'2019/01/01', '%Y/%m/%d')
= 2019-01-01

TO_NUMBER

TO_NUMBER('01234')
= 1234

CAST

CAST('01234' as SIGNED)
= 1234

Funções SELECT condicionais

CASE

CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END

CASE

CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END

Funções nulas

COALESCE

COALESCE(
null, '1', 'a')
= a

COALESCE

COALESCE(
null, '1', 'a')
= 1

NULLIF

NULLIF('1', '2')
= a

NULLIF

NULLIF('1', '2')
= a

NVL

NVL(null, 'a')
= a

IFNULL

IFNULL(null, 'a')
= a

NVL2

CASE

CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END

Ambiente e funções de identificador

SYS_GUID

SELECT SYS_GUID()
FROM DUAL
= 8EFA4A31468B4C6DE05011AC0200009E

REPLACE(
UUID(), '-', '')

UID

SELECT UID FROM DUAL
= 43

USER

SELECT USER FROM DUAL
= UserName

USER + INSTR + SUBSTR

SELECT
SUBSTR(USER(), 1, INSTR(USER(), '@') -1) FROM DUAL
= root

USERENV

SELECT USERENV('LANGUAGE')
FROM DUAL
= ENGLISH_AMERICA.AL32UTF8

SHOW SESSION
VARIABLES

SHOW SESSION VARIABLES LIKE '%collation%';
= utf8_general_ci

ROWID

ROWNUM

Funções de agregação (grupo)

AVG

AVG

COUNT

COUNT

COUNT
(DISTINCT)

COUNT
(DISTINCT)

MAX

MAX

MIN

MIN

SUM

SUM

LISTAGG

SELECT LISTAGG(
DEPARTMENT_NAME, ', ')
WITHIN GROUP
(ORDER BY DEPARTMENT_NAME) DEPT
FROM DEPARTMENTS;


-- Single line results


= Accounting, Administration, Benefits, Construction

GROUP_CONCAT

SELECT GROUP_CONCAT(
DEPARTMENT_NAME ORDER BY DEPARTMENT_NAME SEPARATOR ', ') DEPT
FROM DEPARTMENTS;


-- Single line results


= Accounting, Administration, Benefits, Construction

Busca do Oracle 12c

FETCH

SELECT * FROM
EMPLOYEES
FETCH FIRST 10 ROWS ONLY;

SELECT * FROM
EMPLOYEES
LIMIT 10;

Filtragem básica, operadores e subconsultas

Durante a conversão, a filtragem básica, as funções do operador e as subconsultas são relativamente simples, exigindo pouco ou nenhum esforço.

Observações sobre a conversão

Examine e resolva os formatos de data porque os formatos Oracle e MySQL retornam resultados padrão diferentes:

• A função SYSDATE do Oracle por padrão retorna 01-AUG-19.
• Por padrão, a função SYSDATE() do MySQL retorna 2019-08-01 12:04:05.
• Os formatos de data e hora podem ser definidos usando as funções [DATE_FORMAT](https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_date-format) ou [STR_TO_DATE](https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_str-to-date) do MySQL.

EXISTS/NOT EXISTS

EXISTS/NOT EXISTS

SELECT * FROM DEPARTMENTS D
WHERE EXISTS (SELECT 1
              FROM EMPLOYEES E
              WHERE
              E.DEPARTMENT_ID =
              D.DEPARTMENT_ID);

IN/NOT IN

IN/NOT IN

SELECT * FROM DEPARTMENTS D
WHERE DEPARTMENT_ID IN
            (SELECT DEPARTMENT_ID
             FROM EMPLOYEES E);


-- OR


SELECT * FROM EMPLOYEES
WHERE (EMPLOYEE_ID, DEPARTMENT_ID)
IN((100, 90));

LIKE/NOT LIKE

LIKE/NOT LIKE

SELECT * FROM EMPLOYEES
WHERE FIRST_NAME LIKE '_e_n%';

BETWEEN/NOT BETWEEN

BETWEEN/NOT BETWEEN

SELECT * FROM EMPLOYEES
WHERE EXTRACT(YEAR FROM HIRE_DATE)
NOT BETWEEN 2001 and 2004;

AND/OR

AND/OR

SELECT * FROM EMPLOYEES
WHERE DEPARTMENT_ID IN(100, 101)
AND (SALARY >= 1000 OR HIRE_DATE <= '2006-02-05');

SubQuery

SubQuery

-- SELECT SubQuery
SELECT D.DEPARTMENT_NAME,
       (SELECT AVG(SALARY) AS AVG_SAL
        FROM EMPLOYEES E
        WHERE E.DEPARTMENT_ID =
              D.DEPARTMENT_ID) AVG_SAL
FROM DEPARTMENTS D;


-- JOIN SubQuery
SELECT FIRST_NAME, LAST_NAME, SALARY
FROM EMPLOYEES E JOIN
     (SELECT *
      FROM DEPARTMENTS
      WHERE  LOCATION_ID = 2700) D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;


-- Filtering Subquery
SELECT FIRST_NAME,
       LAST_NAME,
       SALARY
FROM EMPLOYEES
WHERE SALARY < (SELECT AVG(SALARY)
                FROM EMPLOYEES);

> | >= | < | <= | = | <> | !=

Funções analíticas (ou funções de janela e classificação)

As funções analíticas do Oracle estendem a funcionalidade das funções analíticas SQL padrão fornecendo recursos para calcular valores agregados com base em um grupo de linhas. Essas funções podem ser aplicadas a conjuntos de resultados particionados logicamente no escopo de uma única expressão de consulta. Geralmente, eles são usados em combinação com relatórios e análises de negócios, com o potencial de melhorar o desempenho da consulta como uma alternativa para alcançar o mesmo resultado usando um código SQL não analítico mais complexo.

Notas de conversão

• O MySQL versão 5.7 não fornece funções analíticas para oferecer compatibilidade com uma conversão de instruções SQL simples. No entanto, essa funcionalidade foi adicionada parcialmente no MySQL versão 8 (em inglês), tornando a conversão de funções analíticas um ponto a ser considerado, provavelmente exigindo esforço manual no processo de migração.
• Uma solução opcional é reescrever o código para remover o uso de funções analíticas, reverter para soluções de código SQL mais tradicionais ou mover essa lógica para uma camada de aplicativo.

Na tabela a seguir, veja as funções analíticas comuns do Oracle.

RANK
AVERAGE_RANK
DENSE_RANK
RANK ROW_NUMBER
PERCENT_RANK
CUME_DIST
NTILE
FIRST_VALUE
LAST_VALUE
OVER (PARTITION BY...)

CONNECT BY
HIER_ANCESTOR
HIER_CHILD_COUNT
HIER_DEPTH
HIER_LEVEL
HIER_ORDER
HIER_PARENT
HIER_TOP

LAG
LAG_VARIANCE LAG_VARIANCE_PERCENT LEAD
LEAD_VARIANCE LEAD_VARIANCE_PERCENT

Expressão de tabela comum (CTE)

Os CTEs fornecem uma maneira de implementar a lógica do código sequencial para reutilizar o código SQL que pode ser muito complexo ou não eficiente para uso múltiplo. Os CTEs podem ser nomeados e usados várias vezes em diferentes partes de uma instrução SQL usando a cláusula WITH.

Notas de conversão

• O MySQL versão 5.7 não é compatível com CTEs, mas o MySQL versão 8 (em inglês) sim.
• Para uma solução alternativa, use tabelas derivadas ou subconsultas ou reescreva a instrução SQL para eliminar a funcionalidade de CTE.

Exemplos

WITH DEPT_COUNT
(DEPARTMENT_ID, DEPT_COUNT) AS
(SELECT DEPARTMENT_ID,
        COUNT(*)
 FROM EMPLOYEES
 GROUP BY DEPARTMENT_ID)


SELECT E.FIRST_NAME ||' '|| E.LAST_NAME AS EMP_NAME,
       D.DEPT_COUNT AS EMP_DEPT_COUNT
FROM EMPLOYEES E JOIN DEPT_COUNT D
USING (DEPARTMENT_ID)
ORDER BY 2 DESC;

SELECT * FROM (
SELECT CONCAT(E.FIRST_NAME, ' ', E.LAST_NAME) AS EMP_NAME,
       (SELECT COUNT(*)
        FROM EMPLOYEES D
        WHERE E.DEPARTMENT_ID = D.DEPARTMENT_ID
        GROUP BY DEPARTMENT_ID) AS EMP_DEPT_COUNT
FROM EMPLOYEES E
ORDER BY 2 DESC) TBL
WHERE EMP_DEPT_COUNT IS NOT NULL;

Instrução MERGE

A instrução MERGE (ou UPSERT) fornece um meio para especificar instruções SQL que executam condicionalmente operações DML em uma operação MERGE, em vez de uma única operação DML, executada separadamente. Ele seleciona registros da tabela de origem e, em seguida, especificando uma estrutura lógica, executa automaticamente várias operações DML na tabela de destino. Esse recurso ajuda a evitar o uso de várias inserções, atualizações ou exclusões. Observe que MERGE é uma instrução determinística, ou seja, depois que uma linha é processada pela instrução MERGE, ela não pode ser processada novamente usando a mesma instrução MERGE.

Notas de conversão

Ao contrário do Oracle, o MySQL versão 5.7 não é compatível com a funcionalidade MERGE. Para simular parcialmente a funcionalidade MERGE, o MySQL fornece as instruções REPLACE e INSERT… ON DUPLICATE KEY UPDATE (links em inglês):

• REPLACE: funciona da mesma maneira que uma instrução INSERT, exceto se uma linha antiga na tabela tiver o mesmo valor de uma nova linha para um índice PRIMARY KEY ou UNIQUE. Nesse caso, a linha antiga é excluída antes que a nova linha seja inserida.

• INSERT… ON DUPLICATE KEY UPDATE: se uma linha inserida causar um valor duplicado em um índice PRIMARY KEY ou UNIQUE, ocorrerá um UPDATE da linha antiga para eliminar a exceção de chave duplicada, por exemplo:

  INSERT INTO tbl (a,b,c) VALUES (1,2,3)
    ON DUPLICATE KEY UPDATE c=c+1;
  
  UPDATE tbl SET c=c+1 WHERE a=1;
  

Outra solução seria converter a funcionalidade MERGE em um procedimento armazenado para gerenciar operações DML, usando os comandos INSERT, UPDATE e DELETE com processamento de exceções e duplicações.

Dicas de instrução SQL

O Oracle fornece uma grande coleção de dicas de consulta SQL que permite que os usuários influenciem o comportamento do otimizador e a tomada de decisão, com o objetivo de produzir planos de execução de consulta mais eficientes. O Oracle é compatível com mais de 60 dicas de banco de dados diferentes. O MySQL fornece um conjunto limitado de dicas de consulta.

Em geral, o MySQL versão 5.7 é compatível com dois tipos de dicas de consulta: OPTIMIZER HINTS e INDEX HINTS. As Dicas do otimizador do MySQL (em inglês) permitem controlar o comportamento do otimizador em instruções SQL individuais, por exemplo:

SELECT /*+ NO_RANGE_OPTIMIZATION(tbl PRIMARY, col1_idx) */ col1 FROM tbl;

Dicas do otimizador MySQL 5.7 disponíveis

BKA, NO_BKA

BNL, NO_BNL

MAX_EXECUTION_TIME

MRR, NO_MRR

NO_ICP

NO_RANGE_OPTIMIZATION

QB_NAME

SEMIJOIN, NO_SEMIJOIN

SUBQUERY

As Dicas de índice do MySQL (em inglês) fornecem ao otimizador informações sobre como escolher índices durante o processamento da consulta. As palavras-chave USE, FORCE ou IGNORE são usadas para controlar o processo de uso do índice do otimizador, por exemplo:

SELECT * FROM tbl USE INDEX (col1_index, col2_index);
-- OR
SELECT * FROM tbl IGNORE INDEX (col1_index, col2_index);

Observações sobre a conversão

Como há diferenças fundamentais entre o otimizador do MySQL e Oracle, e porque há limitação se houver sobreposição entre dicas de consulta MySQL e Oracle, recomendamos que você converta qualquer instrução SQL do Oracle que contenha dicas de consulta não especificadas sobre o banco de dados MySQL de destino.

Ajuste o desempenho do MySQL por meio das ferramentas do MySQL (por exemplo, Workbench (em inglês) do MySQL para painéis de desempenho em tempo real) e de recursos como análise de consultas usando planos de execução e ajuste dos parâmetros de instância ou sessão de acordo com o caso de uso.

Planos de execução

O principal objetivo dos planos de execução é fornecer uma visão interna das escolhas feitas pelo otimizador de consultas para acessar dados do banco de dados. O otimizador de consultas gera planos de execução para instruções SELECT, INSERT, UPDATE e DELETE para usuários de banco de dados, permitindo que os administradores tenham uma visão melhor de consultas específicas e operações DML. Elas são especialmente úteis quando você precisa fazer o ajuste de desempenho de consultas, por exemplo, para determinar o desempenho do índice ou para determinar se há índices ausentes que precisam ser criados.

Os planos de execução podem ser afetados por volumes de dados, estatísticas de dados e parâmetros de instância (parâmetros globais ou de sessão).

Considerações sobre conversão

Os planos de execução não são objetos de banco de dados que precisam ser migrados. Em vez disso, eles são uma ferramenta para analisar as diferenças de desempenho entre Oracle e MySQL executando a mesma instrução em conjuntos de dados idênticos.

O MySQL não é compatível com a mesma sintaxe, funcionalidade ou saída do plano de execução do Oracle.

Exemplos

SQL> EXPLAIN PLAN FOR
     SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 105;


SQL> SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY (FORMAT=>'ALL +OUTLINE'));


Plan hash value: 1833546154

---------------------------------------------------------------------------------------------
| Id  | Operation                   | Name          | Rows  | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT            |               |     1 |    69 |     1   (0)| 00:00:01 |
|   1 |  TABLE ACCESS BY INDEX ROWID| EMPLOYEES     |     1 |    69 |     1   (0)| 00:00:01 |
|*  2 |   INDEX UNIQUE SCAN         | EMP_EMP_ID_PK |     1 |       |     0   (0)| 00:00:01 |
---------------------------------------------------------------------------------------------

mysql> EXPLAIN SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 105;


+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
| id | select_type | table     | partitions | type  | possible_keys | key     | key_len | ref   | rows | filtered | Extra |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
|  1 | SIMPLE      | EMPLOYEES | NULL       | const | PRIMARY       | PRIMARY | 3       | const |    1 |   100.00 | NULL  |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+

Procedimentos, funções e gatilhos armazenados

PL/SQL é a linguagem processual estendida do Oracle usada para criar, armazenar e aplicar soluções baseadas em código no banco de dados. Em geral, os procedimentos e funções armazenados no banco de dados são elementos de código que consistem em linguagem processual estendida ANSI SQL e SQL, por exemplo, PL/SQL para Oracle, PL/pgSQL para PostgreSQL e linguagem processual MySQL para MySQL. O MySQL usa o mesmo nome do banco de dados para sua própria linguagem processual estendida.

O objetivo desses procedimentos e funções armazenados é fornecer soluções para requisitos mais adequados para execução no banco de dados e não no aplicativo (por exemplo, desempenho, compatibilidade e segurança). Ainda que os procedimentos e as funções armazenados usem PL/SQL, os procedimentos armazenados são usados principalmente para executar operações DDL/DML, e as funções são usadas principalmente para executar cálculos e retornar resultados específicos.

Linguagem processual PL/SQL para MySQL

Do ponto de vista da migração de código do Oracle PL/SQL para o MySQL, a implementação processual do MySQL é diferente da implementação do Oracle. Portanto, a migração de código é necessária para converter a funcionalidade PL/SQL do Oracle em procedimentos e funções armazenados no MySQL. Além disso, o pacote Oracle e o corpo do pacote não são compatíveis com o MySQL. Portanto, ao fazer a conversão de código, converta esses elementos (ou analise-os) em unidades únicas de código MySQL. Observe que os procedimentos e funções armazenados do MySQL também são chamados de rotinas.

Proprietário do objeto de código

No Oracle, o proprietário de um procedimento ou função armazenada é um usuário específico. No MySQL, o proprietário é um esquema específico (criado em um banco de dados por um usuário de banco de dados).

Privilégios e segurança do objeto de código

No Oracle, para criar um procedimento ou função armazenada, o usuário precisa ter o privilégio de sistema CREATE PROCEDURE (para criar procedimentos ou funções em outros usuários diferentes, os usuários do banco de dados precisam ter o privilégio CREATE ANY PROCEDURE). Para executar um procedimento armazenado ou uma função, os usuários do banco de dados precisam ter o privilégio EXECUTE.

No MySQL, para criar um elemento de código, o usuário precisa ter os privilégios CREATE ROUTINE e EXECUTE para executar. A cláusula DEFINER do MySQL define o criador do usuário para o objeto de código, e o usuário precisa ter os privilégios apropriados, como CREATE ROUTINE.

Sintaxe de procedimento e função armazenados do MySQL

O exemplo a seguir mostra o procedimento armazenado do MySQL e a sintaxe (em inglês):

CREATE
    [DEFINER = user]
    PROCEDURE sp_name ([proc_parameter[,...]])
    [characteristic ...] routine_body

CREATE
    [DEFINER = user]
    FUNCTION sp_name ([func_parameter[,...]])
    RETURNS type
    [characteristic ...] routine_body

proc_parameter:
    [ IN | OUT | INOUT ] param_name type

func_parameter:
    param_name type

type:
    Any valid MySQL data type

characteristic:
    COMMENT 'string'
  | LANGUAGE SQL
  | [NOT] DETERMINISTIC
  | { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
  | SQL SECURITY { DEFINER | INVOKER }

routine_body:
    Valid SQL routine statement