Migration d'applications à partir de bases de données PostgreSQL vers une base de données d'IA autonome

Vous pouvez migrer des instructions SQL de PostgreSQL vers Oracle SQL et les exécuter sur la base de données Autonomous AI.

Convertir des instructions PostgreSQL en instructions SQL Oracle

Vous pouvez traduire les instructions SQL écrites dans PostgreSQL en instructions Oracle SQL et les exécuter sur Autonomous AI Database.

Utilisez DBMS_CLOUD_MIGRATION.MIGRATE_SQL pour convertir l'instruction PostgreSQL en instruction Oracle SQL. Il existe des variantes de procédure et de fonction de DBMS_CLOUD_MIGRATION.MIGRATE_SQL.

Migrer l'instruction PostgreSQL vers Oracle SQL avec la procédure MIGRATE_SQL

L'exemple suivant accepte l'instruction SQL écrite en entrée dans PostgreSQL, traduit l'instruction en code SQL Oracle, affecte l'instruction SQL traduite à output_sql_result et imprime le résultat :

SET SERVEROUTPUT ON
   declare output_sql_result CLOB;
BEGIN
  DBMS_CLOUD_MIGRATION.MIGRATE_SQL(
    original_sql => 'SELECT e.employee_id, e.last_name, e.salary FROM employees AS e;',
    output_sql   => output_sql_result,
    source_db    => 'POSTGRES');
    DBMS_OUTPUT.PUT_LINE (output_sql_result);
END;
/

Output
--------------------------------------------------------------
SELECT e.employee_id, e.last_name, e.salary FROM employees e;

Le paramètre original_sql indique l'instruction PostgreSQL.

Le paramètre output_sql stocke l'instruction SQL traduite.

Le paramètre source_db indique le nom de la base de données PostgreSQL.

Pour plus d'informations, voir Procédure et fonction MIGRATE_SQL.

Migrer l'instruction PostgreSQL vers Oracle SQL avec la fonction MIGRATE_SQL

L'exemple suivant illustre la fonction DBMS_CLOUD_MIGRATION.MIGRATE_SQL dans une instruction SELECT. L'entrée de fonction est une instruction PostgreSQL et la fonction renvoie l'instruction traduite dans Oracle SQL :

SELECT DBMS_CLOUD_MIGRATION.MIGRATE_SQL(
     'CREATE TABLE IF NOT EXISTS cars (brand VARCHAR(255), model VARCHAR(255), year INT)',
     'POSTGRES') AS output FROM DUAL;

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

Pour plus d'informations, voir Procédure et fonction MIGRATE_SQL.

Remarques concernant l'exécution de DBMS_CLOUD_MIGRATION.MIGRATE_SQL :

Une erreur peut survenir lors de la conversion si l'instruction SQL d'entrée n'est pas prise en charge dans Oracle SQL. Pour plus d'informations, reportez-vous à Limites relatives à la migration et à la traduction des instructions PostgreSQL vers Oracle SQL.
Les sous-programmes DBMS_CLOUD_MIGRATION.MIGRATE_SQL acceptent une seule instruction SQL en tant qu'entrée. Par conséquent, une seule instruction SQL peut être traduite par appel.

Exécution d'instructions PostgreSQL dans une base de données Autonomous AI

Vous pouvez traduire et exécuter des instructions PostgreSQL de manière interactive dans votre base de données Autonomous AI.

Utilisez la procédure ENABLE_TRANSLATION pour activer la traduction en temps réel des instructions SQL écrites dans PostgreSQL. Une fois la traduction activée dans une session, les instructions PostgreSQL sont automatiquement traduites et exécutées en tant qu'instructions Oracle SQL, et vous pouvez voir les résultats.

Par exemple, après avoir activé la traduction en exécutant ENABLE_TRANSLATION, vous pouvez effectuer les opérations suivantes de manière interactive dans une session :

Créez les tables. Par exemple, créez les tables MOVIE et INVENTORY.
Insérer des données dans des tables.
Tables de requête.
Effectuez des opérations JOIN sur les tables. Par exemple, vous pouvez effectuer une jointure externe gauche sur les tables.

Pour activer la traduction à l'aide de PostgreSQL et exécuter des commandes, procédez comme suit :

Connectez-vous à votre base de données Autonomous AI à l'aide d'un client SQL.

Pour plus d'informations, reportez-vous à Connexion à Autonomous AI Database.

Remarque

Remarque : DBMS_CLOUD_MIGRATION.ENABLE_TRANSLATION n'est pas pris en charge dans Database Actions et n'est pas pris en charge avec le service Oracle APEX.
Exécutez DBMS_CLOUD_MIGRATION.ENABLE_TRANSLATION pour activer la conversion SQL en temps réel dans votre session.
```
BEGIN
 DBMS_CLOUD_MIGRATION.ENABLE_TRANSLATION('POSTGRES');
END;
/
```
Utilisez la requête suivante pour vérifier le langage de traduction SQL de votre session :
```
SELECT SYS_CONTEXT('USERENV','SQL_TRANSLATION_PROFILE_NAME') FROM DUAL;
```
Pour plus d'informations, voir Procédure ENABLE_TRANSLATION.
Entrez des instructions PostgreSQL. Par exemple :
```
CREATE TABLE movie (film_id int, title varchar(255));

Table MOVIE created.
```
Cela traduit et exécute automatiquement l'instruction PostgreSQL CREATE TABLE.

