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

En este documento, se analizan las diferencias básicas entre las consultas de Oracle® y Cloud SQL para MySQL, y cómo las características de Oracle se asignan a las de Cloud SQL para MySQL. También se describen las consideraciones de rendimiento de Cloud SQL para MySQL y las formas de analizar y optimizar el rendimiento de las consultas en Google Cloud. Si bien en este documento se tratan las técnicas para optimizar los procedimientos almacenados y los activadores de Cloud SQL para MySQL, no se explica cómo traducir código PL/SQL a funciones y procedimientos almacenados de MySQL.

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

Diferencias básicas entre las consultas

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

En la siguiente tabla, se destacan las diferencias en la sintaxis de SELECT y FROM de 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 la 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
Distinción entre mayúsculas y minúsculas del nombre de la tabla	Sin distinción 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 definido de la tabla (por ejemplo, el nombre de la tabla solo puede ser orders o ORDERS)

Vistas intercaladas

Las vistas intercaladas (también conocidas como tablas derivadas) son declaraciones SELECT, ubicadas en la cláusula FROM, que se usan como una subconsulta. Las vistas intercaladas pueden ayudar a simplificar las consultas complejas, ya que quitan los cálculos compuestos, o eliminan las operaciones de unión, a la vez que condensan varias consultas separadas en una sola consulta simplificada.

Nota: Las vistas intercaladas de Oracle no requieren el uso de alias, mientras que las vistas intercaladas de Cloud SQL para MySQL requieren un alias específico para cada una.

En el siguiente ejemplo, se muestra un ejemplo de conversión de Oracle 11g/12c a Cloud SQL para MySQL para una vista intercalada.

Una vista intercalada 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;

Uniones

Cloud SQL para MySQL admite los tipos de uniones de Oracle, 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 ON y SUBQUERY en la declaración JOIN.

En la siguiente tabla, se muestra un ejemplo de conversión JOIN.

Tipo de 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	Considera usar UNION con LEFT y RIGHT JOINS: 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 los registros duplicados.
• UNION ALL adjunta los conjuntos de resultados de dos declaraciones SELECT sin eliminar los registros duplicados.
• INTERSECT muestra la intersección de dos declaraciones SELECT, solo si existe un registro en los conjuntos de resultados de ambas consultas.
• MINUS compara dos o más declaraciones SELECT y solo muestra filas distintas de la primera consulta que no son mostradas por la segunda.

Nota: Usar JOIN, IN, o EXISTS funciona como una solución alternativa cuando se convierten las funciones INTERSECT o MINUS de Oracle a Cloud SQL para MySQL.

En la siguiente tabla, se muestran algunos ejemplos de conversiones de Oracle a Cloud SQL para MySQL.

Función de Oracle	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 equivalentes de Oracle (por nombre y funcionalidad, o tienen un nombre diferente, pero con una funcionalidad similar). Si bien algunas funciones de Cloud SQL para MySQL pueden tener nombres idénticos a sus equivalentes de Oracle, también pueden exhibir funcionalidades diferentes.

En la siguiente tabla, se describe en qué casos las funciones de caracteres de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y en cuáles se recomienda la conversión.

