Conversión y optimización de consultas de Oracle Database a Cloud SQL para MySQL

Este documento analiza las diferencias de consulta básicas entre Oracle® y Cloud SQL para MySQL, y cómo las funciones de Oracle se asignan a las funciones de Cloud SQL para MySQL. También describe consideraciones de rendimiento para Cloud SQL para MySQL y formas de analizar y optimizar el rendimiento de las consultas enGoogle Cloud. Si bien este documento aborda técnicas para optimizar procedimientos almacenados y activadores de Cloud SQL para MySQL, no cubre cómo traducir código PL/SQL a funciones y procedimientos almacenados de MySQL.

Al convertir consultas de Oracle Database a Cloud SQL para MySQL, se deben considerar ciertas diferencias de dialecto SQL. También hay varias funciones integradas que son diferentes o incompatibles entre las dos plataformas de bases de datos.

Diferencias de consultas básicas

Si bien tanto Oracle como Cloud SQL para MySQL admiten ANSI SQL, existen varias diferencias fundamentales al consultar datos, principalmente en torno al uso de funciones del sistema.

La siguiente tabla resalta las diferencias en la sintaxis SELECT y FROM para Oracle y Cloud SQL para MySQL.

Nombre de la característica de Oracle implementación de oracle Compatibilidad con Cloud SQL para MySQL Equivalente de Cloud SQL para MySQL
Sintaxis básica de SQL para la recuperación de datos SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY		 Sí SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY
SELECT para impresión de salida SELECT 1 FROM DUAL Sí SELECT 1
o
SELECT 1 FROM DUAL
Alias ​​de columna SELECT COL1 AS C1 Sí SELECT COL1 AS C1
o
SELECT COL1 C1
Sensibilidad entre mayúsculas y minúsculas en los nombres de las tablas No se distingue entre mayúsculas y minúsculas (por ejemplo, el nombre de la tabla puede ser orders y ORDERS ) No Distingue entre mayúsculas y minúsculas según el nombre de la tabla definido (por ejemplo, el nombre de la tabla puede ser solo orders o ORDERS )

Vistas en línea

Las vistas en línea (también conocidas como tablas derivadas) son declaraciones SELECT , ubicadas en la cláusula FROM y utilizadas como subconsulta. Las vistas en línea pueden ayudar a simplificar las consultas complejas al eliminar los cálculos compuestos o eliminar las operaciones de combinación, al mismo tiempo que condensan varias consultas separadas en una única consulta simplificada.

El siguiente ejemplo describe un ejemplo de conversión de Oracle 11g/12c a Cloud SQL para MySQL para una vista en línea.

Una vista en línea en Oracle 11g/12c:

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

Una vista de trabajo en Cloud SQL para MySQL 5.7 con un alias:

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

Se une

Los tipos de unión de Oracle son compatibles con Cloud SQL para MySQL, excepto FULL JOIN . Las uniones de Cloud SQL para MySQL admiten el uso de sintaxis alternativa, como la cláusula USING , la cláusula WHERE en lugar de la cláusula ON y SUBQUERY en la declaración JOIN .

La siguiente tabla muestra un ejemplo de conversión JOIN .

Tipo JOIN de Oracle Compatibilidad con Cloud SQL para MySQL Sintaxis JOIN de Cloud SQL para MySQL
INNER JOIN Sí SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
CROSS JOIN Sí SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E CROSS JOIN DEPARTMENTS D
FULL JOIN No Considere usar UNION con RIGHT JOINS: LEFT y DERECHA:
SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E LEFT JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID UNION SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E RIGHT JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
LEFT JOIN [ OUTER ] Sí SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E LEFT JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
RIGHT JOIN [ OUTER ] Sí SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E RIGHT JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
SUBQUERY Sí SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E JOIN (SELECT * FROM DEPARTMENTS)D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

Si bien Cloud SQL para MySQL admite las funciones UNION y UNION ALL , no admite las funciones INTERSECT y MINUS de Oracle:

  • UNION adjunta los conjuntos de resultados de dos declaraciones SELECT después de eliminar registros duplicados.
  • UNION ALL adjunta los conjuntos de resultados de dos declaraciones SELECT sin eliminar registros duplicados.
  • INTERSECT devuelve la intersección de dos sentencias SELECT , sólo si existe un registro en los conjuntos de resultados de ambas consultas.
  • MINUS compara dos o más declaraciones SELECT y devuelve solo filas distintas de la primera consulta que no devuelve la segunda consulta.

