Migración de aplicaciones de bases de datos MySQL a una base de datos de IA autónoma

Puede migrar sentencias SQL de MySQL a Oracle SQL y ejecutar las sentencias en Autonomous AI Database.

Traducir sentencias MySQL a Oracle SQL

Puede convertir sentencias SQL escritas en MySQL en Oracle SQL y ejecutar las sentencias traducidas en Autonomous AI Database.

Utilice DBMS_CLOUD_MIGRATION.MIGRATE_SQL para traducir una sentencia MySQL a Oracle SQL. Hay variantes de procedimiento y función de DBMS_CLOUD_MIGRATION.MIGRATE_SQL.

Migración de la sentencia MySQL a Oracle SQL con el procedimiento MIGRATE_SQL

En el siguiente ejemplo se acepta la sentencia SQL escrita en MySQL como entrada, se convierte la sentencia en Oracle SQL, se asigna la sentencia SQL traducida a output_sql_result y se imprime el resultado:

SET SERVEROUTPUT ON
   declare output_sql_result CLOB;
BEGIN
  DBMS_CLOUD_MIGRATION.MIGRATE_SQL(
    original_sql => 'CREATE TABLE movie (movie_id INT, title VARCHAR(255));',
    output_sql   => output_sql_result,
    source_db    => 'MYSQL');
    DBMS_OUTPUT.PUT_LINE (output_sql_result);
END;
/

OUTPUT
--------------------------------------------------------------
CREATE TABLE movie (movie_id NUMBER(10), title VARCHAR2(255));

El parámetro original_sql especifica la sentencia MySQL.

El parámetro output_sql almacena el SQL traducido.

El parámetro source_db especifica MySQL como nombre de base de datos.

Consulte Procedimiento y función MIGRATE_SQL para obtener más información.

Migrar la sentencia MySQL a Oracle SQL con la función MIGRATE_SQL

El siguiente ejemplo muestra la función DBMS_CLOUD_MIGRATION.MIGRATE_SQL dentro de una sentencia SELECT. La entrada de la función es una sentencia MySQL y la función devuelve la sentencia traducida en Oracle SQL:

SELECT DBMS_CLOUD_MIGRATION.MIGRATE_SQL(
     'CREATE TABLE movie (film_id INT, title VARCHAR(255));','MYSQL') AS output FROM DUAL;