Función de Oracle	Implementación de Oracle	Equivalente de Cloud SQL para MySQL	Función de Cloud SQL para MySQL	Implementación de Cloud SQL para MySQL
CONCAT	Muestra la primera string concatenada con la segunda: CONCAT('A', 1) = A1	Sí	CONCAT	CONCAT('A', 1) = A1
CONCAT USING PIPE	FNAME |' '| LNAME	No	CONCAT	CONCAT(FNAME, ' ', LNAME)
LOWER o UPPER	Muestra la string, con todas las letras en minúscula o en mayúscula: LOWER('SQL') = sql	Sí	LOWER o UPPER	LOWER('SQL') = sql
LPAD/RPAD	Muestra expression1, con relleno izquierdo o derecho de n caracteres, con la secuencia de caracteres en expression2: LPAD('A',3,'*') = **A	Sí	LPAD o RPAD	LPAD('A',3,'*') = **A
SUBSTR	Muestra una parte de la string. Comienza en la posición x (en este caso, 3), con una longitud de y. La primera posición en la string es 1. SUBSTR('MySQL', 3, 3) = SQL	Sí	SUBSTR	SUBSTR('MySQL', 3, 3) = SQL
INSTR	Muestra la posición (índice) de una string a partir de una string determinada: INSTR('MySQL', 'y') = 2	Sí	INSTR	INSTR('MySQL', 'y') = 2
REPLACE	Muestra una string con cada ocurrencia de una string de búsqueda reemplazada con una string de reemplazo: REPLACE('ORADB', 'ORA', 'MySQL') = MySQLDB	Sí	REPLACE	REPLACE('ORADB', 'ORA', 'MySQL') = MySQLDB
TRIM	Recorta los caracteres iniciales o finales (o ambos) de una string: TRIM(both '-' FROM '-MySQL-') = MySQL TRIM(' MySQL ') = MySQL	Sí	TRIM	TRIM(both '-' FROM '-MySQL-') = MySQL TRIM(' MySQL ') = MySQL
LTRIM/RTRIM	Quita del lado izquierdo o derecho de una string 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 quitar de la string. Las funciones de Cloud SQL para MySQL solo quitan los espacios en blanco al inicio y al final de la string determinada: LTRIM(' MySQL') = MySQL
ASCII	Toma un solo carácter y muestra su código ASCII numérico: ASCII('A') = 65	Sí	ASCII	ASCII('A') = 65
CHR	Muestra el valor del código ASCII, que es un valor numérico de 0 a 225, de 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	Muestra la longitud de una string determinada: LENGTH('MySQL') = 5	Sí	LENGTH	LENGTH('MySQL') = 5
REGEXP_REPLACE	Busca un patrón de expresión regular en una string: REGEXP_REPLACE('John', '[hn].', 'e') = Joe	No	N/A	Compatible con la versión 8 de MySQL. Como solución alternativa, usa la función REPLACE, si es posible, o mueve la lógica a la capa de la aplicación.
REGEXP_SUBSTR	Extiende la funcionalidad de la función SUBSTR mediante la búsqueda de un patrón de expresión regular en una string: REGEXP_SUBSTR('https://console.cloud.google.com/sql/instances','https://([[:alnum:]]+\.?){3,4}/?') = https://console.cloud.google.com/	No	N/A	Compatible con la versión 8 de MySQL. Como solución alternativa, usa la función SUBSTR, si es posible, o mueve la lógica a la capa de la aplicación.
REGEXP_COUNT	Muestra la cantidad de veces en que se produce un patrón en una string de origen	No	N/A	No existe una función equivalente disponible para Cloud SQL para MySQL. Mueve esta lógica a la capa de la aplicación.
REGEXP_INSTR	Busca una posición de string (índice) para un patrón de expresión regular	No	N/A	Compatible con la versión 8 de MySQL. Si usas una versión anterior, mueve esta lógica a la capa de la aplicación.
REVERSE	Muestra la string revertida de una string determinada: REVERSE('MySQL') = LQSyM	Sí	REVERSE	REVERSE('MySQL') = LQSyM

En la siguiente tabla, se describe en qué casos las funciones numéricas de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y en cuáles se recomienda una conversión.

Función de Oracle	Implementación de Oracle	Equivalente de Cloud SQL para MySQL	Función de Cloud SQL para MySQL	Implementación de Cloud SQL para MySQL
ABS	Muestra el valor absoluto de un número determinado: ABS(-4.6) = 4.6	Sí	ABS	ABS(-4.6) = 4.6
CEIL	Muestra el número entero más pequeño que es mayor o igual que el número determinado: CEIL(21.4) = 22	Sí	CEIL	CEIL(21.4) = 22
FLOOR	Muestra el número entero más grande que es igual o menor que el número determinado: FLOOR(-23.7) = -24	Sí	FLOOR	FLOOR(-23.7) = -24
MOD	Muestra el resto de m dividido por n: MOD(10, 3) = 1	Sí	MOD	MOD(10, 3) = 1
ROUND	Muestra n redondeado a números enteros a la derecha del punto decimal: ROUND(1.39, 1) = 1.4	Sí	ROUND	ROUND(1.39, 1) = 1.4
TRUNC(número)	Muestra n1 truncado a n2 lugares 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