La siguiente tabla muestra algunos ejemplos de conversión de Oracle a Cloud SQL para MySQL.

función de oráculo implementación de oracle Compatibilidad con Cloud SQL para MySQL Equivalente de Cloud SQL para MySQL
UNION SELECT COL1 FROM TBL1
UNION
SELECT COL1 FROM TBL2		 Sí SELECT COL1 FROM TBL1
UNION
SELECT COL1 FROM TBL2
UNION ALL SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2		 Sí SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2
INTERSECT SELECT COL1 FROM TBL1
INTERSECT
SELECT COL1 FROM TBL2		 No SELECT COL1 FROM TBL1
WHERE COL1 IN
(SELECT COL1 FROM TBL2)
MINUS SELECT COL1 FROM TBL1
MINUS
SELECT COL1 FROM TBL2		 No SELECT A.COL1 FROM TBL1 A LEFT JOIN TBL2 B ON USING(COL1) WHERE B.COL1 IS NULL

Funciones escalares y de grupo

Cloud SQL para MySQL proporciona una lista extensa de funciones escalares (de una sola fila) y de agregación. Algunas de las funciones de Cloud SQL para MySQL son similares a sus contrapartes de Oracle (por nombre y funcionalidad, o con un nombre diferente pero con funcionalidad similar). Si bien algunas funciones de Cloud SQL para MySQL pueden tener nombres idénticos a sus contrapartes de Oracle, también pueden exhibir funcionalidades diferentes.

La siguiente tabla describe dónde son equivalentes las funciones de caracteres de Oracle y Cloud SQL para MySQL por nombre y funcionalidad, y dónde se recomienda una conversión.

función de oráculo implementación de oracle Equivalente de Cloud SQL para MySQL Función Cloud SQL para MySQL Implementación de Cloud SQL para MySQL
CONCAT Devuelve la primera cadena concatenada con la segunda cadena:
CONCAT('A', 1) = A1		 Sí CONCAT CONCAT('A', 1) = A1
CONCAT USING PIPE FNAME |' '| LNAME No CONCAT CONCAT(FNAME, ' ', LNAME)
LOWER o UPPER Devuelve la cadena, con todas las letras en minúsculas o en mayúsculas:
LOWER('SQL') = sql		 Sí LOWER o UPPER LOWER('SQL') = sql
LPAD/RPAD Devuelve expression1 , rellenada hacia la izquierda o hacia la derecha hasta una longitud n caracteres con la secuencia de caracteres en expression2 :
LPAD('A',3,'*') = **A		 Sí LPAD o RPAD LPAD('A',3,'*') = **A
SUBSTR Devuelve una parte de la cadena, comenzando en la posición x (en este caso 3), con una longitud de y . La primera posición en la cadena es 1.
SUBSTR('MySQL', 3, 3) = SQL		 Sí SUBSTR SUBSTR('MySQL', 3, 3) = SQL
INSTR Devuelve la posición (índice) de una cadena de una cadena determinada:
INSTR('MySQL', 'y') = 2		 Sí INSTR INSTR('MySQL', 'y') = 2
REPLACE Devuelve una cadena con cada aparición de una cadena de búsqueda reemplazada por una cadena de reemplazo:
REPLACE('ORADB', 'ORA', 'MySQL') = MySQLDB		 Sí REPLACE REPLACE('ORADB', 'ORA', 'MySQL') = MySQLDB
TRIM Recorte los caracteres iniciales o finales (o ambos) de una cadena:
TRIM(both '-' FROM '-MySQL-') = MySQL TRIM(' MySQL ') = MySQL		 Sí TRIM TRIM(both '-' FROM '-MySQL-') = MySQL TRIM(' MySQL ') = MySQL
LTRIM/RTRIM Elimina del lado izquierdo o derecho de una cadena todos los caracteres que aparecen en la búsqueda:
LTRIM(' MySQL', ' ') = MySQL		 Parcialmente LTRIM or RTRIM Las funciones LTRIM y RTRIM de Oracle toman un segundo parámetro que especifica qué caracteres iniciales o finales se eliminarán de la cadena. Las funciones de Cloud SQL para MySQL solo eliminan los espacios en blanco iniciales y finales de la cadena dada:
LTRIM(' MySQL') = MySQL
ASCII Toma un solo carácter y devuelve su código ASCII numérico:
ASCII('A') = 65		 Sí ASCII ASCII('A') = 65
CHR Devuelve el valor del código ASCII, que es un valor numérico del 0 al 225, a un carácter:
CHR(65) = A		 Requiere un nombre de función diferente CHAR Cloud SQL para MySQL usa la función CHAR para la misma funcionalidad, por lo que debes cambiar el nombre de la función:
CHAR(65) = A
LENGTH Devuelve la longitud de una cadena determinada:
LENGTH('MySQL') = 5		 Sí LENGTH LENGTH('MySQL') = 5
REGEXP_REPLACE Busca una cadena para un patrón de expresión regular:
REGEXP_REPLACE('John', '[hn].', 'e') = Joe		 No N / A Compatible a partir de la versión 8 de MySQL. Como solución alternativa, utilice la función REPLACE si es posible o mueva la lógica a la capa de aplicación.
REGEXP_SUBSTR Extiende la funcionalidad de la función SUBSTR buscando en una cadena un patrón de expresión regular:
REGEXP_SUBSTR('https://console.cloud.google.com/sql/instances','https://([[:alnum:]]+\.?){3,4}/?') = https://console.cloud.google.com/		 No N / A Compatible a partir de la versión 8 de MySQL. Como solución alternativa, utilice la función SUBSTR si es posible o mueva la lógica a la capa de aplicación.
REGEXP_COUNT Devuelve el número de veces que ocurre un patrón en una cadena fuente No N / A No hay una función equivalente disponible para Cloud SQL para MySQL. Mueva esta lógica a la capa de aplicación.
REGEXP_INSTR Buscar una posición de cadena (índice) para un patrón de expresión regular No N / A Compatible a partir de la versión 8 de MySQL. Si tiene una versión anterior, mueva esta lógica a la capa de aplicación.
REVERSE Devuelve la cadena invertida para una cadena determinada:
REVERSE('MySQL') = LQSyM		 Sí REVERSE REVERSE('MySQL') = LQSyM

