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 |
SELECTFROMWHEREGROUP BYHAVINGORDER BY
|
Sí |
SELECTFROMWHEREGROUP BYHAVINGORDER BY
|
SELECT para la impresión de salida |
SELECT 1 FROM DUAL
|
Sí |
SELECT 1o SELECT 1 FROM DUAL
|
| Alias de columna | SELECT COL1 AS C1
|
Sí |
SELECT COL1 AS C1o 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.
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:
UNIONadjunta los conjuntos de resultados de dos declaracionesSELECTdespués de eliminar los registros duplicados.UNION ALLadjunta los conjuntos de resultados de dos declaracionesSELECTsin eliminar los registros duplicados.INTERSECTmuestra la intersección de dos declaracionesSELECT, solo si existe un registro en los conjuntos de resultados de ambas consultas.MINUScompara dos o más declaracionesSELECTy solo muestra filas distintas de la primera consulta que no son mostradas por la segunda.
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 TBL1UNIONSELECT COL1 FROM TBL2
|
Sí | SELECT COL1 FROM TBL1UNIONSELECT COL1 FROM TBL2
|
UNION ALL |
SELECT COL1 FROM TBL1UNION ALLSELECT COL1 FROM TBL2
|
Sí | SELECT COL1 FROM TBL1UNION ALLSELECT COL1 FROM TBL2
|
INTERSECT |
SELECT COL1 FROM TBL1INTERSECTSELECT COL1 FROM TBL2
|
No |
SELECT COL1 FROM TBL1WHERE COL1 IN(SELECT COL1 FROM TBL2)
|
MINUS |
SELECT COL1 FROM TBL1MINUSSELECT 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() |
SELECT SYSDATE()
FROM DUAL;
= 2019-01-31 10:01:01.0
Puedes cambiar el formato |
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í | 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
SYSDATEde 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 para 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_analysisde 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.