En la siguiente tabla, se describe en qué casos las funciones datetime de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y en cuáles se recomienda una conversión.

Función de Oracle	Implementación de Oracle	Equivalente de Cloud SQL para MySQL	Función de Cloud SQL para MySQL	Implementación de Cloud SQL para MySQL
SYSDATE	Muestra la fecha y hora actuales establecidas para el sistema operativo en el que se encuentra el servidor de la base de datos: SELECT SYSDATE FROM DUAL; = 31-JUL-2019	Sí	SYSDATE()	SYSDATE() de Cloud SQL para MySQL debe incluir paréntesis y muestra, 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 Puedes cambiar el formato datetime a nivel de la sesión
SYSTIMESTAMP	Muestra la fecha del sistema, incluidos los segundos fraccionarios y la 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 muestra un formato datetime diferente de forma predeterminada. Para cambiar el formato del resultado, usa la función DATE_FORMAT(). SELECT CURRENT_TIMESTAMP FROM DUAL; = 2019-01-31 06:55:07
LOCAL_ TIMESTAMP	Muestra la fecha y hora actuales como un tipo TIMESTAMP: SELECT LOCALTIMESTAMP FROM DUAL = 01-JAN-19 10.01.10.123456 PM	Muestra un formato datetime diferente.	LOCAL_ TIMESTAMP	La función de Cloud SQL para MySQL muestra un formato datetime diferente al formato predeterminado para Oracle. Para cambiar el formato del resultado, usa la función DATE_FORMAT(). SELECT LOCAL_TIMESTAMP FROM DUAL = 2019-01-01 10:01:01.0
CURRENT_DATE	Muestra la fecha actual: SELECT CURRENT_DATE FROM DUAL = 31-JAN-19	Muestra un formato datetime diferente.	CURRENT_ DATE	La función de Cloud SQL para MySQL muestra un formato datetime diferente. Para cambiar el formato del resultado, usa la función DATE_FORMAT(). SELECT CURRENT_DATE FROM DUAL = 2019-01-31
CURRENT_ TIMESTAMP	Muestra la fecha y hora actuales: SELECT CURRENT_TIMESTAMP FROM DUAL = 31-JAN-19 06.54.35.543146 AM +00:00	Muestra un formato datetime diferente.	CURRENT_ TIMESTAMP	La función de Cloud SQL para MySQL muestra un formato datetime diferente. Para cambiar el formato del resultado, usa la función DATE_FORMAT(). SELECT CURRENT_TIMESTAMP FROM DUAL = 2019-01-31 06:55:07
ADD_MONTHS	Muestra la fecha más los 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 muestra un formato datetime diferente. Para cambiar el formato del resultado, usa la función DATE_FORMAT(). ADDDATE(SYSDATE(), 1) = 2019-08-01 06:42:49.0
EXTRACT (parte de la fecha)	Muestra 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 la fecha)	EXTRACT(YEAR FROM DATE '2019-01-31') = 2019
LAST_DAY	Muestra el último día del mes de una fecha determinada: LAST_DAY('01-JAN-2019') = 31-JAN-19	Parcialmente	LAST_DAY	La función de Cloud SQL para MySQL muestra un formato datetime diferente al formato predeterminado para Oracle. Para cambiar el formato del resultado, usa la función DATE_FORMAT(). LAST_DAY('2019-01-01') = 2019-01-31
MONTH_ BETWEEN	Muestra la cantidad de meses entre las fechas determinadas date1 y date2: MONTHS_BETWEEN( SYSDATE, SYSDATE-60) = 1.96	Parcialmente	PERIOD_DIFF	La función PERIOD_DIFF de Cloud SQL para MySQL muestra la diferencia en meses como un número entero entre dos períodos (con formato 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 string 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 convierte el formato de un valor de fecha según una string de formato: DATE_FORMAT( SYSDATE(),'%d-%m-%Y %H:%i:%s') 01-01-2019 10:01:01

En la siguiente tabla, se describe en qué casos las funciones de codificación y decodificación de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y en cuáles se recomienda una conversión.

Función de Oracle	Implementación de Oracle	Equivalente de Cloud SQL para MySQL	Función de Cloud SQL para MySQL	Implementación de Cloud SQL para MySQL
DECODE	Compara la expresión con cada valor de búsqueda con la funcionalidad de una declaración IF-THEN-ELSE.	No	CASE	Usa la declaración CASE de Cloud SQL para MySQL a fin de obtener una funcionalidad similar.
DUMP	Muestra un valor VARCHAR2 que contiene el código de 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 de hash de una expresión determinada.	No	MD5 or SHA	Usa la función MD5 para sumas de verificación de 128 bits o la función SHA para sumas de verificación de 160 bits.

En la siguiente tabla, se describe en qué casos las funciones de conversión de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y en cuáles se recomienda una conversión.

Función de Oracle	Implementación de Oracle	Equivalente de Cloud SQL para MySQL	Función de Cloud SQL para MySQL	Implementación de Cloud SQL para MySQL
CAST	Convierte un tipo de datos integrado o un valor de tipo de colección en otro tipo de datos integrado o valor de tipo de colección: CAST('1' as int) + 1 = 2	Parcialmente	CAST	Realiza un ajuste según se requiera una conversión explícita o implícita: CAST('1' AS SIGNED) + 1 = 2
CONVERT	Convierte una string de caracteres de un conjunto de caracteres en otro: CONVERT ( 'Ä Ê Í Õ Ø A B C D E ', 'US7ASCII', 'WE8ISO8859P1') = ?? ?? ?? A B C	Parcialmente	CONVERT	La función CONVERT de Cloud SQL para MySQL requiere algunos ajustes en la sintaxis y los parámetros: CONVERT( 'Ä Ê Í A B C ' USING utf8) = Ä Ê Í A B C
TO_CHAR (string/numérico)	La función convierte un número o una fecha en una string: TO_CHAR(22.73,'$99.9') = $22.7	No	FORMAT	La función FORMAT de Cloud SQL para MySQL convierte un número en un formato como #,###,###.##, lo redondea a un decimal y, luego, muestra el resultado como una string: CONCAT('$', FORMAT(22.73, 1)) = $22.7
TO_DATE	La función TO_DATE de Oracle convierte una string en una fecha basada en un formato 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 de Cloud SQL para MySQL toma una string y muestra 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	Usa la función CAST de Cloud SQL para MySQL a fin de mostrar el mismo resultado que la función TO_NUMBER de Oracle: CAST('01234' as SIGNED) = 1234

En la siguiente tabla, se describe en qué casos las funciones condicionales SELECT de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y en cuáles se recomienda una conversión.

Función de Oracle	Implementación de Oracle	Equivalente de Cloud SQL para MySQL	Función de Cloud SQL para MySQL	Implementación de Cloud SQL para MySQL
CASE	La declaración CASE elige 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 control condicional IF/ELSE dentro de la declaración SELECT: CASE WHEN condition THEN result [WHEN ...] [ELSE result] END

En la siguiente tabla, se describe en qué casos las funciones nulas de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y en cuáles se recomienda una conversión.

Función de Oracle	Implementación de Oracle	Equivalente de Cloud SQL para MySQL	Función de Cloud SQL para MySQL	Implementación de Cloud SQL para MySQL
COALESCE	Muestra la primera expresión que no es 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 muestra null. Si no son iguales, la función muestra expression1: NULLIF('1', '2') = a	Sí	NULLIF	NULLIF('1', '2') = a
NVL	Reemplaza un valor null con una string en los resultados de una consulta: NVL(null, 'a') = a	No	IFNULL	IFNULL(null, 'a') = a
NVL2	Determina el valor que muestra 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 una declaración correspondiente: CASE WHEN condition THEN result [WHEN ...] [ELSE result] END

En la siguiente tabla, se describe en qué casos las funciones de identificador y entorno de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y en cuáles se recomienda una conversión.

Función de Oracle	Implementación de Oracle	Equivalente de Cloud SQL para MySQL	Función de Cloud SQL para MySQL	Implementación de Cloud SQL para MySQL
SYS_GUID	Genera y muestra un identificador único global (valor RAW) compuesto por 16 bytes: SELECT SYS_GUID() FROM DUAL = 8EFA4A31468B4C6DE05011AC0200009E	No	REPLACE y UUID	Como solución alternativa, usa las funciones REPLACE y UUID para simular la función SYS_GUID: REPLACE( UUID(), '-', '')
UID	Muestra un número entero que identifica de forma exclusiva al usuario de la sesión (el usuario que inició sesión): SELECT UID FROM DUAL = 43	No	N/A	N/A
USER	Muestra 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 de Cloud SQL para MySQL muestra el nombre de usuario y el nombre de host (root@IP_ADDRESS) de la conexión. Para recuperar solo el nombre de usuario, usa las funciones complementarias adicionales: SELECT SUBSTR(USER(), 1, INSTR(USER(), '@') -1) FROM DUAL = root
USERENV	Muestra 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 muestra la configuración de 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 de 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 usas una versión anterior, emula la misma funcionalidad con una variable de sesión @row_number.
ROWNUM	Muestra un número que representa el orden en que una tabla de Oracle muestra una fila.	Parcialmente	N/A	ROW_NUMBER() está disponible a partir de MySQL 8.0. Si usas una versión anterior, emula la misma funcionalidad con una variable de sesión @row_number.

En la siguiente tabla, se describe en qué casos las funciones agregadas (grupo) de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y en cuáles se recomienda una conversión.

Función de Oracle	Implementación de Oracle	Equivalente de Cloud SQL para MySQL	Función de Cloud SQL para MySQL	Implementación de Cloud SQL para MySQL
AVG	Muestra el valor promedio de una columna o expresión.	Sí	AVG	Equivalente a Oracle
COUNT	Muestra la cantidad de filas que muestra una consulta.	Sí	COUNT	Equivalente a Oracle
COUNT (DISTINCT)	Muestra el número de valores únicos en la columna o expresión.	Sí	COUNT (DISTINCT)	Equivalente a Oracle
MAX	Muestra el valor máximo de una columna o expresión.	Sí	MAX	Equivalente a Oracle
MIN	Muestra el valor mínimo de una columna o expresión.	Sí	MIN	Equivalente a Oracle
SUM	Muestra la suma de un valor de una columna o expresión.	Sí	SUM	Equivalente a Oracle
LISTAGG	Ordena los datos dentro de cada grupo especificado en la cláusula ORDER BY y concatena los valores de la columna de medición: SELECT LISTAGG( DEPARTMENT_NAME, ', ') WITHIN GROUP (ORDER BY DEPARTMENT_NAME) DEPT FROM DEPARTMENTS; -- Single line results = Accounting, Administration, Benefits, Construction	Requiere un nombre y una sintaxis de función diferentes	GROUP_ CONCAT	Usa la función GROUP_CONCAT de Cloud SQL para MySQL a fin de mostrar resultados equivalentes: SELECT GROUP_CONCAT( DEPARTMENT_NAME ORDER BY DEPARTMENT_NAME SEPARATOR ', ') DEPT FROM DEPARTMENTS; -- Single line results = Accounting, Administration, Benefits, Construction

En la siguiente tabla, se describe en qué casos la función FETCH de Oracle y Cloud SQL para MySQL es equivalente por nombre y funcionalidad.

Función de Oracle	Implementación de Oracle	Equivalente de Cloud SQL para MySQL	Función de Cloud SQL para MySQL	Implementación de Cloud SQL para MySQL
FETCH	Recupera una cantidad específica de filas del conjunto de resultados de una consulta de varias filas: SELECT * FROM EMPLOYEES FETCH FIRST 10 ROWS ONLY;	Sí	LIMIT	Usa la cláusula LIMIT de MySQL para recuperar filas de una consulta: SELECT * FROM EMPLOYEES LIMIT 10;

Filtrado básico, operadores y subconsultas

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

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

Para configurar los formatos de fecha y hora, usa las funciones DATE_FORMAT o STR_TO_DATE de MySQL.

En la siguiente tabla, se describe en qué casos funciones de subconsulta, operadores y filtros básicas de Oracle y Cloud SQL para MySQL son equivalentes por nombre y funcionalidad, y en cuáles se recomienda una conversión.

Función de Oracle	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: > | >= | < | <= | = | <> | !=

Prácticas recomendadas para las consultas de Cloud SQL para MySQL

A fin de mantener niveles de rendimiento comparables entre Cloud SQL para MySQL y Oracle, es posible que tengas que optimizar tus consultas. Estas optimizaciones incluyen cambiar las estructuras de índice y ajustar el esquema de la base de datos. En esta sección, se proporcionan algunos lineamientos para ayudarte a lograr un rendimiento de consultas similar en Cloud SQL para MySQL.

Crea un índice agrupado

Cuando se usa el motor de almacenamiento InnoDB, una práctica recomendada es definir una tabla con una clave primaria, ya que esta clave crea un índice agrupado en la tabla. Además de mejorar el rendimiento de las consultas, este enfoque también te 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 del DML. Esta práctica recomendada lleva a una segunda: supervisar regularmente los índices redundantes y, en caso de tener alguno, descartarlos de la base de datos.

Usa la siguiente consulta con el fin de identificar tablas sin claves primarias a fin de poder crear claves primarias 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';

Usa la siguiente consulta a fin de buscar tablas que no tengan índices con el objetivo de 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';

Usa la siguiente consulta para verificar los índices redundantes a fin de quitar las redundancias:

mysql> SELECT * FROM sys.schema_redundant_indexes;

Ajusta los parámetros de búsqueda

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

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

Supervisa las consultas

Las consultas de ejecución lenta pueden hacer que el sistema deje de responder o que generen otros cuellos de botella, por lo que es importante supervisar las consultas con frecuencia.

Existen varias formas de diagnosticar las instrucciones de SQL de ejecución lenta:

• Usa el panel de Cloud SQL para MySQL a fin de obtener estadísticas históricas y en tiempo real de las consultas de ejecución lenta.
• Usa Cloud Monitoring a fin de supervisar el registro lento de consultas de Cloud SQL para MySQL.

• Usa la vista statement_analysis de Cloud SQL para MySQL a fin de ver las estadísticas de tiempo de ejecución de una instrucción de SQL:

  mysql> SELECT * FROM sys.statement_analysis;
  

Analiza consultas de Cloud SQL para MySQL

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

• Los planes de ejecución no son objetos de base de datos que se deban migrar, sino una herramienta para analizar las diferencias de rendimiento entre Oracle y Cloud SQL para MySQL que ejecuta 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 uno 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  |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+

Optimiza los activadores y los procedimientos almacenados

A diferencia de Oracle, las funciones y los procedimientos almacenados de Cloud SQL para MySQL se analizan en cada ejecución. Una herramienta útil para realizar comparativas del procedimiento almacenado y del rendimiento de la función es la utilidad BENCHMARK() de MySQL. Esta herramienta toma dos parámetros, un recuento de iteraciones y una expresión, y calcula el tiempo de ejecución de la expresión determinada (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 observas una regresión de rendimiento durante la conversión, usa 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 una estructura de índice de tabla a fin de que se adapte al optimizador de MySQL. Otra práctica común es optimizar un código PL/SQL convertido mediante la reducción de la recuperación de datos innecesarios o mediante el uso de tablas temporales dentro del código de procedimiento de MySQL.

¿Qué sigue?

• Explora más acerca de las cuentas de usuario de MySQL.
• Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.