La siguiente tabla describe dónde las funciones numéricas de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y dónde se recomienda una conversión.

función de oráculo implementación de oracle Equivalente de Cloud SQL para MySQL Función Cloud SQL para MySQL Implementación de Cloud SQL para MySQL
ABS Devuelve el valor absoluto de un número dado:
ABS(-4.6) = 4.6		 Sí ABS ABS(-4.6) = 4.6
CEIL Devuelve el entero más pequeño que es mayor o igual al número dado:
CEIL(21.4) = 22		 Sí CEIL CEIL(21.4) = 22
FLOOR Devuelve el mayor entero igual o menor que el número dado:
FLOOR(-23.7) = -24		 Sí FLOOR FLOOR(-23.7) = -24
MOD Devuelve el resto de m dividido por n :
MOD(10, 3) = 1		 Sí MOD MOD(10, 3) = 1
ROUND Devuelve n redondeado a lugares enteros a la derecha del punto decimal:
ROUND(1.39, 1) = 1.4		 Sí ROUND ROUND(1.39, 1) = 1.4
TRUNC (número) Devuelve n1 truncado a n2 decimales. El segundo parámetro es opcional.
TRUNC(99.999) = 99 TRUNC(99.999, 0) = 99		 Requiere un nombre de función diferente TRUNCATE (número) La función de Cloud SQL para MySQL tiene un nombre diferente y el segundo parámetro es obligatorio.
TRUNCATE(99.999, 0) = 99

La siguiente tabla describe dónde las funciones datetime Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y dónde se recomienda una conversión.

función de oráculo implementación de oracle Equivalente de Cloud SQL para MySQL Función Cloud SQL para MySQL Implementación de Cloud SQL para MySQL
SYSDATE Devuelve la fecha y hora actuales establecidas para el sistema operativo en el que reside el servidor de la base de datos:
SELECT SYSDATE FROM DUAL; = 31-JUL-2019		 Sí SYSDATE()

Cloud SQL para MySQL SYSDATE() debe incluir paréntesis y devuelve de forma predeterminada un formato datetime diferente al de la función SYSDATE de Oracle:

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

Puede cambiar el formato datetime a nivel de sesión