Vous pouvez effectuer la vérification à l'aide de la commande DESC. Par exemple :
```
DESC movie;

Name        Null?     Type

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

TITLE                 VARCHAR2(255)
```
La table MOVIE est créée et les types de données de chacune des colonnes sont automatiquement convertis en types de données Oracle.

Une erreur peut survenir lors de la conversion si l'instruction SQL d'entrée n'est pas prise en charge. Pour plus d'informations, reportez-vous à Limites relatives à la migration et à la traduction des instructions PostgreSQL vers Oracle SQL.

Insérez des données dans la table MOVIE. Par exemple :

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

1 row inserted.

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

1 row inserted.

Vérifiez l'insertion des données en interrogeant la table MOVIE. Par exemple :

SELECT * FROM movie;

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

Créez une table INVENTORY :
```
CREATE TABLE inventory (film_id int, inventory_id int);

Table INVENTORY created.
```
Vous pouvez vérifier cette étape à l'aide de la commande DESC. Par exemple :
```
DESC inventory;

Name        Null?     Type

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

INVENTORY_ID          NUMBER(38)
```
La table INVENTORY est créée et les types de données de chacune des colonnes sont automatiquement convertis en types de données Oracle.

Insérez des données dans la table INVENTORY. Par exemple :

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.

Vérifiez l'insertion des données en interrogeant INVENTORY. Par exemple :

SELECT * FROM inventory;

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

Effectuez une jointure externe gauche sur les tables MOVIE et INVENTORY :
```
SELECT m.film_id, m.title, inventory.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
```
Cet exemple effectue une opération LEFT OUTER JOIN sur les tables movie et inventory. Le mot-clé AS pour les alias de table dans la clause FROM n'est pas pris en charge dans Oracle SQL. La requête est d'abord convertie en code SQL Oracle, puis exécutée dans votre session.
Utilisez la procédure DBMS_CLOUD_MIGRATION.DISABLE_TRANSLATION pour désactiver la traduction SQL en temps réel pour votre session.
```
BEGIN
 DBMS_CLOUD_MIGRATION.DISABLE_TRANSLATION;
END;
/
```
Une erreur est renvoyée si la traduction SQL n'est pas activée pour votre session.

Voir Procédure DISABLE_TRANSLATION

Vous pouvez interroger la vue V$MAPPED_SQL pour répertorier les instructions PostgreSQL qui sont traduites et mises en correspondance en mémoire avec des instructions SQL Oracle.

Par exemple :

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

Pour plus d'informations, reportez-vous à V$MAPPED_SQL.

Migrer les fichiers PostgreSQL vers Oracle SQL

Vous pouvez migrer un fichier contenant des instructions PostgreSQL vers un fichier contenant des instructions SQL Oracle.

La procédure DBMS_CLOUD_MIGRATION.MIGRATE_FILE traduit les instructions SQL dans un fichier PostgreSQL dans Object Storage et génère un nouveau fichier contenant Oracle SQL.

Vous devez au préalable télécharger des fichiers PostgreSQL portant l'extension .sql vers un emplacement sur Object Storage. Les exemples suivants utilisent le fichier postgrestest.sql téléchargé vers Object Storage. Pour plus d'informations, reportez-vous à Mettre des données dans le stockage d'objets.

Pour migrer des fichiers PostgreSQL vers Oracle SQL, procédez comme suit :

Connectez-vous à votre instance Autonomous AI Database.

Pour plus d'informations, reportez-vous à Connexion à Autonomous AI Database.
Configurez l'accès à Cloud Object Storage à l'aide d'un principal de ressource ou en créant un objet d'informations d'identification.

Cette étape permet d'accéder au stockage d'objets cloud dans lequel vous placez les fichiers que vous migrez :
- Utilisez un principal de ressource pour accéder à Cloud Object Storage :
  
  Définir des stratégies et des rôles pour accéder à Oracle Cloud Infrastructure Object Storage avec un principal de ressource. Pour plus d'informations, reportez-vous à Utilisation du principal de ressource pour accéder aux ressources Oracle Cloud Infrastructure et à Utilisation du principal de ressource avec DBMS_CLOUD.
  
  Si vos fichiers résident dans le stockage d'objets cloud d'un autre fournisseur, définissez les stratégies et les rôles appropriés pour accéder à la ressource. Pour plus d'informations, reportez-vous à Configuration de stratégies et de rôles pour accéder aux ressources.
- Créez des informations d'identification pour accéder au stockage d'objet cloud :
  
  Vous pouvez créer des informations d'identification pour accéder à Cloud Object Storage.
  
  Par exemple :