OUTPUT
------------------------------------------------------------------------------
create table cars (brand VARCHAR2(255), model VARCHAR2(255);

Consulte Procedimiento y función MIGRATE_SQL para obtener más información.

Notas para ejecutar DBMS_CLOUD_MIGRATION.MIGRATE_SQL:

Puede que se produzca un error durante la traducción si la sentencia SQL de entrada no está soportada en Oracle SQL. Consulte Limitaciones para la migración y la traducción de sentencias MySQL a Oracle SQL para obtener más información.
Los subprogramas DBMS_CLOUD_MIGRATION.MIGRATE_SQL solo aceptan una sentencia SQL como entrada. Por lo tanto, solo se puede convertir una sola sentencia SQL por llamada.

Ejecutar sentencias MySQL en una base de datos de IA autónoma

Puede traducir y ejecutar de forma interactiva sentencias MySQL en su base de datos de IA autónoma.

Utilice el procedimiento ENABLE_TRANSLATION para activar la traducción en tiempo real de sentencias SQL escritas en MySQL. Después de activar la traducción en una sesión, las sentencias MySQL se traducen y ejecutan automáticamente como sentencias SQL de Oracle, y puede ver los resultados.

Por ejemplo, después de activar la traducción ejecutando ENABLE_TRANSLATION, puede realizar de forma interactiva lo siguiente en una sesión:

Cree las tablas. Por ejemplo, cree las tablas MOVIE y INVENTORY.
Insertar datos en tablas.
Tablas de consultas.
Realizar operaciones JOIN en tablas. Por ejemplo, puede realizar una unión externa izquierda en las tablas.

Para activar la traducción con MySQL y ejecutar comandos:

Conéctese a su base de datos de IA autónoma mediante un cliente SQL.

Consulte Conexión a una base de datos de IA autónoma para obtener más información.

Nota

Nota: DBMS_CLOUD_MIGRATION.ENABLE_TRANSLATION no está soportado en Database Actions y no lo está con el servicio de Oracle APEX.
Ejecute DBMS_CLOUD_MIGRATION.ENABLE_TRANSLATION para activar la traducción SQL en tiempo real en la sesión. Utilice el parámetro MYSQL para traducir desde MySQL.
```
BEGIN
 DBMS_CLOUD_MIGRATION.ENABLE_TRANSLATION('MYSQL');
END;
/
```
Utilice la siguiente consulta para verificar el lenguaje de traducción SQL de la sesión:
```
SELECT SYS_CONTEXT('USERENV','SQL_TRANSLATION_PROFILE_NAME') FROM DUAL;
```
Consulte el procedimiento ENABLE_TRANSLATION para obtener más información.
Introduzca las sentencias MySQL. Por ejemplo:
```
CREATE TABLE movie (film_id int, title varchar(255));

Table MOVIE created.
```
Esto traduce y ejecuta automáticamente la sentencia CREATE TABLE de MySQL.

Puede verificar mediante el comando DESC. Por ejemplo:
```
DESC movie;

Name        Null?     Type

-------     -----     -------------
FILM_ID               NUMBER(38)

TITLE                 VARCHAR2(255)
```
Se crea la tabla MOVIE y los tipos de dato de cada una de las columnas se convierten automáticamente en tipos de dato de Oracle.

Puede que se produzca un error durante la traducción si la sentencia SQL de entrada no está soportada. Consulte Limitaciones para la migración y la traducción de sentencias MySQL a Oracle SQL para obtener más información.

Inserte datos en la tabla MOVIE. Por ejemplo:

INSERT INTO movie (film_id, title) VALUES (123, 'Tangled');

1 row inserted.

INSERT INTO movie (film_id, title) VALUES (234, 'Frozen');

1 row inserted.

Verifique la inserción de datos consultando la tabla MOVIE. Por ejemplo:

SELECT * FROM movie;

FILM_ID  TITLE
-------- ---------
123  Tangled
234  Frozen

Cree una tabla INVENTORY:

CREATE TABLE inventory (film_id int, inventory_id int);

Table INVENTORY created.

Puede verificar este paso con el comando DESC. Por ejemplo:

DESC inventory;

Name        Null?     Type

-------     -----     -------------
FILM_ID               NUMBER(38)

INVENTORY_ID          NUMBER(38)

Se crea la tabla INVENTORY y los tipos de dato de cada una de las columnas se convierten automáticamente en tipos de dato de Oracle.

Inserte datos en la tabla INVENTORY. Por ejemplo:

INSERT INTO inventory(film_id, inventory_id) VALUES (123, 223);

1 row inserted.

INSERT INTO inventory(film_id, inventory_id) VALUES (234, 334);

1 row inserted.

Verifique la inserción de datos consultando INVENTORY. Por ejemplo:

SELECT * FROM inventory;

FILM_ID  INVENTORY_ID
-------- -------------
123  223
234  334

Realice una unión externa izquierda en las tablas MOVIE y INVENTORY:
```
SELECT m.film_id, m.title, inventory_id
    FROM movie AS m LEFT JOIN inventory
    ON inventory.film_id = m.film_id;

  FILM_ID  TITLE       INVENTORY_ID

---------- ---------- ------------
       234 Frozen      334
       123 Tangled     223
```
En este ejemplo se realiza una operación LEFT OUTER JOIN en las tablas movie y inventory. La palabra clave AS para los alias de tabla de la cláusula FROM no está soportada en Oracle SQL. La consulta se traduce primero a Oracle SQL y, a continuación, se ejecuta en la sesión.
Utilice el procedimiento DBMS_CLOUD_MIGRATION.DISABLE_TRANSLATION para desactivar la traducción de lenguaje SQL en tiempo real para la sesión.
```
BEGIN
 DBMS_CLOUD_MIGRATION.DISABLE_TRANSLATION;
END;
/
```
Esto devuelve un error si la traducción del lenguaje SQL no está activada para la sesión.

Consulte DISABLE_TRANSLATION Procedure.

Puede consultar la vista V$MAPPED_SQL para mostrar las sentencias MySQL que se traducen y asignan en memoria a las sentencias SQL de Oracle.

Por ejemplo:

SELECT v.*
    FROM v$mapped_sql v, dba_objects o
    WHERE v.sql_translation_profile_id = o.object_id
        AND o.object_name = 'MYSQL'
        AND o.object_type = 'TRANSLATION PROFILE';

Consulte V$MAPPED_SQL para obtener más información.

Migración de archivos MySQL a Oracle SQL

Puede migrar un archivo que contenga sentencias MySQL a un archivo que contenga sentencias SQL de Oracle.

El procedimiento DBMS_CLOUD_MIGRATION.MIGRATE_FILE traduce sentencias SQL en un archivo MySQL en Object Storage y genera un nuevo archivo que contiene Oracle SQL.

Como requisito, cargue uno o más archivos de MySQL con una extensión .sql en una ubicación de Object Storage. En los siguientes ejemplos se utiliza el archivo mysqltest.sql que se carga en Object Storage. Consulte Poner datos en Object Storage para obtener más información.

Para migrar archivos MySQL a Oracle SQL:

Conéctese a su instancia de base de datos de IA autónoma.

Consulte Conexión a una base de datos de IA autónoma para obtener más información.
Configure el acceso a Cloud Object Storage mediante una entidad de recurso o mediante la creación de un objeto de credencial.

En este paso se proporciona acceso al almacenamiento de objetos en la nube, donde puede colocar los archivos que está migrando:
- Utilice una entidad de recurso para acceder a Cloud Object Storage:
  
  Defina políticas y roles para acceder a Oracle Cloud Infrastructure Object Storage con una entidad de recurso. Consulte Uso de la entidad de recurso para acceder a los recursos de Oracle Cloud Infrastructure y Uso de la entidad de recurso con DBMS_CLOUD para obtener más información.
  
  Si los archivos residen en el almacenamiento de objetos en la nube de otro proveedor, defina las políticas y los roles adecuados para acceder al recurso. Consulte Configuración de políticas y roles para acceder a recursos para obtener más información.
- Cree una credencial para acceder a Cloud Object Storage:
  
  Puede crear una credencial para acceder a Cloud Object Storage.
  
  Por ejemplo:
```
BEGIN
DBMS_CLOUD.CREATE_CREDENTIAL (
credential_name => 'OBJ_STORE_CRED',
username        => 'user1@example.com',
password        => 'password'
);
END;
/
```
  Consulte Procedimiento CREATE_CREDENTIAL para obtener más información.
También puede mostrar los archivos en Object Storage. Por ejemplo:
```
VAR function_list CLOB;
SELECT object_name FROM DBMS_CLOUD.LIST_OBJECTS
  (credential_name => 'OCI$RESOURCE_PRINCIPAL', location_uri => 'https://objectstorage.region.oraclecloud.com/n/namespace/b/bucket/o/files');

OBJECT_NAME

---------------------
mysqltest.sql
```
También, si crea una credencial en lugar de la entidad de recurso, OCI$RESOURCE_PRINCIPAL, especifique el nombre de credencial en el parámetro credential_name.

Consulte Función LIST_OBJECTS para obtener más información.
Ejecute DBMS_CLOUD_MIGRATION.MIGRATE_FILE para migrar el archivo MySQL a Oracle SQL:
```
BEGIN
DBMS_CLOUD_MIGRATION.MIGRATE_FILE (
   credential_name => 'OCI$RESOURCE_PRINCIPAL',
   location_uri    => 'https://objectstorage.region.oraclecloud.com/n/namespace/b/bucket/o/files/mysqltest.sql',
   source_db       => 'MYSQL'
  );
END;
/
```
El parámetro credential_name especifica la credencial para acceder al URI de Cloud Object Storage. El usuario que ejecuta DBMS_CLOUD_MIGRATION.MIGRATE_FILE debe tener el privilegio EXECUTE para el objeto de credencial utilizado para acceder al URI de Object Storage. Es decir, la credencial que especifique con el parámetro credential_name. Si utiliza una credencial en lugar de una entidad de recurso, especifique el nombre de la credencial en el parámetro credential_name.

El parámetro location_uri especifica el URI del archivo de origen. El formato del URI depende del servicio Cloud Object Storage que utilice. Consulte Formatos de URI de DBMS_CLOUD para obtener más información.

El parámetro source_db especifica MySQL como lenguaje de base de datos. Utilice el valor MYSQL para convertir archivos MySQL en Oracle SQL.

La ejecución de este comando convierte el archivo MySQL mysqltest.sql en Oracle SQL y genera un nuevo archivo con el nombre original_filename_oracle.sql.

Para este ejemplo, al ejecutar DBMS_CLOUD_MIGRATION.MIGRATE_FILE con el archivo de entrada mysqltest.sql se genera mysqltest_oracle.sql. Después del paso de traducción, el procedimiento carga mysqltest_oracle.sql en Object Storage.

Opcionalmente, utilice el parámetro target_uri para especificar la ubicación en la que se carga el archivo traducido. El valor por defecto de este parámetro es NULL, lo que significa que el archivo traducido se carga en la misma ubicación que se especifica en el parámetro location_uri.

Consulte Procedimiento MIGRATE_FILE para obtener más información.
Verifique que se haya generado el archivo de salida.
```
SELECT object_name FROM DBMS_CLOUD.LIST_OBJECTS (
    credential_name => 'OCI$RESOURCE_PRINCIPAL', location_uri => 'https://objectstorage.region.oraclecloud.com/n/namespace/b/bucket/o/files');

OBJECT_NAME

---------------------
mysqltest.sql
mysqltest_oracle.sql
```
También, si crea una credencial en lugar de la entidad de recurso, OCI$RESOURCE_PRINCIPAL, especifique el nombre de credencial en el parámetro credential_name.

Consulte Función LIST_OBJECTS para obtener más información.

Ejecute la siguiente consulta para ver el contenido del archivo mysqltest_oracle.sql:

SELECT UTL_RAW.CAST_TO_VARCHAR2 (DBMS_CLOUD.GET_OBJECT(
  credential_name => 'OCI$RESOURCE_PRINCIPAL',
  object_uri => 'https://objectstorage.region.oraclecloud.com/n/namespace/b/bucket/o/files'))
FROM dual;

UTL_RAW.CAST_TO_VARCHAR2(DBMS_CLOUD.GET_OBJECT(CREDENTIAL_NAME=>'CRED1',OBJECT_U
--------------------------------------------------------------------------------
DROP TABLE movie;
DROP TABLE inventory;
CREATE TABLE movie (film_id NUMBER(10), title VARCHAR2(255));
INSERT INTO movie (film_id, title) VALUES (123, 'Tangled');
INSERT INTO movie (film_id, title) VALUES (234, 'Frozen');
CREATE TABLE movie (film_id NUMBER(10), inventory_id NUMBER(10));
INSERT INTO movie (film_id, inventory_id) VALUES (123, 223);
INSERT INTO inventory (film_id, inventory_id) VALUES (234, 334);
SELECT * FROM movie;

También, si crea una credencial en lugar de la entidad de recurso, OCI$RESOURCE_PRINCIPAL, especifique el nombre de credencial en el parámetro credential_name.

Consulte Función y procedimiento GET_OBJECT para obtener más información.

Limitaciones para la Migración y Traducción de Sentencias MySQL a SQL de Oracle

En esta sección se resumen las limitaciones de la migración de sentencias SQL de MySQL a Oracle SQL.

Tenga en cuenta las siguientes restricciones al migrar del tipo de base de datos MySQL a Oracle SQL:

Variables globales definidas por el usuario: las variables globales definidas por el usuario de MySQL declaradas con formato @var_name no están soportadas al realizar la conversión a Oracle SQL.
Identificadores entre comillas: los identificadores de MySQL que se incluyen con backticks (`), como var_name, no están soportados al traducir a Oracle SQL. Solo están soportados los identificadores que no tienen comillas o que están entre comillas dobles.
Delimitadores:
- Para funciones y procedimientos, solo se admiten los delimitadores $$ y //.
- Para las sentencias SQL solo está soportado el delimitador ;.

La siguiente lista de funciones MySQL no está soportada:

ADDTIME(datetime, time)
AES_DECRYPT(crypt_str, key_str)
AES_ENCRYPT(str, key_str)
BIN(num)
CONV(num, from_base, to_base)
CONVERT_TZ(datetime, from, to)
CRC32(exp)
DATE_ADD(date, interval)