SYSTIMESTAMP Devuelve la fecha del sistema, incluidas fracciones de segundo y zona horaria:
SELECT SYSTIMESTAMP FROM DUAL = 01-JAN-19 07.37.11.622187000 AM +00:00		 Requiere un nombre de función diferente CURRENT_ TIMESTAMP La función de Cloud SQL para MySQL devuelve un formato datetime diferente de forma predeterminada. Para reformatear la salida, utilice la función DATE_FORMAT() .
SELECT CURRENT_TIMESTAMP FROM DUAL; = 2019-01-31 06:55:07
LOCAL_ TIMESTAMP Devuelve la fecha y hora actuales como tipo TIMESTAMP :
SELECT LOCALTIMESTAMP FROM DUAL = 01-JAN-19 10.01.10.123456 PM		 Devuelve un formato datetime diferente LOCAL_ TIMESTAMP La función de Cloud SQL para MySQL devuelve un formato datetime diferente al formato predeterminado de Oracle. Para reformatear la salida, utilice la función DATE_FORMAT() .
SELECT LOCAL_TIMESTAMP FROM DUAL = 2019-01-01 10:01:01.0
CURRENT_DATE Devuelve la fecha actual:
SELECT CURRENT_DATE FROM DUAL = 31-JAN-19		 Devuelve un formato datetime diferente CURRENT_ DATE La función de Cloud SQL para MySQL devuelve un formato datetime diferente. Para reformatear la salida, utilice la función DATE_FORMAT() .
SELECT CURRENT_DATE FROM DUAL = 2019-01-31
CURRENT_ TIMESTAMP Devuelve la fecha y hora actuales:
SELECT CURRENT_TIMESTAMP FROM DUAL = 31-JAN-19 06.54.35.543146 AM +00:00		 Devuelve un formato datetime diferente CURRENT_ TIMESTAMP La función de Cloud SQL para MySQL devuelve un formato datetime diferente. Para reformatear la salida, utilice la función DATE_FORMAT() .
SELECT CURRENT_TIMESTAMP FROM DUAL = 2019-01-31 06:55:07
ADD_MONTHS Devuelve la fecha más meses enteros:
ADD_MONTHS(SYSDATE, 1) = 31-JAN-19		 Requiere un nombre de función diferente ADDDATE La función de Cloud SQL para MySQL devuelve un formato datetime diferente. Para reformatear la salida, utilice la función DATE_FORMAT() .
ADDDATE(SYSDATE(), 1) = 2019-08-01 06:42:49.0
EXTRACT (parte de fecha) Devuelve el valor de un campo datetime basado en una expresión de intervalo:
EXTRACT(YEAR FROM DATE '2019-01-31') = 2019		 Sí EXTRACT (parte de fecha) EXTRACT(YEAR FROM DATE '2019-01-31') = 2019
LAST_DAY Devuelve el último día del mes para una fecha determinada:
LAST_DAY('01-JAN-2019') = 31-JAN-19		 Parcialmente LAST_DAY La función de Cloud SQL para MySQL devuelve un formato datetime diferente al formato predeterminado de Oracle. Para reformatear la salida, utilice la función DATE_FORMAT() .
LAST_DAY('2019-01-01') = 2019-01-31
MONTH_ BETWEEN Devuelve el número de meses entre las fechas dadas date1 y date2 :
MONTHS_BETWEEN( SYSDATE, SYSDATE-60) = 1.96		 Parcialmente PERIOD_DIFF La función PERIOD_DIFF de Cloud SQL para MySQL devuelve la diferencia en meses como un número entero entre dos períodos (formateado como YYMM o YYYYMM ):
PERIOD_DIFF( '201903', '201901') = 2
TO_CHAR (Datetime) Convierte un tipo de número, datetime o marca de tiempo en un tipo de cadena
TO_CHAR( SYSDATE,'DD-MM-YYYY HH24:MI:SS') = 01-01-2019 10:01:01		 Requiere un nombre de función diferente DATE_FORMAT La función DATE_FORMAT de Cloud SQL para MySQL formatea un valor de fecha según una cadena de formato:
DATE_FORMAT( SYSDATE(),'%d-%m-%Y %H:%i:%s') 01-01-2019 10:01:01

La siguiente tabla describe dónde las funciones de codificación y decodificación de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y dónde se recomienda una conversión.

función de oráculo implementación de oracle Equivalente de Cloud SQL para MySQL Función Cloud SQL para MySQL Implementación de Cloud SQL para MySQL
DECODE Compara la expresión con cada valor de búsqueda uno por uno usando la funcionalidad de una declaración IF-THEN-ELSE No CASE Utilice la declaración CASE Cloud SQL para MySQL para obtener una funcionalidad similar
DUMP Devuelve un valor VARCHAR2 que contiene el código del tipo de datos, la longitud en bytes y la representación interna de la expresión. No N / A No compatible
ORA_HASH Calcula un valor hash para una expresión dada No MD5 or SHA Utilice la función MD5 para sumas de comprobación de 128 bits o la función SHA para sumas de comprobación de 160 bits

