

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Connexion aux bases de données Oracle à l'aide du AWS Schema Conversion Tool
<a name="CHAP_Source.Oracle"></a>

Vous pouvez les utiliser AWS SCT pour convertir des schémas, des objets de code de base de données et du code d'application depuis Oracle Database vers les cibles suivantes : 
+ Amazon RDS for MySQL
+ Amazon Aurora MySQL-Compatible Edition
+ Amazon RDS pour PostgreSQL
+ Amazon Aurora PostgreSQL-Compatible Edition
+ Amazon RDS for Oracle
+ Amazon RDS for MariaDB

Lorsque la source est une base de données Oracle, les commentaires peuvent être convertis au format approprié, par exemple dans une base de données PostgreSQL. AWS SCT peut convertir les commentaires sur les tables, les vues et les colonnes. Les commentaires peuvent inclure des apostrophes ; les apostrophes sont AWS SCT doublées lors de la conversion d'instructions SQL, comme c'est le cas pour les chaînes littérales.

Pour plus d’informations, consultez les rubriques suivantes.

**Topics**
+ [Privilèges pour Oracle en tant que source](#CHAP_Source.Oracle.Permissions)
+ [Connexion à Oracle en tant que source](#CHAP_Source.Oracle.Connecting)
+ [Migration d'Oracle vers Amazon RDS for PostgreSQL ou Amazon Aurora PostgreSQL avec AWS Schema Conversion Tool](CHAP_Source.Oracle.ToPostgreSQL.md)
+ [Migration d'Oracle vers Amazon RDS for MySQL ou Amazon Aurora MySQL avec AWS Schema Conversion Tool](CHAP_Source.Oracle.ToMySQL.md)
+ [Migration d'une base de données Oracle vers Amazon RDS for Oracle avec AWS Schema Conversion Tool](CHAP_Source.Oracle.ToRDSOracle.md)

## Privilèges pour Oracle en tant que source
<a name="CHAP_Source.Oracle.Permissions"></a>

Les privilèges requis pour Oracle en tant que source sont les suivants : 
+ CONNECT 
+ SELECT\$1CATALOG\$1ROLE 
+ SELECT ANY DICTIONARY 
+ SELECT ON SYS.ARGUMENT\$1

## Connexion à Oracle en tant que source
<a name="CHAP_Source.Oracle.Connecting"></a>

Utilisez la procédure suivante pour vous connecter à votre base de données source Oracle avec AWS Schema Conversion Tool. 

**Pour vous connecter à une base de données source Oracle**

1. Dans le AWS Schema Conversion Tool, choisissez **Ajouter une source**. 

1. Choisissez **Oracle**, puis **Next**. 

   La boîte de dialogue **Ajouter une source** apparaît.

1. Dans **Nom de connexion**, entrez le nom de votre base de données. AWS SCT affiche ce nom dans l'arborescence du panneau de gauche. 

1. Utilisez les informations d'identification de la base de données AWS Secrets Manager ou saisissez-les manuellement :
   + Pour utiliser les informations d'identification de base de données issues de Secrets Manager, suivez les instructions suivantes :

     1. Pour **AWS Secret**, choisissez le nom du secret.

     1. Choisissez **Populer pour renseigner** automatiquement toutes les valeurs dans la boîte de dialogue de connexion à la base de données depuis Secrets Manager.

     Pour plus d'informations sur l'utilisation des informations d'identification de base de données depuis Secrets Manager, consultez[Configuration AWS Secrets Manager dans AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
   + Pour saisir manuellement les informations de connexion à la base de données source Oracle, suivez les instructions suivantes :    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/SchemaConversionTool/latest/userguide/CHAP_Source.Oracle.html)

1. Choisissez **Tester la connexion** pour vérifier que AWS SCT vous pouvez vous connecter à votre base de données source. 

1. Choisissez **Connect pour vous** connecter à votre base de données source.

# Migration d'Oracle vers Amazon RDS for PostgreSQL ou Amazon Aurora PostgreSQL avec AWS Schema Conversion Tool
<a name="CHAP_Source.Oracle.ToPostgreSQL"></a>

Lorsque vous convertissez une base de données Oracle en RDS pour PostgreSQL ou Amazon Aurora PostgreSQL, tenez compte des points suivants.

**Topics**
+ [Privilèges pour PostgreSQL en tant que base de données cible](#CHAP_Source.Oracle.ToPostgreSQL.ConfigureTarget)
+ [Paramètres de conversion Oracle vers PostgreSQL](#CHAP_Source.Oracle.ToPostgreSQL.ConversionSettings)
+ [Conversion de séquences Oracle](#CHAP_Source.Oracle.ToPostgreSQL.ConvertSequences)
+ [Conversion de Oracle ROWID](#CHAP_Source.Oracle.ToPostgreSQL.ConvertRowID)
+ [Conversion du SQL dynamique Oracle](#CHAP_Source.Oracle.ToPostgreSQL.DynamicSQL)
+ [Conversion de partitions Oracle](#CHAP_Source.Oracle.ToPostgreSQL.PG10Partitioning)

Lorsque vous convertissez des objets système Oracle en PostgreSQL AWS SCT , effectuez les conversions comme indiqué dans le tableau suivant.


| Objet du système Oracle | Description | Objet PostgreSQL converti | 
| --- | --- | --- | 
| V\$1VERSION  | Affiche les numéros de version des éléments de la bibliothèque principale dans la base de données Oracle | aws\$1oracle\$1ext.v\$1version | 
| V\$1INSTANCE | Vue qui indique l'état de l'instance actuelle. | aws\$1oracle\$1ext.v\$1instance | 

Vous pouvez l'utiliser AWS SCT pour convertir des fichiers Oracle SQL\$1Plus en psql, qui est une interface basée sur un terminal pour PostgreSQL. Pour de plus amples informations, veuillez consulter [Conversion du code SQL d'une application en utilisant AWS SCT](CHAP_Converting.App.md).

## Privilèges pour PostgreSQL en tant que base de données cible
<a name="CHAP_Source.Oracle.ToPostgreSQL.ConfigureTarget"></a>

Pour utiliser PostgreSQL comme cible AWS SCT , le privilège est requis. `CREATE ON DATABASE` Assurez-vous d'accorder ce privilège à chaque base de données PostgreSQL cible.

Pour utiliser les synonymes publics convertis, remplacez le chemin de recherche par défaut de la base de données par`"$user", public_synonyms, public`.

Vous pouvez utiliser l’exemple de code suivant pour créer un utilisateur de base de données et accorder les privilèges.

```
CREATE ROLE user_name LOGIN PASSWORD 'your_password';
GRANT CREATE ON DATABASE db_name TO user_name;
ALTER DATABASE db_name SET SEARCH_PATH = "$user", public_synonyms, public;
```

Dans l'exemple précédent, remplacez *user\$1name* par le nom de votre utilisateur. Remplacez ensuite *db\$1name* par le nom de votre base de données cible. Enfin, remplacez-le *your\$1password* par un mot de passe sécurisé.

Pour utiliser Amazon RDS for PostgreSQL comme cible, vous devez disposer du privilège. AWS SCT `rds_superuser`

Dans PostgreSQL, seul le propriétaire du schéma ou un `superuser` peut supprimer un schéma. Le propriétaire peut supprimer un schéma et tous les objets qu'il inclut même si le propriétaire du schéma ne possède pas certains de ses objets.

Lorsque vous utilisez différents utilisateurs pour convertir et appliquer différents schémas à votre base de données cible, un message d'erreur peut s'afficher lorsque vous ne AWS SCT pouvez pas supprimer un schéma. Pour éviter ce message d’erreur, utilisez le rôle `superuser`. 

## Paramètres de conversion Oracle vers PostgreSQL
<a name="CHAP_Source.Oracle.ToPostgreSQL.ConversionSettings"></a>

**Pour modifier les paramètres de conversion d'Oracle vers PostgreSQL, **choisissez Paramètres AWS SCT dans, puis sélectionnez** Paramètres de conversion.** Dans la liste supérieure, choisissez **Oracle**, puis **Oracle — PostgreSQL**. AWS SCT affiche tous les paramètres disponibles pour la conversion d'Oracle vers PostgreSQL.

Les paramètres de conversion d'Oracle vers PostgreSQL incluent des options pour AWS SCT les éléments suivants :
+ Pour limiter le nombre de commentaires contenant des actions dans le code converti.

  Pour **Ajouter des commentaires dans le code converti pour les actions de gravité sélectionnée ou supérieure**, choisissez la sévérité des actions. AWS SCT ajoute des commentaires dans le code converti pour les actions dont la sévérité est sélectionnée ou supérieure.

  Par exemple, pour réduire au maximum le nombre de commentaires dans votre code converti, choisissez **Erreurs uniquement**. Pour inclure les commentaires pour tous les éléments d’action de votre code converti, choisissez **Tous les messages**.
+ Pour permettre AWS SCT de convertir les vues matérialisées Oracle en tables ou en vues matérialisées sur PostgreSQL. Pour la **conversion des vues matérialisées en tant que**, choisissez le mode de conversion de vos vues matérialisées source.
+ Pour travailler avec votre code source Oracle lorsqu'il inclut les `TO_NUMBER` fonctions `TO_CHAR``TO_DATE`, et avec des paramètres non pris en charge par PostgreSQL. Par défaut, AWS SCT émule l'utilisation de ces paramètres dans le code converti.

  Lorsque votre code source Oracle inclut uniquement des paramètres pris en charge par PostgreSQL, vous pouvez utiliser PostgreSQL `TO_CHAR` natif et ses fonctions. `TO_DATE` `TO_NUMBER` Dans ce cas, le code converti fonctionne plus rapidement. Pour inclure uniquement ces paramètres, sélectionnez les valeurs suivantes :
  + **La fonction TO\$1CHAR () n'utilise pas de chaînes de formatage spécifiques à Oracle**
  + **La fonction TO\$1DATE () n'utilise pas de chaînes de formatage spécifiques à Oracle**
  + **La fonction TO\$1NUMBER () n'utilise pas de chaînes de formatage spécifiques à Oracle**
+ Pour remédier au cas où votre base de données source Oracle ne stocke que des valeurs entières dans les colonnes de clé principale ou étrangère du type de `NUMBER` données, AWS SCT vous pouvez convertir ces colonnes en type de `BIGINT` données. Cette approche améliore les performances de votre code converti. Pour adopter cette approche, sélectionnez **Convertir les colonnes de clé principale/étrangère NUMBER en colonnes BIGINT.** Assurez-vous que votre source n’inclut pas de valeurs à virgule flottante dans ces colonnes pour éviter toute perte de données.
+ Pour ignorer les déclencheurs et les contraintes désactivés dans votre code source. Pour ce faire, choisissez **Ignorer les déclencheurs et les contraintes désactivés**.
+ À utiliser AWS SCT pour convertir des variables de chaîne appelées en tant que SQL dynamique. Le code de la base de données peut modifier les valeurs de ces variables de chaîne. Pour vous assurer que cela convertit AWS SCT toujours la dernière valeur de cette variable de chaîne, sélectionnez **Convertir le code SQL dynamique créé dans des routines appelées**.
+ Pour remédier à ce problème, les versions 10 et antérieures de PostgreSQL ne prennent pas en charge les procédures. Si vous ou vos utilisateurs ne connaissez pas l'utilisation des procédures dans PostgreSQL AWS SCT , vous pouvez convertir les procédures Oracle en fonctions PostgreSQL. Pour ce faire, sélectionnez **Convertir les procédures en fonctions**.
+ Pour obtenir des informations supplémentaires sur les actions effectuées. Pour ce faire, vous pouvez ajouter des fonctions spécifiques au pack d'extension en sélectionnant **Ajouter un bloc de levée d'exception pour les problèmes de migration présentant les niveaux de gravité suivants**. Choisissez ensuite les niveaux de gravité pour déclencher les exceptions définies par l’utilisateur.
+ Pour travailler avec une base de données Oracle source susceptible d'inclure des contraintes liées aux noms générés automatiquement. Si votre code source utilise ces noms, assurez-vous de sélectionner **Convertir les noms de contraintes générés par le système à l'aide des noms d'origine de la source**. Si votre code source utilise ces contraintes mais pas leur nom, désactivez cette option pour augmenter la vitesse de conversion.
+ Pour déterminer si votre base de données et vos applications s'exécutent dans des fuseaux horaires différents. Par défaut, AWS SCT émule les fuseaux horaires dans le code converti. Toutefois, vous n’avez pas besoin de cette émulation lorsque votre base de données et vos applications utilisent le même fuseau horaire. Dans ce cas, sélectionnez Le **fuseau horaire du côté client correspond au fuseau horaire du serveur**.
+ Pour déterminer si vos bases de données source et cible s'exécutent dans des fuseaux horaires différents. Dans ce cas, la fonction qui émule la fonction Oracle `SYSDATE` intégrée renvoie des valeurs différentes de celles de la fonction source. Pour vous assurer que vos fonctions source et cible renvoient les mêmes valeurs, choisissez **Définir le fuseau horaire par défaut pour l'émulation SYSDATE**.
+ Pour utiliser les fonctions de l'extension Oracle dans votre code converti. Pour ce faire, dans **Utiliser l'implémentation d'Oracle**, sélectionnez les fonctions à utiliser. Pour plus d'informations sur Oracle, voir [orace](https://github.com/orafce/orafce) on. GitHub

## Conversion de séquences Oracle
<a name="CHAP_Source.Oracle.ToPostgreSQL.ConvertSequences"></a>

AWS SCT convertit des séquences d'Oracle vers PostgreSQL. Si vous utilisez des séquences pour maintenir des contraintes d'intégrité, assurez-vous que les nouvelles valeurs d'une séquence migrée ne chevauchent pas les valeurs existantes.

**Pour renseigner les séquences converties avec la dernière valeur de la base de données source**

1. Ouvrez votre AWS SCT projet avec Oracle comme source.

1. Choisissez **Paramètres**, puis **Paramètres de conversion**. 

1. Dans la liste supérieure, choisissez **Oracle**, puis **Oracle — PostgreSQL**. AWS SCT affiche tous les paramètres disponibles pour la conversion d'Oracle vers PostgreSQL. 

1. Choisissez **Remplir les séquences converties avec la dernière valeur générée côté source.**

1. Cliquez **sur OK** pour enregistrer les paramètres et fermer la boîte de dialogue des **paramètres de conversion**. 

## Conversion de Oracle ROWID
<a name="CHAP_Source.Oracle.ToPostgreSQL.ConvertRowID"></a>

 Dans une base de données Oracle, la pseudo-colonne ROWID contient l'adresse de la ligne de table. La pseudocolonne ROWID est propre à Oracle. Elle AWS SCT convertit donc la pseudocolonne ROWID en colonne de données dans PostgreSQL. En utilisant cette conversion, vous pouvez conserver les informations ROWID. 

Lors de la conversion de la pseudocolonne ROWID, AWS SCT vous pouvez créer une colonne de données avec le type de données. `bigint` S'il n'existe aucune clé primaire, AWS SCT définit la colonne ROWID comme clé primaire. S'il existe une clé primaire, AWS SCT définit la colonne ROWID avec une contrainte unique.

Si le code de votre base de données source inclut des opérations avec ROWID, que vous ne pouvez pas exécuter à l'aide d'un type de données numérique, vous AWS SCT pouvez créer une colonne de données avec ce type de `character varying` données.

**Pour créer une colonne de données pour Oracle ROWID pour un projet**

1. Ouvrez votre AWS SCT projet avec Oracle comme source.

1. Choisissez **Paramètres**, puis **Paramètres de conversion**. 

1. Dans la liste supérieure, choisissez **Oracle**, puis **Oracle — PostgreSQL**. AWS SCT affiche tous les paramètres disponibles pour la conversion d'Oracle vers PostgreSQL. 

1. Pour **Générer un identifiant de ligne**, effectuez l'une des opérations suivantes : 
   + Choisissez **Générer comme identité** pour créer une colonne de données numériques.
   + Choisissez **Générer comme type de domaine de caractères** pour créer une colonne de données de caractères.

1. Cliquez **sur OK** pour enregistrer les paramètres et fermer la boîte de dialogue des **paramètres de conversion**. 

## Conversion du SQL dynamique Oracle
<a name="CHAP_Source.Oracle.ToPostgreSQL.DynamicSQL"></a>

 Oracle propose deux méthodes pour implémenter le SQL dynamique : en utilisant une instruction EXECUTE IMMEDIATE ou en appelant des procédures dans le package DBMS\$1SQL. Si votre base de données Oracle source inclut des objets avec du SQL dynamique, utilisez-les AWS SCT pour convertir les instructions Oracle Dynamic SQL en PostgreSQL.

**Pour convertir le SQL dynamique Oracle en PostgreSQL**

1. Ouvrez votre AWS SCT projet avec Oracle comme source.

1. Choisissez un objet de base de données qui utilise le SQL dynamique dans l'arborescence des sources Oracle.

1. Ouvrez le menu contextuel (clic droit) de l'objet, choisissez **Convertir le schéma** et acceptez de remplacer les objets s'ils existent. La capture d'écran suivante montre la procédure convertie en dessous de la procédure Oracle avec du SQL dynamique.  
![\[Conversion Dynamic SQL\]](http://docs.aws.amazon.com/fr_fr/SchemaConversionTool/latest/userguide/images/dynamicsql1.png)

## Conversion de partitions Oracle
<a name="CHAP_Source.Oracle.ToPostgreSQL.PG10Partitioning"></a>

AWS SCT prend actuellement en charge les méthodes de partitionnement suivantes : 
+ Range
+ List
+ Gamme multicolonnes
+ Hachage
+ Composite (liste de liste, liste de plages, plage de listes, hachage de liste, hachage de plage, hachage de hachage)

# Migration d'Oracle vers Amazon RDS for MySQL ou Amazon Aurora MySQL avec AWS Schema Conversion Tool
<a name="CHAP_Source.Oracle.ToMySQL"></a>

Pour émuler les fonctions de base de données Oracle dans votre code MySQL converti, utilisez le pack d'extension Oracle to MySQL dans AWS SCT. Pour plus d’informations sur les packs d’extension, consultez [Utilisation de packs d'extension avec AWS Schema Conversion Tool](CHAP_ExtensionPack.md). 

**Topics**
+ [Privilèges pour MySQL en tant que base de données cible](#CHAP_Source.Oracle.ToMySQL.ConfigureTarget)
+ [Paramètres de conversion Oracle vers MySQL](#CHAP_Source.Oracle.ToMySQL.ConversionSettings)
+ [Considérations concernant la migration](#CHAP_Source.Oracle.ToMySQL.MigrationConsiderations)
+ [Conversion de l'instruction WITH dans Oracle en RDS pour MySQL ou Amazon Aurora MySQL](#CHAP_Source.Oracle.ToMySQL.With)

## Privilèges pour MySQL en tant que base de données cible
<a name="CHAP_Source.Oracle.ToMySQL.ConfigureTarget"></a>

Les privilèges requis pour MySQL en tant que cible sont les suivants :
+ CRÉER SUR\$1 . \$1
+ MODIFIER \$1 . \$1
+ DÉPOSEZ \$1 . \$1
+ INDEX SUR \$1 . \$1
+ RÉFÉRENCES SUR\$1 . \$1
+ SELECT ON \$1.\$1
+ CRÉER UNE VUE SUR \$1 . \$1
+ SHOW VIEW ON \$1.\$1
+ DÉCLENCHEUR ACTIVÉ\$1 . \$1
+ CRÉER UNE ROUTINE SUR\$1 . \$1
+ MODIFIER LA ROUTINE SUR \$1 . \$1
+ EXÉCUTER SUR\$1 . \$1
+ CRÉER DES TABLES TEMPORAIRES SUR\$1 . \$1
+ AWS\$1LAMBDA\$1ACCÈS
+ INSÉRER, METTRE À JOUR SUR AWS\$1ORACLE \$1EXT. \$1
+ INSÉREZ, METTEZ À JOUR, SUPPRIMEZ SUR AWS\$1ORACLE \$1EXT\$1DATA. \$1

Si vous utilisez une base de données MySQL version 5.7 ou inférieure comme cible, accordez l'autorisation INVOKE LAMBDA \$1.\$1 au lieu de AWS\$1LAMBDA \$1ACCESS. Pour les bases de données MySQL version 8.0 et supérieures, accordez l' AWS\$1LAMBDA\$1ACCESS autorisation.

Vous pouvez utiliser l’exemple de code suivant pour créer un utilisateur de base de données et accorder les privilèges.

```
CREATE USER 'user_name' IDENTIFIED BY 'your_password';
GRANT CREATE ON *.* TO 'user_name';
GRANT ALTER ON *.* TO 'user_name';
GRANT DROP ON *.* TO 'user_name';
GRANT INDEX ON *.* TO 'user_name';
GRANT REFERENCES ON *.* TO 'user_name';
GRANT SELECT ON *.* TO 'user_name';
GRANT CREATE VIEW ON *.* TO 'user_name';
GRANT SHOW VIEW ON *.* TO 'user_name';
GRANT TRIGGER ON *.* TO 'user_name';
GRANT CREATE ROUTINE ON *.* TO 'user_name';
GRANT ALTER ROUTINE ON *.* TO 'user_name';
GRANT EXECUTE ON *.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON *.* TO 'user_name';
GRANT AWS_LAMBDA_ACCESS TO 'user_name';
GRANT INSERT, UPDATE ON AWS_ORACLE_EXT.* TO 'user_name';
GRANT INSERT, UPDATE, DELETE ON AWS_ORACLE_EXT_DATA.* TO 'user_name';
```

Dans l'exemple précédent, remplacez *user\$1name* par le nom de votre utilisateur. Remplacez-le ensuite *your\$1password* par un mot de passe sécurisé.

Si vous utilisez une base de données MySQL version 5.7 ou inférieure comme cible, utilisez `GRANT INVOKE LAMBDA ON *.* TO 'user_name'` plutôt que`GRANT AWS_LAMBDA_ACCESS TO 'user_name'`.

Pour utiliser Amazon RDS for MySQL ou Aurora MySQL en tant que cible, définissez le paramètre `lower_case_table_names` sur `1`. Cette valeur signifie que le serveur MySQL traite les identifiants des noms d’objets tels que les tables, les index, les déclencheurs et les bases de données sans distinction entre majuscules et minuscules. Si vous avez activé la journalisation binaire dans votre instance cible, définissez le paramètre `log_bin_trust_function_creators` sur `1`. Dans ce cas, vous n’avez pas besoin d’utiliser les caractéristiques `DETERMINISTIC`, `READS SQL DATA` ni `NO SQL` pour créer des fonctions stockées. Pour configurer ces paramètres, créez un nouveau groupe de paramètres de base de données ou modifiez un groupe de paramètres de base de données existant.

## Paramètres de conversion Oracle vers MySQL
<a name="CHAP_Source.Oracle.ToMySQL.ConversionSettings"></a>

Pour modifier les paramètres de conversion d'Oracle vers MySQL, choisissez **Paramètres** dans AWS SCT, puis sélectionnez **Paramètres de conversion**. Dans la liste supérieure, choisissez **Oracle**, puis **Oracle — MySQL**. AWS SCT affiche tous les paramètres disponibles pour la conversion d'Oracle vers MySQL.

Les paramètres de conversion d'Oracle vers MySQL AWS SCT incluent des options pour les éléments suivants :
+ Pour limiter le nombre de commentaires contenant des actions dans le code converti.

  Pour **Ajouter des commentaires dans le code converti pour les actions de gravité sélectionnée ou supérieure**, choisissez la sévérité des actions. AWS SCT ajoute des commentaires dans le code converti pour les actions dont la sévérité est sélectionnée ou supérieure.

  Par exemple, pour réduire au maximum le nombre de commentaires dans votre code converti, choisissez **Erreurs uniquement**. Pour inclure les commentaires pour tous les éléments d’action de votre code converti, choisissez **Tous les messages**.
+ Pour résoudre ce problème, votre base de données Oracle source peut utiliser la `ROWID` pseudocolonne, mais MySQL ne prend pas en charge des fonctionnalités similaires. AWS SCT peut émuler la `ROWID` pseudocolonne dans le code converti. Pour ce faire, choisissez **Generate as identity** pour **Generate row ID ?** .

  Si votre code source Oracle n'utilise pas la `ROWID` pseudocolonne, choisissez **Ne pas générer pour Generate** **row ID ?** Dans ce cas, le code converti fonctionne plus rapidement.
+ Pour travailler avec votre code source Oracle lorsqu'il inclut les `TO_NUMBER` fonctions `TO_CHAR``TO_DATE`, et avec des paramètres que MySQL ne prend pas en charge. Par défaut, AWS SCT émule l'utilisation de ces paramètres dans le code converti.

  Lorsque votre code source Oracle inclut uniquement des paramètres pris en charge par PostgreSQL, vous pouvez utiliser `TO_CHAR` MySQL `TO_DATE` natif et ses fonctions. `TO_NUMBER` Dans ce cas, le code converti fonctionne plus rapidement. Pour inclure uniquement ces paramètres, sélectionnez les valeurs suivantes :
  + **La fonction TO\$1CHAR () n'utilise pas de chaînes de formatage spécifiques à Oracle**
  + **La fonction TO\$1DATE () n'utilise pas de chaînes de formatage spécifiques à Oracle**
  + **La fonction TO\$1NUMBER () n'utilise pas de chaînes de formatage spécifiques à Oracle**
+ Pour déterminer si votre base de données et vos applications s'exécutent dans des fuseaux horaires différents. Par défaut, AWS SCT émule les fuseaux horaires dans le code converti. Toutefois, vous n’avez pas besoin de cette émulation lorsque votre base de données et vos applications utilisent le même fuseau horaire. Dans ce cas, sélectionnez Le **fuseau horaire du côté client correspond au fuseau horaire du serveur**.

## Considérations concernant la migration
<a name="CHAP_Source.Oracle.ToMySQL.MigrationConsiderations"></a>

Lorsque vous convertissez Oracle en RDS for MySQL ou Aurora MySQL, vous pouvez utiliser une `GOTO` instruction et une étiquette pour modifier l'ordre dans lequel les instructions s'exécutent. Toutes les instructions PL/SQL qui suivent une `GOTO` instruction sont ignorées et le traitement se poursuit au niveau de l'étiquette. Vous pouvez utiliser `GOTO` des instructions et des étiquettes n'importe où dans une procédure, un lot ou un bloc d'instructions. Vous pouvez également suivre les instructions GOTO.

MySQL n'utilise pas d'`GOTO`instructions. Lors de la AWS SCT conversion du code contenant une `GOTO` instruction, il convertit l'instruction pour utiliser une `LOOP…END LOOP` instruction `BEGIN…END` or. 

Vous trouverez des exemples de AWS SCT conversion d'`GOTO`instructions dans le tableau suivant.


| Instruction Oracle | Instruction MySQL | 
| --- | --- | 
|  <pre>BEGIN<br />   ....<br />   statement1;<br />   ....<br />   GOTO label1;<br />   statement2;<br />   ....<br />   label1:<br />   Statement3;<br />   ....<br />END<br /></pre>  |  <pre>BEGIN<br /> label1:<br /> BEGIN<br />   ....<br />   statement1;<br />   ....<br />   LEAVE label1;<br />   statement2;<br />   ....<br /> END;<br />   Statement3;<br />   ....<br />END<br /></pre>  | 
|  <pre>BEGIN<br />   ....<br />   statement1;<br />   ....<br />   label1:<br />   statement2;<br />   ....<br />   GOTO label1;<br />   statement3;<br />   ....<br />   statement4;<br />   ....<br />END<br /></pre>  |  <pre>BEGIN<br />   ....<br />   statement1;<br />   ....<br />   label1:<br />   LOOP<br />    statement2;<br />    ....<br />    ITERATE label1;<br />    LEAVE label1;<br />   END LOOP; <br />    statement3;<br />    ....<br />    statement4;<br />    ....<br />END<br /></pre>  | 
|  <pre>BEGIN<br />   ....<br />   statement1;<br />   ....<br />   label1:<br />   statement2;<br />   ....<br />   statement3;<br />   ....<br />   statement4;<br />   ....<br />END<br /></pre>  |  <pre>BEGIN<br />   ....<br />   statement1;<br />   ....<br />   label1:<br />   BEGIN<br />    statement2;<br />    ....    <br />    statement3;<br />    ....<br />    statement4;<br />    ....    <br />   END; <br />END<br /></pre>  | 

## Conversion de l'instruction WITH dans Oracle en RDS pour MySQL ou Amazon Aurora MySQL
<a name="CHAP_Source.Oracle.ToMySQL.With"></a>

Vous utilisez la clause WITH (subquery\$1factoring) dans Oracle pour attribuer un nom (query\$1name) à un bloc contenant une sous-requête. Vous pouvez ensuite référencer plusieurs endroits de bloc contenant la sous-requête dans la requête en spécifiant query\$1name. Si un bloc de sous-requête ne contient ni liens ni paramètres (local, procédure, fonction, package), AWS SCT convertit la clause en vue ou en table temporaire. 

L'avantage de convertir la clause en table temporaire est que les références répétées à la sous-requête peuvent être plus efficaces. Cette amélioration de l'efficacité s'explique par le fait que les données sont facilement extraites de la table temporaire au lieu d'être requises par chaque référence. Vous pouvez l'émuler en utilisant des vues supplémentaires ou une table temporaire. Le nom de la vue utilise le format `<procedure_name>$<subselect_alias>`.

Vous trouverez des exemples dans le tableau ci-dessous. 


| Instruction Oracle | Instruction MySQL | 
| --- | --- | 
|  <pre>CREATE PROCEDURE <br /> TEST_ORA_PG.P_WITH_SELECT_VARIABLE_01<br />     (p_state IN NUMBER)<br />AS<br />  l_dept_id NUMBER := 1; <br />BEGIN<br />FOR cur IN  <br />           (WITH dept_empl(id, name, surname, <br />              lastname, state, dept_id)<br />              AS<br />                  (<br />                    SELECT id, name, surname,  <br />                     lastname, state, dept_id <br />                      FROM test_ora_pg.dept_employees<br />                     WHERE state = p_state AND <br />                       dept_id = l_dept_id)<br />            SELECT id,state   <br />              FROM dept_empl<br />            ORDER BY id)  LOOP<br />  NULL;<br />END LOOP;<br /></pre>  |  <pre>CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_VARIABLE_01(IN par_P_STATE DOUBLE)<br />BEGIN<br />    DECLARE var_l_dept_id DOUBLE DEFAULT 1;<br />    DECLARE var$id VARCHAR (8000);<br />    DECLARE var$state VARCHAR (8000);<br />    DECLARE done INT DEFAULT FALSE;<br />    DECLARE cur CURSOR FOR SELECT<br />        ID, STATE<br />        FROM (SELECT<br />            ID, NAME, SURNAME, LASTNAME, STATE, DEPT_ID<br />            FROM TEST_ORA_PG.DEPT_EMPLOYEES<br />            WHERE STATE = par_p_state AND DEPT_ID = var_l_dept_id) AS dept_empl<br />        ORDER BY ID;<br />    DECLARE CONTINUE HANDLER FOR NOT FOUND<br />        SET done := TRUE;<br />    OPEN cur;<br /><br />    read_label:<br />    LOOP<br />        FETCH cur INTO var$id, var$state;<br /><br />        IF done THEN<br />            LEAVE read_label;<br />        END IF;<br /><br />        BEGIN<br />        END;<br />    END LOOP;<br />    CLOSE cur;<br />END;<br /></pre>  | 
|  <pre>CREATE PROCEDURE <br /> TEST_ORA_PG.P_WITH_SELECT_REGULAR_MULT_01<br />AS    <br />BEGIN<br /><br /> FOR cur IN  (<br />               WITH dept_empl AS<br />                   (<br />                        SELECT id, name, surname, <br />                         lastname, state, dept_id <br />                          FROM test_ora_pg.dept_employees<br />                         WHERE state = 1),<br />                    dept AS <br />                   (SELECT id deptid, parent_id, <br />                      name deptname<br />                      FROM test_ora_pg.department                <br />                   )<br />                SELECT dept_empl.*,dept.*          <br />                 FROM dept_empl, dept<br />                 WHERE dept_empl.dept_id = dept.deptid<br />              ) LOOP<br />              NULL;<br />            END LOOP;<br /></pre>  |  <pre>CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl<br /> `(id, name, surname, lastname, state, dept_id)<br />AS<br />(SELECT id, name, surname, lastname, state, dept_id <br />   FROM test_ora_pg.dept_employees<br />  WHERE state = 1);<br />  <br />CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept<br /> `(deptid, parent_id,deptname)<br />AS<br />(SELECT id deptid, parent_id, name deptname<br />   FROM test_ora_pg.department);  <br /><br /><br />CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()<br />BEGIN<br />    DECLARE var$ID DOUBLE;<br />    DECLARE var$NAME VARCHAR (30);<br />    DECLARE var$SURNAME VARCHAR (30);<br />    DECLARE var$LASTNAME VARCHAR (30);<br />    DECLARE var$STATE DOUBLE;<br />    DECLARE var$DEPT_ID DOUBLE;<br />    DECLARE var$deptid DOUBLE;<br />    DECLARE var$PARENT_ID DOUBLE;<br />    DECLARE var$deptname VARCHAR (200);<br />    DECLARE done INT DEFAULT FALSE;<br />    DECLARE cur CURSOR FOR SELECT<br />        dept_empl.*, dept.*<br />        FROM TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl<br />          ` AS dept_empl,<br />             TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept<br />          ` AS dept<br />        WHERE dept_empl.DEPT_ID = dept.DEPTID;<br />    DECLARE CONTINUE HANDLER FOR NOT FOUND<br />        SET done := TRUE;<br />    OPEN cur;<br /><br />    read_label:<br />    LOOP<br />    FETCH cur INTO var$ID, var$NAME, var$SURNAME, <br />     var$LASTNAME, var$STATE, var$DEPT_ID, var$deptid, <br />     var$PARENT_ID, var$deptname;<br /><br />        IF done THEN<br />            LEAVE read_label;<br />        END IF;<br /><br />        BEGIN<br />        END;<br />    END LOOP;<br />    CLOSE cur;<br />END;<br /><br />call test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()<br /></pre>  | 
|  <pre>CREATE PROCEDURE <br />  TEST_ORA_PG.P_WITH_SELECT_VAR_CROSS_02(p_state IN NUMBER)<br />AS    <br />   l_dept_id NUMBER := 10;<br />BEGIN<br /> FOR cur IN  (<br />               WITH emp AS              <br />                    (SELECT id, name, surname, <br />                      lastname, state, dept_id <br />                       FROM test_ora_pg.dept_employees<br />                      WHERE dept_id > 10                 <br />                    ),<br />                    active_emp AS<br />                    (<br />                      SELECT id<br />                        FROM emp<br />                       WHERE emp.state = p_state <br />                    )<br />                    <br />                SELECT *          <br />                  FROM active_emp                 <br />              ) LOOP<br />         NULL;<br />  END LOOP;<br />  <br />END;<br /></pre>  |  <pre>CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_VAR_CROSS_01$emp<br />    `(id, name, surname, lastname, state, dept_id)<br />AS<br />(SELECT<br />       id, name, surname, lastname, <br />       state, dept_id<br />  FROM TEST_ORA_PG.DEPT_EMPLOYEES<br />  WHERE DEPT_ID > 10);<br /><br /><br />CREATE PROCEDURE <br />   test_ora_pg.P_WITH_SELECT_VAR_CROSS_02(IN par_P_STATE DOUBLE)<br />BEGIN<br />    DECLARE var_l_dept_id DOUBLE DEFAULT 10;<br />    DECLARE var$ID DOUBLE;<br />    DECLARE done INT DEFAULT FALSE;<br />    DECLARE cur CURSOR FOR SELECT *<br />                             FROM (SELECT<br />                                      ID<br />                                     FROM <br />                             TEST_ORA_PG.<br />                              `P_WITH_SELECT_VAR_CROSS_01$emp` AS emp<br />                                   WHERE emp.STATE = par_p_state) <br />                                    AS active_emp;<br />    DECLARE CONTINUE HANDLER FOR NOT FOUND<br />        SET done := TRUE;<br />    OPEN cur;<br /><br />    read_label:<br />    LOOP<br />        FETCH cur INTO var$ID;<br /><br />        IF done THEN<br />            LEAVE read_label;<br />        END IF;<br /><br />        BEGIN<br />        END;<br />    END LOOP;<br />    CLOSE cur;<br />END;<br /></pre>  | 

# Migration d'une base de données Oracle vers Amazon RDS for Oracle avec AWS Schema Conversion Tool
<a name="CHAP_Source.Oracle.ToRDSOracle"></a>

Éléments à prendre en compte lors de la migration d'un schéma et de code Oracle vers Amazon RDS pourOracle : 
+ AWS SCT peut ajouter des objets de répertoire à l'arborescence des objets. Les *objets de répertoire* sont des structures logiques qui représentent chacune un répertoire physique sur le système de fichiers du serveur. Vous pouvez utiliser des objets de répertoire avec les packages tels que DBMS\$1LOB, UTL\$1FILE, DBMS\$1FILE\$1TRANSFER, l'utilitaire DATAPUMP, et ainsi de suite.
+ AWS SCT prend en charge la conversion des tablespaces Oracle en une instance de base de données Amazon RDS for Oracle. Oracle stocke les données logiquement dans les espaces de table et physiquement dans les fichiers de données associés à l'espace de table correspondant. Dans Oracle, vous pouvez créer des espaces de table avec des noms de fichier de données. Amazon RDS prend en charge Oracle Managed Files (OMF) pour les fichiers de données, les fichiers journaux et les fichiers de contrôle uniquement. AWS SCT crée les fichiers de données nécessaires lors de la conversion.
+ AWS SCT peut convertir les rôles et les privilèges au niveau du serveur. Le moteur de base de données Oracle utilise une sécurité basée sur le rôle. Un rôle est un ensemble de privilèges que vous pouvez accorder ou révoquer à un utilisateur. Un rôle prédéfini dans Amazon RDS, appelé DBA, autorise normalement tous les privilèges d'administration sur un moteur de base de données Oracle. Les privilèges suivants ne sont pas disponibles pour le rôle DBA sur une instance de base de données Amazon RDS en utilisant le moteur Oracle :
  + Alter database
  + Alter system
  + Create any directory
  + Grant any privilege
  + Grant any role
  + Create external job

  Vous pouvez accorder tous les autres privilèges à un rôle d'utilisateur Amazon RDS pour Oracle, y compris les privilèges de filtrage avancés et de colonne.
+ AWS SCT prend en charge la conversion de tâches Oracle en tâches pouvant être exécutées sur Amazon RDS for Oracle. Quelques limitations s'appliquent à la conversion, notamment :
  + Les tâches exécutables ne sont pas prises en charge.
  + Les tâches de planification qui utilisent le type de données ANYDATA comme argument ne sont pas prises en charge.
+ Oracle Real Application Clusters (RAC) One Node est une option pour Oracle Database Enterprise Edition qui a été introduite avec Oracle Database 11g version 2. Amazon RDS pour Oracle ne prend pas en charge la fonction RAC. Pour un haut niveau de disponibilité, utilisez multi-AZ Amazon RDS. 

  Dans un déploiement multi-AZ, Amazon RDS fournit et maintient automatiquement un réplica de secours synchrone dans une autre zone de disponibilité. L'instance de base de données principale est répliquée de manière synchrone entre les zones de disponibilité et un réplica de secours. Cette fonctionnalité assure la redondance des données, élimine les I/O blocages et minimise les pics de latence lors des sauvegardes du système.
+ Oracle Spatial fournit un schéma SQL et des fonctions qui facilitent le stockage, la récupération, la mise à jour et la requête de collections de données spatiales dans une base de données Oracle. Oracle Locator fournit des capacités généralement requises pour prendre en charge les applications basées sur des services sans fil et sur Internet, ainsi que les solutions GIS basées sur le partenariat. Oracle Locator est un sous-ensemble limité d'Oracle Spatial.

  Pour utiliser les fonctionnalités Oracle Spatial et Oracle Locator, ajoutez l'option SPATIAL ou LOCATOR (mutuellement exclusives) au groupe d'options de votre instance de base de données.

  Il existe certains prérequis pour utiliser Oracle Spatial et Oracle Locator sur une instance de base de données Amazon RDS pour Oracle :
  + L'instance doit utiliser Oracle Enterprise Edition version 12.1.0.2.v6 ou supérieure, ou 11.2.0.4.v10 ou supérieure.
  + Votre instance doit être dans un VPC (cloud privé virtuel).
  + L'instance doit être la classe d'instance de base de données qui peut prendre en charge la fonctionnalité Oracle. Par exemple, Oracle Spatial n'est pas pris en charge pour les classes d'instance de base de données db.m1.small, db.t1.micro, db.t2.micro ou db.t2.small. Pour plus d'informations, consultez la section [Support des classes d'instance de base de données pour Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html#Oracle.Concepts.InstanceClasses).
  + L'option Mise à niveau automatique de versions mineures doit être activée pour l'instance. Amazon RDS met à jour votre instance de base de données vers le PSU Oracle le plus récent en cas de vulnérabilités de sécurité présentant un score CVSS égal ou supérieur à 9, ou d'autres vulnérabilités de sécurité annoncées. Pour plus d’informations, veuillez consulter la rubrique 

    [Paramètres pour les instances de base de données Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ModifyInstance.Oracle.html#USER_ModifyInstance.Oracle.Settings).
  + Si votre instance de base de données est de version 11.2.0.4.v10 ou supérieure, vous devez installer l'option XMLDB. Pour plus d’informations, veuillez consulter la rubrique

    Base de [données XML Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.Options.XMLDB.html).
  + Vous devez disposer d'une licence Oracle Spatial fournie par Oracle. Pour plus d'informations, consultez [Oracle Spatial et Graph](https://shop.oracle.com/apex/product?p1=OracleSpatialandGraph) dans la documentation d'Oracle.
+ Data Guard est inclus avec Oracle Database Enterprise Edition. Pour un haut niveau de disponibilité, utilisez la fonction multi-AZ Amazon RDS. 

  Dans un déploiement multi-AZ, Amazon RDS fournit et maintient automatiquement un réplica de secours synchrone dans une autre zone de disponibilité. L'instance de base de données principale est répliquée de manière synchrone entre les zones de disponibilité et un réplica de secours. Cette fonctionnalité assure la redondance des données, élimine les I/O blocages et minimise les pics de latence lors des sauvegardes du système.
+ AWS SCT prend en charge la conversion des objets Oracle DBMS\$1SCHEDULER lors de la migration vers Amazon RDS for Oracle. Le rapport AWS SCT d'évaluation indique si un objet de planification peut être converti. Pour plus d'informations sur l'utilisation des objets de planification avec Amazon RDS, consultez la [documentation Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.System.html#Appendix.Oracle.CommonDBATasks.ModifyScheduler).
+ Pour les conversions d'Oracle vers Amazon RDS pour Oracle, les liens de base de données sont pris en charge. Un lien de base de données est un objet de schéma dans une base de données qui vous permet d'accéder aux objets d'une autre base de données. L'autre base de données ne doit pas nécessairement être une base de données Oracle. Toutefois, pour accéder aux bases de données autres qu'Oracle, vous devez utiliser Oracle Heterogeneous Services.

  Une fois que vous avez créé un lien de base de données, vous pouvez l'utiliser dans les instructions SQL pour faire référence aux tables, aux vues et aux PL/SQL objets de l'autre base de données. Pour utiliser un lien de base de données, ajoutez-le `@dblink` au nom de la table, de la vue ou de PL/SQL l'objet. Vous pouvez interroger une table ou une vue dans l'autre base de données avec l'instruction SELECT. Pour plus d'informations sur l'utilisation des liens de base de données Oracle, consultez la [documentation Oracle](https://docs.oracle.com/cd/B28359_01/server.111/b28310/ds_concepts002.htm#ADMIN12083).

  Pour plus d'informations sur l'utilisation des liens de base de données avec AMazon RDS, consultez la [documentation Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Database.html#Appendix.Oracle.CommonDBATasks.DBLinks).
+ Le rapport AWS SCT d'évaluation fournit les indicateurs du serveur pour la conversion. Ces metrics sur votre instance Oracle sont les suivantes :
  + Capacité de calcul et de mémoire de l'instance de base de données cible.
  + Fonctionnalités Oracle non prises en charge, telles que Real Application Clusters, qu'Amazon RDS ne prend pas en charge.
  + Charge de travail en lecture/écriture sur disque
  + Total moyen du débit de disque
  + Les informations du serveur telles que le nom du serveur, le nom d'hôte, le système d'exploitation et le jeu de caractères.

## Privilèges accordés à RDS for Oracle en tant que cible
<a name="CHAP_Source.Oracle.ToRDSOracle.ConfigureTarget"></a>

Pour migrer vers Amazon RDS for Oracle, créez un utilisateur de base de données privilégié. Vous pouvez utiliser l'exemple de code suivant.

```
CREATE USER user_name IDENTIFIED BY your_password;

-- System privileges
GRANT DROP ANY CUBE BUILD PROCESS TO user_name;
GRANT ALTER ANY CUBE TO user_name;
GRANT CREATE ANY CUBE DIMENSION TO user_name;
GRANT CREATE ANY ASSEMBLY TO user_name;
GRANT ALTER ANY RULE TO user_name;
GRANT SELECT ANY DICTIONARY TO user_name;
GRANT ALTER ANY DIMENSION TO user_name;
GRANT CREATE ANY DIMENSION TO user_name;
GRANT ALTER ANY TYPE TO user_name;
GRANT DROP ANY TRIGGER TO user_name;
GRANT CREATE ANY VIEW TO user_name;
GRANT ALTER ANY CUBE BUILD PROCESS TO user_name;
GRANT CREATE ANY CREDENTIAL TO user_name;
GRANT DROP ANY CUBE DIMENSION TO user_name;
GRANT DROP ANY ASSEMBLY TO user_name;
GRANT DROP ANY PROCEDURE TO user_name;
GRANT ALTER ANY PROCEDURE TO user_name;
GRANT ALTER ANY SQL TRANSLATION PROFILE TO user_name;
GRANT DROP ANY MEASURE FOLDER TO user_name;
GRANT CREATE ANY MEASURE FOLDER TO user_name;
GRANT DROP ANY CUBE TO user_name;
GRANT DROP ANY MINING MODEL TO user_name;
GRANT CREATE ANY MINING MODEL TO user_name;
GRANT DROP ANY EDITION TO user_name;
GRANT CREATE ANY EVALUATION CONTEXT TO user_name;
GRANT DROP ANY DIMENSION TO user_name;
GRANT ALTER ANY INDEXTYPE TO user_name;
GRANT DROP ANY TYPE TO user_name;
GRANT CREATE ANY PROCEDURE TO user_name;
GRANT CREATE ANY SQL TRANSLATION PROFILE TO user_name;
GRANT CREATE ANY CUBE TO user_name;
GRANT COMMENT ANY MINING MODEL TO user_name;
GRANT ALTER ANY MINING MODEL TO user_name;
GRANT DROP ANY SQL PROFILE TO user_name;
GRANT CREATE ANY JOB TO user_name;
GRANT DROP ANY EVALUATION CONTEXT TO user_name;
GRANT ALTER ANY EVALUATION CONTEXT TO user_name;
GRANT CREATE ANY INDEXTYPE TO user_name;
GRANT CREATE ANY OPERATOR TO user_name;
GRANT CREATE ANY TRIGGER TO user_name;
GRANT DROP ANY ROLE TO user_name;
GRANT DROP ANY SEQUENCE TO user_name;
GRANT DROP ANY CLUSTER TO user_name;
GRANT DROP ANY SQL TRANSLATION PROFILE TO user_name;
GRANT ALTER ANY ASSEMBLY TO user_name;
GRANT CREATE ANY RULE SET TO user_name;
GRANT ALTER ANY OUTLINE TO user_name;
GRANT UNDER ANY TYPE TO user_name;
GRANT CREATE ANY TYPE TO user_name;
GRANT DROP ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY ROLE TO user_name;
GRANT DROP ANY VIEW TO user_name;
GRANT ALTER ANY INDEX TO user_name;
GRANT COMMENT ANY TABLE TO user_name;
GRANT CREATE ANY TABLE TO user_name;
GRANT CREATE USER TO user_name;
GRANT DROP ANY RULE SET TO user_name;
GRANT CREATE ANY CONTEXT TO user_name;
GRANT DROP ANY INDEXTYPE TO user_name;
GRANT ALTER ANY OPERATOR TO user_name;
GRANT CREATE ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY SEQUENCE TO user_name;
GRANT DROP ANY SYNONYM TO user_name;
GRANT CREATE ANY SYNONYM TO user_name;
GRANT DROP USER TO user_name;
GRANT ALTER ANY MEASURE FOLDER TO user_name;
GRANT ALTER ANY EDITION TO user_name;
GRANT DROP ANY RULE TO user_name;
GRANT CREATE ANY RULE TO user_name;
GRANT ALTER ANY RULE SET TO user_name;
GRANT CREATE ANY OUTLINE TO user_name;
GRANT UNDER ANY TABLE TO user_name;
GRANT UNDER ANY VIEW TO user_name;
GRANT DROP ANY DIRECTORY TO user_name;
GRANT ALTER ANY CLUSTER TO user_name;
GRANT CREATE ANY CLUSTER TO user_name;
GRANT ALTER ANY TABLE TO user_name;
GRANT CREATE ANY CUBE BUILD PROCESS TO user_name;
GRANT ALTER ANY CUBE DIMENSION TO user_name;
GRANT CREATE ANY EDITION TO user_name;
GRANT CREATE ANY SQL PROFILE TO user_name;
GRANT ALTER ANY SQL PROFILE TO user_name;
GRANT DROP ANY OUTLINE TO user_name;
GRANT DROP ANY CONTEXT TO user_name;
GRANT DROP ANY OPERATOR TO user_name;
GRANT DROP ANY LIBRARY TO user_name;
GRANT ALTER ANY LIBRARY TO user_name;
GRANT CREATE ANY LIBRARY TO user_name;
GRANT ALTER ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY TRIGGER TO user_name;
GRANT CREATE ANY SEQUENCE TO user_name;
GRANT DROP ANY INDEX TO user_name;
GRANT CREATE ANY INDEX TO user_name;
GRANT DROP ANY TABLE TO user_name;
GRANT SELECT_CATALOG_ROLE TO user_name;
GRANT SELECT ANY SEQUENCE TO user_name;

-- Database Links
GRANT CREATE DATABASE LINK TO user_name;
GRANT CREATE PUBLIC DATABASE LINK TO user_name;
GRANT DROP PUBLIC DATABASE LINK TO user_name;


-- Server Level Objects (directory)
GRANT CREATE ANY DIRECTORY TO user_name;
GRANT DROP ANY DIRECTORY TO user_name;
-- (for RDS only)
GRANT EXECUTE ON RDSADMIN.RDSADMIN_UTIL TO user_name;

-- Server Level Objects (tablespace)
GRANT CREATE TABLESPACE TO user_name;
GRANT DROP TABLESPACE TO user_name;

-- Server Level Objects (user roles)
/* (grant source privileges with admin option or convert roles/privs as DBA) */

-- Queues
grant execute on DBMS_AQADM to user_name;
grant aq_administrator_role to user_name;

-- for Materialized View Logs creation
GRANT SELECT ANY TABLE TO user_name;

-- Roles
GRANT RESOURCE TO user_name;
GRANT CONNECT TO user_name;
```

Dans l'exemple précédent, remplacez *user\$1name* par le nom de votre utilisateur. Remplacez-le ensuite *your\$1password* par un mot de passe sécurisé.

## Limitations lors de la conversion d'Oracle vers Amazon RDS for Oracle
<a name="CHAP_Source.Oracle.ToRDSOracle.Limitations"></a>

Quelques éléments à prendre en compte lors de la migration d'un schéma Oracle et d'un code vers Amazon RDS pour Oracle : 
+  Un rôle prédéfini dans Amazon RDS, appelé DBA, autorise normalement tous les privilèges d'administration sur un moteur de base de données Oracle. Les privilèges suivants ne sont pas disponibles pour le rôle DBA sur une instance de base de données Amazon RDS en utilisant le moteur Oracle :
  + Alter database
  + Alter system
  + Create any directory
  + Grant any privilege
  + Grant any role
  + Create external job

  Vous pouvez accorder tous les autres privilèges à un rôle d'utilisateur Oracle RDS.
+ Amazon RDS for Oracle prend en charge l'audit traditionnel, l'audit détaillé à l'aide du package DBMS\$1FGA et Oracle Unified Auditing.
+ Amazon RDS pour Oracle ne prend pas en charge la capture des données modifiées (CDC). Pour effectuer le CDC pendant et après une migration de base de données, utilisez AWS Database Migration Service.