```
BEGIN
DBMS_CLOUD.CREATE_CREDENTIAL (
credential_name => 'OBJ_STORE_CRED',
username        => 'user1@example.com',
password        => 'password'
);
END;
/
```
  Pour plus d'informations, reportez-vous à Procédure CREATE_CREDENTIAL.
Vous pouvez éventuellement répertorier les fichiers dans Object Storage. Par exemple :
```
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

---------------------
postgrestest.sql
```
Si vous créez des informations d'identification à la place du principal de ressource, OCI$RESOURCE_PRINCIPAL, indiquez le nom des informations d'identification dans le paramètre credential_name.

Pour plus d'informations, voir Fonction LIST_OBJECTS.
Exécutez DBMS_CLOUD_MIGRATION.MIGRATE_FILE pour migrer le fichier PostgreSQL vers 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/postgrestest.sql',
   source_db       => 'POSTGRES'
  );
END;
/
```
Le paramètre credential_name indique les informations d'identification permettant d'accéder à l'URI de stockage d'objet cloud. L'utilisateur qui exécute DBMS_CLOUD_MIGRATION.MIGRATE_FILE doit disposer du privilège EXECUTE pour l'objet d'informations d'identification utilisé pour accéder à l'URI Object Storage. Autrement dit, informations d'identification que vous indiquez avec le paramètre credential_name. Si vous utilisez des informations d'identification au lieu d'un principal de ressource, indiquez le nom des informations d'identification dans le paramètre credential_name.

Le paramètre location_uri indique l'URI du fichier source. Le format de l'URI dépend du service Cloud Object Storage que vous utilisez. Pour plus d'informations, voir Formats d'URI DBMS_CLOUD.

Le paramètre source_db indique le langage de base de données PostgreSQL. Utilisez la valeur POSTGRES pour convertir les fichiers PostgreSQL en Oracle SQL.

L'exécution de cette commande traduit le fichier PostgreSQL postgrestest.sql en Oracle SQL et génère un nouveau fichier portant le nom original_filename_oracle.sql.

Pour cet exemple, l'exécution de DBMS_CLOUD_MIGRATION.MIGRATE_FILE avec le fichier d'entrée postgrestest.sql génère postgrestest_oracle.sql. Après l'étape de traduction, la procédure télécharge postgrestest_oracle.sql vers Object Storage.

Vous pouvez éventuellement utiliser le paramètre target_uri pour indiquer l'emplacement de téléchargement du fichier traduit. La valeur par défaut de ce paramètre est NULL, ce qui signifie que le fichier traduit est téléchargé vers le même emplacement que celui indiqué dans le paramètre location_uri.

Pour plus d'informations, reportez-vous à Procédure MIGRATE_FILE.
Vérifiez que le fichier de sortie a été généré.
```
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

---------------------
postgrestest.sql
postgrestest_oracle.sql
```
Si vous créez des informations d'identification à la place du principal de ressource, OCI$RESOURCE_PRINCIPAL, indiquez le nom des informations d'identification dans le paramètre credential_name.

Pour plus d'informations, voir Fonction LIST_OBJECTS.

Exécutez la requête suivante pour afficher le contenu du fichier postgrestest_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
--------------------------------------------------------------------------------
SELECT f.film_id, f.title, inventory_id
FROM film f LEFT JOIN inventory
ON inventory.film_id = f.film_id;

Si vous créez des informations d'identification à la place du principal de ressource, OCI$RESOURCE_PRINCIPAL, indiquez le nom des informations d'identification dans le paramètre credential_name.

Pour plus d'informations, voir Procédure et fonction GET_OBJECT.

Limites de migration et de traduction des instructions PostgreSQL vers Oracle SQL

Cette section récapitule les limites de la migration d'instructions SQL de PostgreSQL vers Oracle SQL.

La liste suivante d'instructions PostgreSQL n'est pas prise en charge lors de la migration vers la base de données Autonomous AI :

CREATE DOMAIN
CREATE EXTENSION
CREATE DATABASE
CREATE TYPE
SET

La liste suivante d'instructions PostgreSQL est prise en charge avec des restrictions :

ALTER TABLE : seul ALTER TABLE ADD CONSTRAINT est pris en charge lors de la migration vers la base de données Autonomous AI.
DELETE : le mot-clé RETURNING * dans l'instruction DELETE n'est pas pris en charge dans la base de données Autonomous AI. Vous devez remplacer la clause RETURNING * par la clause RETURNING INTO. Par exemple, DELETE FROM tasks WHERE status = 'DONE' RETURNING *;.

Pour plus d'informations, reportez-vous à Clause RETURNING INTO.
CREATE FUNCTION : les éléments suivants ne sont pas pris en charge avec CREATE FUNCTION :
- Type de retour SETOF. Vous devez remplacer SETOF par des types de retour CURSORS ou COLLECTIONS.
- Clause IMMUTABLE.
- Déclarations de paramètre au format FUNCTION_NAME (DATATYPE, DATATYPE).
ALTER FUNCTION : les arguments de fonction ALTER FUNCTION, par exemple RENAME TO, OWNER TO et SET SCHEMA, ne sont pas pris en charge.