La siguiente tabla describe dónde son equivalentes las funciones de conversión de Oracle y Cloud SQL para MySQL por nombre y funcionalidad, y dónde se recomienda una conversión.

función de oráculo implementación de oracle Equivalente de Cloud SQL para MySQL Función Cloud SQL para MySQL Implementación de Cloud SQL para MySQL
CAST Convierte un tipo de datos integrado o valor de tipo colección en otro tipo de datos integrado o valor de tipo colección:
CAST('1' as int) + 1 = 2		 Parcialmente CAST Ajustar dependiendo de si se requiere una conversión explícita o implícita:
CAST('1' AS SIGNED) + 1 = 2
CONVERT Convierte una cadena de caracteres de un conjunto de caracteres a otro:
CONVERT ( 'Ä Ê Í Õ Ø ABCDE ', 'US7ASCII', 'WE8ISO8859P1') = ?? ?? ?? ABC		 Parcialmente CONVERT La función CONVERT de Cloud SQL para MySQL requiere algunos ajustes en la sintaxis y los parámetros:
CONVERT( 'Ä Ê Í ABC ' USING utf8) = Ä Ê Í ABC
TO_CHAR (cadena/numérico) La función convierte un número o fecha en una cadena:
TO_CHAR(22.73,'$99.9') = $22.7		 No FORMAT La función FORMAT Cloud SQL para MySQL convierte un número a un formato como #,###,###.## , lo redondea a un decimal y luego devuelve el resultado como una cadena:
CONCAT('$', FORMAT(22.73, 1)) = $22.7
TO_DATE La función TO_DATE de Oracle convierte una cadena en una fecha basada en un formato de datetimecode :
TO_DATE( '2019/01/01', 'yyyy-mm-dd') = 01-JAN-2019		 Requiere un nombre de función diferente STR_TO_DATE La función STR_TO_DATE Cloud SQL para MySQL toma una cadena y devuelve una fecha basada en un formato datetime :
STR_TO_DATE( '2019/01/01', '%Y/%m/%d') = 2019-01-01
TO_NUMBER Convierte la expresión en un valor de un tipo de datos NUMBER :
TO_NUMBER('01234') = 1234		 Requiere un nombre de función diferente CAST Utilice la función CAST Cloud SQL para MySQL para devolver el mismo resultado que la función TO_NUMBER de Oracle:
CAST('01234' as SIGNED) = 1234

La siguiente tabla describe dónde las funciones SELECT condicionales de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y dónde se recomienda una conversión.

función de oráculo implementación de oracle Equivalente de Cloud SQL para MySQL Función Cloud SQL para MySQL Implementación de Cloud SQL para MySQL
CASE La declaración CASE elige entre una secuencia de condiciones y ejecuta una declaración correspondiente con la siguiente sintaxis:
CASE WHEN condition THEN result [WHEN ...] [ELSE result] END		 Sí CASE Además de la función CASE , Cloud SQL para MySQL admite el uso del manejo condicional IF/ELSE dentro de la instrucción SELECT :
CASE WHEN condition THEN result [WHEN ...] [ELSE result] END

La siguiente tabla describe dónde las funciones nulas de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y dónde se recomienda una conversión.

función de oráculo implementación de oracle Equivalente de Cloud SQL para MySQL Función Cloud SQL para MySQL Implementación de Cloud SQL para MySQL
COALESCE Devuelve la primera expresión no nula en la lista de expresiones:
COALESCE( null, '1', 'a') = a		 Sí COALESCE COALESCE( null, '1', 'a') = 1
NULLIF Realiza una comparación entre expression1 y expression2 . Si son iguales, la función devuelve null . Si no son iguales, la función devuelve expression1 :
NULLIF('1', '2') = a		 Sí NULLIF NULLIF('1', '2') = a
NVL Reemplaza un valor null con una cadena en los resultados de una consulta:
NVL(null, 'a') = a		 No IFNULL IFNULL(null, 'a') = a
NVL2 Determina el valor devuelto por una consulta en función de si una expresión es nula o no. No CASE La declaración CASE elige entre una secuencia de condiciones y ejecuta la declaración correspondiente:
CASE WHEN condition THEN result [WHEN ...] [ELSE result] END

La siguiente tabla describe dónde son equivalentes las funciones de identificador y el entorno de Oracle y Cloud SQL para MySQL por nombre y funcionalidad, y dónde se recomienda una conversión.

función de oráculo implementación de oracle Equivalente de Cloud SQL para MySQL Función Cloud SQL para MySQL Implementación de Cloud SQL para MySQL
SYS_GUID Genera y devuelve un identificador único global (valor RAW ) compuesto por 16 bytes:
SELECT SYS_GUID() FROM DUAL = 8EFA4A31468B4C6DE05011AC0200009E		 No REPLACE y UUID Como solución alternativa, utilice las funciones REPLACE y UUID para simular la función SYS_GUID :
REPLACE( UUID(), '-', '')
UID Devuelve un número entero que identifica de forma única al usuario de la sesión (el usuario que ha iniciado sesión):
SELECT UID FROM DUAL = 43		 No N / A N / A
USER Devuelve el nombre de usuario del usuario que está conectado a la sesión actual:
SELECT USER FROM DUAL = username		 Sí USER + INSTR + SUBSTR La función USER Cloud SQL para MySQL devuelve el nombre de usuario y el nombre de host ( root@ IP_ADDRESS ) para la conexión. Para recuperar solo el nombre de usuario, utilice las funciones de soporte adicionales:
SELECT SUBSTR(USER(), 1, INSTR(USER(), '@') -1) FROM DUAL = root
USERENV Devuelve información sobre la sesión actual de Oracle, como el idioma de la sesión:
SELECT USERENV('LANGUAGE') FROM DUAL = ENGLISH_AMERICA. AL32UTF8		 No SHOW SESSION VARIABLES La declaración SHOW SESSION VARIABLES de Cloud SQL para MySQL devuelve la configuración para la sesión actual:
SHOW SESSION VARIABLES LIKE '%collation%'; = utf8_general_ci
ROWID Oracle asigna a cada fila de una tabla un ROWID único para identificar la fila en la tabla. El ROWID es la dirección de la fila que contiene el número del objeto de datos, el bloque de datos de la fila, la posición de la fila y el archivo de datos. Parcialmente N / A ROW_NUMBER() está disponible a partir de MySQL 8.0. Si está utilizando una versión anterior, emule la misma funcionalidad utilizando una variable de sesión @row_number .
ROWNUM Devuelve un número que representa el orden en que una tabla de Oracle devuelve una fila. Parcialmente N / A ROW_NUMBER() está disponible a partir de MySQL 8.0. Si está utilizando una versión anterior, emule la misma funcionalidad utilizando una variable de sesión @row_number .

En la siguiente tabla se describe dónde las funciones agregadas (de grupo) de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y dónde se recomienda una conversión.

función de oráculo implementación de oracle Equivalente de Cloud SQL para MySQL Función Cloud SQL para MySQL Implementación de Cloud SQL para MySQL
AVG Devuelve el valor promedio de una columna o expresión. Sí AVG Equivalente a Oráculo
COUNT Devuelve el número de filas devueltas por una consulta. Sí COUNT Equivalente a Oráculo
COUNT (DISTINCT) Devuelve el número de valores únicos en la columna o expresión. Sí COUNT (DISTINCT) Equivalente a Oráculo
MAX Devuelve el valor máximo de una columna o expresión. Sí MÁXIMO Equivalente a Oráculo
MIN Devuelve el valor mínimo de una columna o expresión. Sí MIN Equivalente a Oráculo
SUM Devuelve la suma de un valor de una columna o expresión Sí SUM Equivalente a Oráculo
LISTAGG Ordena los datos dentro de cada grupo especificado en la cláusula ORDER BY y concatena los valores de la columna de medida:
SELECT LISTAGG( DEPARTMENT_NAME, ', ') WITHIN GROUP (ORDER BY DEPARTMENT_NAME) DEPT FROM DEPARTMENTS; -- Single line results = Accounting, Administration, Benefits, Construction		 Requiere un nombre de función y una sintaxis diferentes GROUP_ CONCAT Utilice la función GROUP_CONCAT Cloud SQL para MySQL para obtener resultados equivalentes:
SELECT GROUP_CONCAT( DEPARTMENT_NAME ORDER BY DEPARTMENT_NAME SEPARATOR ', ') DEPT FROM DEPARTMENTS; -- Single line results = Accounting, Administration, Benefits, Construction

La siguiente tabla describe dónde la función FETCH de Oracle y Cloud SQL para MySQL es equivalente por nombre y funcionalidad.

función de oráculo implementación de oracle Equivalente de Cloud SQL para MySQL Función Cloud SQL para MySQL Implementación de Cloud SQL para MySQL
FETCH Recupera un número específico de filas del conjunto de resultados de una consulta de varias filas:
SELECT * FROM EMPLOYEES FETCH FIRST 10 ROWS ONLY;		 Sí LIMIT Utilice la cláusula LIMIT MySQL para recuperar filas de una consulta:
SELECT * FROM EMPLOYEES LIMIT 10;

Filtrado básico, operadores y subconsultas.

El filtrado básico, las funciones de operador y las subconsultas son relativamente sencillos de convertir y requieren un esfuerzo nominal. La mayor parte del esfuerzo gira en torno a la conversión de formatos de fecha porque Oracle y Cloud SQL para MySQL usan diferentes formatos de fecha predeterminados:

  • La función SYSDATE de Oracle devuelve este formato de forma predeterminada: 01-AUG-19 .
  • La función SYSDATE() de Cloud SQL para MySQL devuelve este formato de forma predeterminada: 2019-08-01 12:04:05 .

Para establecer formatos de fecha y hora, utilice las funciones MySQL DATE_FORMAT o STR_TO_DATE .

La siguiente tabla describe dónde son equivalentes por nombre y funcionalidad las funciones de subconsulta, operadores y filtrado básico de Oracle y Cloud SQL para MySQL, y dónde se recomienda una conversión.

función de oráculo implementación de oracle Equivalente de Cloud SQL para MySQL Función de Cloud SQL para MySQL
EXISTS/ NOT EXISTS Sí EXISTS/ NOT EXISTS SELECT * FROM DEPARTMENTS D WHERE EXISTS (SELECT 1 FROM EMPLOYEES E WHERE E.DEPARTMENT_ID = D.DEPARTMENT_ID);
IN/NOT IN Sí 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 Sí LIKE/NOT LIKE SELECT * FROM EMPLOYEES WHERE FIRST_NAME LIKE '_e_n%';
BETWEEN/ NOT BETWEEN Sí BETWEEN/ NOT BETWEEN SELECT * FROM EMPLOYEES WHERE EXTRACT(YEAR FROM HIRE_DATE) NOT BETWEEN 2001 and 2004;
AND/OR Sí AND/OR SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID IN(100, 101) AND (SALARY >= 1000 OR HIRE_DATE <= '2006-02-05');
SubQuery Sí SubQuery Cloud SQL para MySQL admite subconsultas en la cláusula SELECT , en la cláusula JOIN y para filtrar en las cláusulas WHERE/AND :
-- 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);
Operadores Sí Operadores Cloud SQL para MySQL admite todos los operadores básicos:
> | >= | < | <= | = | <> | !=

Mejores prácticas para consultas de Cloud SQL para MySQL

Para mantener niveles comparables de rendimiento entre Cloud SQL para MySQL y Oracle, es posible que necesites optimizar tus consultas. Estas optimizaciones incluyen cambiar las estructuras de índice y ajustar el esquema de la base de datos. Esta sección proporciona algunas pautas para ayudarlo a lograr un rendimiento de consultas comparable en Cloud SQL para MySQL.

Crear un índice agrupado

Cuando se utiliza el motor de almacenamiento InnoDB , una mejor práctica es definir una tabla con una clave principal, porque esta clave crea un índice agrupado en esa tabla. Además de mejorar el rendimiento de las consultas, este enfoque también le permite crear índices secundarios adicionales. Sin embargo, debes evitar crear demasiados índices. Tener índices redundantes no mejora el rendimiento y puede ralentizar la ejecución de DML . Esta mejor práctica conduce a una segunda mejor práctica: supervise periódicamente los índices redundantes y, si tiene alguno redundante, elimínelo de la base de datos.

Utilice la siguiente consulta para identificar tablas sin claves principales para poder crear claves principales para ellas:

mysql> SELECT t.table_schema, t.table_name
       FROM information_schema.tables t LEFT JOIN
       information_schema.statistics s
       ON t.table_schema=s.table_schema AND t.table_name=s.table_name
       AND s.non_unique=0
       WHERE s.table_name IS NULL
       AND t.table_schema NOT IN('sys', 'information_schema', 'mysql',
       'performance_schema')
       AND t.`TABLE_TYPE` <> 'VIEW';

Utilice la siguiente consulta para buscar tablas que no tengan índices para poder crear índices para ellas:

mysql> SELECT t.table_schema, t.table_name FROM INFORMATION_SCHEMA.tables t
       WHERE table_name NOT IN
             (SELECT  table_name FROM (
                      SELECT  table_name, index_name
                      FROM information_schema.statistics
                  GROUP BY  table_name, index_name) tab_ind_cols
           GROUP BY table_name)
AND table_schema NOT IN('sys', 'information_schema', 'mysql', 'performance_schema')
AND TABLE_TYPE <> 'VIEW';

Utilice la siguiente consulta para comprobar si hay índices redundantes para poder eliminar las redundancias:

mysql> SELECT * FROM sys.schema_redundant_indexes;

Ajustar los parámetros de consulta

Para ajustar el rendimiento de las consultas, es posible que necesite ajustar los parámetros de la sesión. Cloud SQL para MySQL tiene un conjunto de indicadores que puedes modificar para este propósito, incluidos los siguientes indicadores:

  • Parámetros relacionados con InnoDB
  • SORT parámetros
  • JOIN parámetros
  • Parámetros de manejo de caché

Monitorear consultas

Las consultas de ejecución lenta pueden hacer que el sistema deje de responder o generar otros cuellos de botella, por lo que es importante monitorear las consultas periódicamente.

Hay varias formas de diagnosticar sentencias SQL de ejecución lenta:

  • Utilice el panel de Cloud SQL para MySQL para obtener información histórica y en tiempo real sobre consultas de ejecución lenta.
  • Utilice Cloud Monitoring para monitorear el registro de consultas lentas de Cloud SQL para MySQL.

  • Utilice la vista statement_analysis Cloud SQL para MySQL para ver las estadísticas de tiempo de ejecución de una declaración SQL:

    mysql> SELECT * FROM sys.statement_analysis;

Analizar consultas de Cloud SQL para MySQL

El optimizador de consultas en Cloud SQL para MySQL genera un plan de ejecución para declaraciones SELECT , INSERT , UPDATE y DELETE . Estos planes son útiles cuando ajusta una consulta de ejecución lenta. Hay algunas consideraciones a tener en cuenta:

  • Los planes de ejecución no son objetos de base de datos que deban migrarse; más bien, son una herramienta para analizar las diferencias de rendimiento entre Oracle y Cloud SQL para MySQL que ejecutan la misma declaración en conjuntos de datos idénticos.
  • Cloud SQL para MySQL no admite la misma sintaxis, funcionalidad o resultado del plan de ejecución que Oracle.

A continuación se muestra un plan de ejemplo para ilustrar las diferencias entre un plan de ejecución de Oracle y un plan de ejecución de Cloud SQL para MySQL:

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  |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+

Optimice los procedimientos almacenados y los desencadenantes.

A diferencia de Oracle, las funciones y procedimientos almacenados de Cloud SQL para MySQL se analizan en cada ejecución. Una herramienta útil para evaluar el rendimiento de funciones y procedimientos almacenados es la utilidad MySQL BENCHMARK() . Esta herramienta toma dos parámetros, un recuento de iteraciones y una expresión, y estima el tiempo de ejecución de la expresión dada (por ejemplo, procedimiento almacenado, función y declaración SELECT ). El resultado representa el tiempo de ejecución total aproximado en todas las iteraciones.

El siguiente es un ejemplo para ilustrar la utilidad BENCHMARK() :

-- SELECT Expression Example

mysql> select benchmark(10000000, 'select sysdate()');
+-----------------------------------------+
| benchmark(10000000, 'select sysdate()') |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
1 row in set (0.12 sec)

-- Result: Run time of 0.12 sec for 1,0000,000 iterations

-- FUNCTION Example
mysql> select benchmark(1000000, func1());
+-----------------------------+
| benchmark(1000000, func1()) |
+-----------------------------+
|                           0 |
+-----------------------------+
1 row in set (2.54 sec)

-- Result: Run time of 2.54 sec for 1,000,000 iterations

Si nota una regresión en el rendimiento durante la conversión, utilice el comando EXPLAIN de MySQL para identificar los posibles factores que contribuyen a la regresión. Una solución común para el rendimiento lento es alterar la estructura del índice de una tabla para adaptarla al optimizador MySQL. Otra práctica común es optimizar un código PL/SQL convertido reduciendo la recuperación de datos innecesaria o usando tablas temporales dentro del código MySQL procesal.

¿Qué sigue?

  • Explore más sobre las cuentas de usuario de MySQL .
  • Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Eche un vistazo a nuestro Centro de arquitectura en la nube .