Spostamento di utenti e schemi da Oracle® a Cloud SQL per MySQL

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questo documento illustra le differenze di base tra Oracle e Cloud SQL per MySQL in relazione alla creazione di utenti, schemi, tabelle, indici e viste.

Differenze terminologiche tra Oracle e Cloud SQL per MySQL

Oracle e Cloud SQL per MySQL hanno architetture diverse per istanze, database, utenti e schemi. La tabella seguente riassume queste differenze principali.

Terminologia Oracle Descrizione Terminologia di Cloud SQL per MySQL Differenze chiave
istanza (11 g) Una singola istanza Oracle 11g contiene un solo database. istanza Un'istanza Cloud SQL per MySQL può contenere più database.
istanza (12c) La funzionalità multi-tenant introdotta nell'istanza Oracle 12c contiene più database come database pluggable (PDB). istanza Cloud SQL per MySQL può contenere più database, ognuno dei quali serve un servizio o un'applicazione diverso.
schema Uno schema è un utente che possiede oggetti del database. database Uno schema Oracle è analogo a un database Cloud SQL per MySQL.
user Un utente Oracle è un nome utilizzato per la connessione al database. Un utente potrebbe anche essere proprietario di oggetti di database, nel qual caso l'utente è anche considerato uno schema. user Un utente Cloud SQL per MySQL è anche un nome utilizzato per connettersi al database e viene assegnato a un insieme di autorizzazioni per gli oggetti del database. A differenza di un utente Oracle, un utente Cloud SQL per MySQL non possiede alcun oggetto database.
role Un ruolo è un insieme di autorizzazioni di database concesse a un utente di database. autorizzazioni MySQL 5.7 non supporta la gestione dei ruoli. Le autorizzazioni per gli oggetti del database sono configurate utilizzando la clausola GRANT.

Esportazione delle configurazioni Oracle

Uno dei primi passaggi per pianificare una migrazione a Cloud SQL per MySQL consiste nel rivedere le impostazioni dei parametri esistenti nel database Oracle di origine. Le impostazioni relative all'allocazione della memoria, al set di caratteri e ai parametri di archiviazione sono utili perché possono determinare la configurazione iniziale e il dimensionamento dell'ambiente di destinazione Cloud SQL per MySQL. Esistono diversi metodi per estrarre le impostazioni dei parametri Oracle. Di seguito ne riportiamo alcuni comuni:

  • I report AWR contengono dati di allocazione delle risorse (CPU/RAM), configurazione dei parametri dell'istanza e numero massimo di sessioni attive.
  • DBA_HIST, V$OSSTAT e V$LICENSE per i dettagli sull'utilizzo della CPU.
  • V$PARAMETER vista per i parametri di configurazione del database.
  • V$NLS_PARAMETERS visualizzazione per i parametri del linguaggio di database.
  • DBA_DATA_FILES per il calcolo delle dimensioni di archiviazione del database.
  • Oracle SPFILE per le configurazioni di istanze di database.
  • Gli strumenti di pianificazione dei job (ad esempio, crontab) per identificare backup di routine o periodi di manutenzione da prendere in considerazione.

Importazione e configurazione degli utenti in Cloud SQL per MySQL

A livello generale, ogni schema Oracle deve essere creato come database separato in Cloud SQL per MySQL. Come accennato in precedenza, gli oggetti di database in Cloud SQL per MySQL appartengono a un database specifico anziché a uno schema specifico.

La seguente tabella illustra esempi di conversione.

Tipo di azione Tipo di database Confronto comandi
Crea utente Oracle CREATE USER username IDENTIFIED BY password;
Cloud SQL for MySQL -- Allows connections from a local server only
CREATE USER 'username'@'localhost' IDENTIFIED BY 'password';
-- Allows connections from a remote server
CREATE USER 'username'@'%' IDENTIFIED BY 'password';
Assegnare i ruoli di amministratore a un utente Oracle GRANT CONNECT TO username;
Cloud SQL for MySQL Not supported by Cloud SQL for MySQL
Concessione di privilegi Oracle GRANT SELECT, INSERT, UPDATE ON HR.EMPLOYEES TO username;
Cloud SQL for MySQL -- Grant on all tables under the HR database (* as wildcard)
GRANT CREATE, INSERT, UPDATE ON HR.* TO 'username'@'localhost';
Revoca dei privilegi Oracle REVOKE UPDATE ON HR.EMPLOYEES FROM username;
Cloud SQL for MySQL REVOKE UPDATE ON HR.* FROM 'username'@'localhost';
Concedi DBA/super user Oracle GRANT DBA TO username;
Cloud SQL for MySQL GRANT ALL ON *.* TO 'username'@'%';
Rilascia utente Oracle DROP USER username CASCADE;
Cloud SQL for MySQL DROP USER 'username'@'localhost';
Metadati degli utenti Oracle DBA_USERS
Cloud SQL for MySQL mysql.user
Metadati delle autorizzazioni Oracle DBA_SYS_PRIVS
DBA_ROLE_PRIVS
SESSION_PRIVS
Cloud SQL for MySQL mysql.user
INFORMATION_SCHEMA.USER_PRIVILEGES
Stringa di connessione dell'interfaccia a riga di comando Oracle sqlplus username/password@host/tns_alias
sqlplus username/password@host:IP/sid
Cloud SQL for MySQL mysql -u username -p password -h hostname databasename

Utenti di database Oracle 12c

Esistono due tipi di utenti in Oracle 12c: utenti comuni e utenti locali. Gli utenti comuni vengono creati nel database di container radice, inclusi i database pluggable (PDB). Sono identificati dal prefisso C## nel nome utente. Gli utenti locali vengono creati solo in un PDB specifico. È possibile creare utenti di database diversi con nomi utente identici in più PDB. Durante la migrazione da Oracle 12c a Cloud SQL per MySQL, gli utenti e le autorizzazioni devono essere modificati in modo da adattare l'architettura di Cloud SQL per MySQL. Ecco due esempi comuni per illustrare queste differenze:

# Oracle common user
SQL> CREATE USER c##username IDENTIFIED BY password CONTAINER=ALL;

# Cloud SQL for MySQL user with all permissions for all databases
mysql> CREATE USER 'username'@'%' IDENTIFIED BY 'password';
mysql> GRANT ALL ON *.* TO 'username'@'%';

# Oracle local user
SQL> ALTER SESSION SET CONTAINER=pdb;
SQL> CREATE USER username IDENTIFIED BY password QUOTA 50M ON USERS;

# Cloud SQL for MySQL user with permissions for specific database
mysql> CREATE USER 'username'@'%' IDENTIFIED BY 'password';
mysql> GRANT ALL ON databasename.* TO 'username'@'%';

Gestione di utenti e autorizzazioni tramite Cloud SQL in Google Cloud Console

Nella console Google Cloud, visualizza la connessione attualmente configurata Cloud SQL per MySQL in Storage > SQL > Istanza > Utenti > Visualizza account utente (o Crea account utente).

Gestione di utenti e autorizzazioni tramite Cloud SQL in Google Cloud Console.

Importazione di definizioni di tabelle e viste

Oracle e Cloud SQL per MySQL sono diversi in termini di distinzione tra maiuscole e minuscole. I nomi delle tabelle e delle viste Oracle non sono sensibili alle maiuscole. I nomi Cloud SQL per MySQL sono disponibili. La distinzione tra maiuscole e minuscole per Cloud SQL per MySQL può essere disabilitata impostando il parametro lower_case_table_names su "1", nel qual caso i nomi delle tabelle e delle viste sono archiviati in lettere minuscole e i confronti non sono più sensibili alle maiuscole. Tieni presente che questo parametro può essere modificato solo dalla sezione Cloud SQL di Google Cloud Console (flag di configurazione) o utilizzando l'API gcloud. Gli oggetti come colonna, indice, routine archiviata, nomi degli eventi e alias di colonna non sono sensibili alle maiuscole su nessuna delle piattaforme.

Crea sintassi della tabella

Quando converti le tabelle da Oracle ai tipi di dati MySQL, il primo passaggio consiste nell'estrazione delle istruzioni di creazione delle tabelle Oracle dal database di origine. La seguente query di esempio estrae il DDL per la tabella LOCATIONS dallo schema HR:

SQL> SELECT DBMS_METADATA.GET_DDL('TABLE', 'LOCATIONS') FROM DUAL;

CREATE TABLE "HR"."LOCATIONS"
   (    "LOCATION_ID" NUMBER(4,0),
    "STREET_ADDRESS" VARCHAR2(40),
    "POSTAL_CODE" VARCHAR2(12),
    "CITY" VARCHAR2(30) CONSTRAINT "LOC_CITY_NN" NOT NULL ENABLE,
    "STATE_PROVINCE" VARCHAR2(25),
    "COUNTRY_ID" CHAR(2),
     CONSTRAINT "LOC_ID_PK" PRIMARY KEY ("LOCATION_ID")
...
      CONSTRAINT "LOC_C_ID_FK" FOREIGN KEY ("COUNTRY_ID")
            REFERENCES "HR"."COUNTRIES" ("COUNTRY_ID") ENABLE
...

L'output completo include elementi di archiviazione, indici e informazioni sulla tabella, che sono stati omessi perché questi elementi aggiuntivi non sono supportati dall'istruzione CREATE TABLE Cloud SQL per MySQL.

Una volta estratto il DDL, esegui la conversione della tabella in base alla tabella di conversione dei tipi di dati Oracle-to-Cloud SQL per MySQL. Ogni tipo di dati di colonna deve essere controllato se può essere convertito così com'è o, se non è supportato, deve essere scelto un tipo di dati diverso in base alla tabella di conversione. Ad esempio, di seguito è riportato il DDL convertito per la tabella LOCATIONS.

mysql> SHOW CREATE TABLE LOCATIONS;

Create Table: CREATE TABLE `LOCATIONS` (
  `LOCATION_ID` decimal(4,0) NOT NULL,
  `STREET_ADDRESS` varchar(40) DEFAULT NULL,
  `POSTAL_CODE` varchar(12) DEFAULT NULL,
  `CITY` varchar(30) NOT NULL,
  `STATE_PROVINCE` varchar(25) DEFAULT NULL,
  `COUNTRY_ID` char(2) DEFAULT NULL,
  PRIMARY KEY (`LOCATION_ID`),
  KEY `LOC_CITY_IX` (`CITY`) USING BTREE,
  KEY `LOC_COUNTRY_IX` (`COUNTRY_ID`) USING BTREE,
  KEY `LOC_STATE_PROVINCE_IX` (`STATE_PROVINCE`) USING BTREE,
  CONSTRAINT `LOC_C_ID_FK` FOREIGN KEY (`COUNTRY_ID`) REFERENCES `COUNTRIES` (`COUNTRY_ID`) ON DELETE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=utf8

Tieni presente che in Cloud SQL per MySQL CREATE TABLE gli indici sono denominati KEYS. Il DDL della tabella Cloud SQL per MySQL include anche il set di caratteri e i valori del motore di archiviazione (il valore predefinito è InnoDB).

Crea tabella come selezionata (CTAS)

L'istruzione CREATE TABLE AS SELECT viene utilizzata per creare una nuova tabella basata su una tabella esistente. Ricorda che vengono copiati solo i nomi delle colonne e i tipi di dati delle colonne, al contrario dei vincoli e degli indici.

Cloud SQL per MySQL supporta lo standard ANSI SQL per la funzionalità CTAS ed è compatibile con l'istruzione CTAS Oracle. Tuttavia, poiché Cloud SQL per MySQL utilizza la modalità di replica GTID, un CTAS genera un'eccezione che vieta questa operazione.

mysql> CREATE TABLE EMP AS SELECT * FROM EMPLOYEES;

Statement violates GTID consistency: CREATE TABLE ... SELECT.

In alternativa, puoi utilizzare l'istruzione CREATE TABLE… LIKE per creare una tabella identica con un nome diverso, quindi eseguire un'ALTER TABLE se necessario.

mysql> CREATE TABLE EMP LIKE EMPLOYEES;

Purtroppo, questa soluzione alternativa non supporta la creazione di una struttura di tabella diversa da quella originale (ad esempio, in base a JOIN, funzione o raggruppamento).

Colonne invisibili Oracle 12c

Cloud SQL per MySQL non supporta questa funzionalità. Come soluzione alternativa, crea una vista che contenga solo le colonne visibili.

Vincoli tabella

Oracle fornisce sei tipi di vincoli di tabella che possono essere definiti durante la creazione della tabella o dopo la sua creazione con il comando ALTER TABLE. I tipi di vincolo Oracle sono PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK, NOT NULL e REF. Inoltre, Oracle consente all'utente di controllare lo stato di un vincolo tramite le seguenti opzioni:

  • INITIALLY IMMEDIATE: controlla il vincolo alla fine di ogni istruzione SQL successiva (lo stato predefinito).
  • DEFERRABLE/NOT DEFERRABLE: consente l'utilizzo della clausola SET CONSTRAINT nelle transazioni successive fino a quando non viene inviata un'istruzione COMMIT.
  • INITIALLY DEFERRED: controlla il vincolo alla fine delle transazioni successive.
  • VALIDATE/NO VALIDATE: controlla (o non deliberatamente non) la presenza di errori in righe nuove o modificate. Questi parametri variano a seconda che il vincolo sia ENABLED o DISABLED.
  • ENABLE/DISABLE: consente di specificare se il vincolo deve essere applicato dopo la creazione (ENABLE per impostazione predefinita).

Cloud SQL per MySQL supporta anche sei tipi di vincoli di tabella. Sono PRIMARY KEY, FOREIGN KEY, UNIQUE, NOT NULL, ENUM (tipo MYSQL) e SET (tipo MYSQL). Tuttavia, esistono alcune differenze significative tra i tipi di vincolo di Oracle e Cloud SQL per MySQL:

  • Cloud SQL per MySQL non supporta il vincolo REF di Oracle.
  • Cloud SQL per MySQL non supporta il vincolo CHECK di Oracle. Sebbene Cloud SQL per MySQL non si lamenti quando viene creata una tabella con un vincolo CHECK, la funzionalità di controllo non funziona. In alternativa, valuta la possibilità di utilizzare VIEW WITH CHECK OPTION di MySQL se è richiesto un vincolo CHECK.
  • I vincoli su VIEWS non sono supportati in Cloud SQL per MySQL, ad eccezione dell'opzione CHECK menzionata in precedenza.
  • Cloud SQL per MySQL non supporta la disattivazione dei vincoli, ad eccezione dei vincoli FOREIGN KEY (tramite il parametro foreign_key_checks).
  • Il nome PRIMARY KEY di Cloud SQL per MySQL è sempre PRIMARY, anche se provi a rinominarlo.
  • Ad eccezione di PRIMARY KEY, i nomi dei vincoli possono essere impostati in Cloud SQL per MySQL così come si trovano in Oracle.

La tabella seguente riassume le principali differenze tra i tipi di vincolo di Oracle e Cloud SQL per MySQL.

Tipo di vincolo Oracle Assistenza Cloud SQL per MySQL Cloud SQL per MySQL equivalente
PRIMARY KEY È sempre denominato PRIMARY e creato come indice in cluster.
FOREIGN KEY Utilizza la stessa sintassi SQL ANSI di Oracle. Utilizza la clausola ON DELETE per gestire i casi di eliminazione di record padre di FOREIGN KEY. Cloud SQL per MySQL offre quattro opzioni per gestire i casi in cui i dati vengono eliminati dalla tabella principale e viene fatto riferimento a una tabella secondaria da un vincolo FOREIGN KEY:
  • ON DELETE CASCADE
  • ON DELETE RESTRICT
  • ON DELETE NO ACTION
  • ON DELETE SET NULL
Utilizza la clausola ON UPDATE per gestire i casi di aggiornamento dei record padre di FOREIGN KEY. Cloud SQL per MySQL offre due opzioni per gestire gli eventi di aggiornamento dei vincoli FOREIGN KEY:
  • ON UPDATE CASCADE
  • ON UPDATE RESTRICT
I nomi dei vincoli delle chiavi straniere vengono generati automaticamente dal database o specificati in modo esplicito durante la creazione dei vincoli.
UNIQUE Crea un indice UNIQUE per impostazione predefinita.
CHECK No Non supportati. Utilizza una soluzione alternativa come:
  • VIEW WITH CHECK OPTION
  • ENUM/SET
  • TRIGGERS
NOT NULL NOT NULL
REF No Non supportati.
DEFERRABLE/
NOT DEFERRABLE
No Non supportati. Utilizza il parametro foreign_key_checks per disattivare la convalida di FOREIGN KEYS (a livello di sessione).
INITIALLY IMMEDIATE No Funzionalità non supportata
INITIALLY DEFERRED No Non supportati.
VALIDATE/NO VALIDATE No Non supportati. Utilizza il parametro foreign_key_checks per disattivare la convalida di FOREIGN KEYS. Il parametro foreign_key_checks può essere impostato a livello di sessione.
ENABLE/DISABLE No Questa opzione è attiva per impostazione predefinita.
Vincolo su VIEW No Non supportata tranne VIEW WITH CHECK OPTION.
Metadati vincoli Oracle DBA_CONSTRAINTS
Cloud SQL per MySQL INFORMATION_SCHEMA.TABLE_CONSTRAINTS

Colonne virtuali e calcolate

Le colonne virtuali di Oracle e Cloud SQL per MySQL per Microsoft MySQL, note anche in Cloud SQL per MySQL come colonne generate, si basano sui risultati di calcolo di altre colonne. Vengono visualizzati come colonne normali, ma i loro valori derivano da un calcolo e i loro valori non vengono archiviati nel database. Le colonne virtuali possono essere utilizzate con vincoli, indici, partizionamento delle tabelle e chiavi esterne, ma non possono essere manipolate tramite operazioni DML.

A differenza delle colonne virtuali di Oracle, le colonne generate da Cloud SQL per MySQL devono specificare il tipo di dati della colonna calcolata. Il valore GENERATED ALWAYS deve essere specificato, come negli esempi seguenti:

Colonna virtuale Oracle

SQL> CREATE TABLE PRODUCTS (
        PRODUCT_ID     INT PRIMARY KEY,
        PRODUCT_TYPE   VARCHAR2(100) NOT NULL,
        PRODUCT_PRICE  NUMBER(6,2) NOT NULL,
        PRICE_WITH_TAX AS (ROUND(PRODUCT_PRICE * 1.01, 2))
);

SQL> INSERT INTO PRODUCTS(PRODUCT_ID, PRODUCT_TYPE, PRODUCT_PRICE)
     VALUES(1, 'A', 99.99);

SQL> SELECT * FROM PRODUCTS;

PRODUCT_ID PRODUCT_TYPE         PRODUCT_PRICE PRICE_WITH_TAX
---------- -------------------- ------------- --------------
         1 A                            99.99         100.99

Colonna Cloud SQL per MySQL generata

mysql> CREATE TABLE PRODUCTS (
          PRODUCT_ID INT PRIMARY KEY,
          PRODUCT_TYPE VARCHAR(100) NOT NULL,
          PRODUCT_PRICE NUMERIC(6,2) NOT NULL,
          PRICE_WITH_TAX NUMERIC(6,2) GENERATED ALWAYS AS
             (ROUND(PRODUCT_PRICE * 1.01, 2))
       );

mysql> INSERT INTO PRODUCTS(PRODUCT_ID, PRODUCT_TYPE, PRODUCT_PRICE)
       VALUES(1, 'A', 99.99);

mysql> SELECT * FROM PRODUCTS;

+------------+--------------+---------------+----------------+
| PRODUCT_ID | PRODUCT_TYPE | PRODUCT_PRICE | PRICE_WITH_TAX |
+------------+--------------+---------------+----------------+
|          1 | A            |         99.99 |         100.99 |
+------------+--------------+---------------+----------------+

Indici di tabella

Oracle offre una selezione di indici più ampia rispetto a Cloud SQL per MySQL. La seguente tabella elenca gli indici disponibili in Cloud SQL per MySQL.

Nome indice Descrizione dell'indice
Albero B Tipo di indice predefinito per Cloud SQL per MySQL, utilizzato per velocizzare le query su uguaglianza e intervallo. Supporta tutti i tipi di dati originari e può essere utilizzato per recuperare i valori NULL. I valori indice sono ordinati in ordine crescente per impostazione predefinita, ma possono essere configurati anche in ordine decrescente.
Prefisso Supporta colonne TEXT e CLOB. Indicizza solo i caratteri iniziali (o prefisso) dei valori di colonna.
Unico Applica un vincolo UNIQUE ai valori indicizzati.
Hash Utilizzato per velocizzare le ricerche sulla parità. Sono considerati non sicuri perché non sono compatibili con le transazioni. Sono supportati dal motore di archiviazione della memoria.
Testo integrale Utile per eseguire query su grandi quantità di testo.
Spaziale Utilizzato per velocizzare le query GIS. Supporta POINT, GEOMETRY e altri tipi di spazi.

La seguente tabella confronta i tipi di indice tra Oracle e Cloud SQL per MySQL.

Indice Oracle Descrizione Supportato da Cloud SQL per MySQL Cloud SQL per MySQL equivalente
Indice bitmap Archivia una bitmap per ogni chiave di indice, ideale per il recupero dei dati per i carichi di lavoro OLAP. No N/D
Indice B- Tree Tipo di indice più comune, adatto per una varietà di carichi di lavoro e può essere configurato in ordinamento ASC|DESC. Indice B-tree
Quando crei un PK, l'indice Cloud SQL per MySQL viene creato per impostazione predefinita come indice in cluster in ordine crescente.
Indice composito Creata su due o più colonne per migliorare le prestazioni del recupero dei dati. L'ordinamento delle colonne all'interno dell'indice determina il percorso di accesso. Indici a più colonne
È possibile specificare fino a 16 colonne durante la creazione di un indice a più colonne.
Indice basato sulle funzioni Archivia l'output di una funzione applicata ai valori di una colonna della tabella. No Come soluzione alternativa, utilizza GENERATED COLUMNS e aggiungi un indice a quella colonna.
Indice univoco Un indice di b-albero che applica un vincolo UNIQUE ai valori indicizzati in base a una colonna. Indice univoco
Indice dominio applicazione Ideale per indicizzare dati non relazionali, come dati audio/video, dati LOB e altri tipi non testuali. No Come soluzione alternativa, utilizza un indice prefix per indicizzare le colonne "BLOB".
Indice invisibile Funzionalità Oracle che consente di gestire, gestire e testare gli indici senza influire sul processo decisionale dell'ottimizzatore. No Come soluzione alternativa, puoi creare un indice aggiuntivo su una replica di lettura a scopo di test senza influire sull'attività in corso.
Tabella organizzata dall'indice Un tipo di indice che controlla fisicamente la modalità di archiviazione dei dati a livello di tabella e indice. No Cloud SQL per MySQL non supporta le tabelle con indicizzazione dell'indice. Un indice in cluster, creato per ogni chiave primaria su "InnoDB", è la cosa più vicina a una tabella organizzata dall'indice in Cloud SQL per MySQL.
Indice locale e globale Utilizzato per l'indicizzazione di tabelle partizionate in Oracle. Ogni indice è definito come LOCAL o GLOBAL. No Gli indici di partizione di Cloud SQL per MySQL hanno la stessa funzionalità degli indici locali di Oracle (ovvero l'indice è definito a livello di partizione; il livello globale non è supportato).
Indici parziali per le tabelle partizionate (Oracle 12c) Crea un indice in un sottoinsieme di partizioni di una tabella. Supporta LOCAL e GLOBAL. No N/D
CREATE/DROP INDEX Comando utilizzato per la creazione e l'eliminazione dell'indice Cloud SQL per MySQL supporta il comando CREATE INDEX. Supporta inoltre ALTER TABLE tablename ADD INDEX indexname columnname
ALTER INDEX ... REBUILD Consente di ricreare l'indice, il che può causare un blocco esclusivo nella tabella indicizzata. Richiede una sintassi diversa Cloud SQL per MySQL supporta le ricostruzioni di indice utilizzando l'istruzione ANALYZE TABLE. La tabella è bloccata per le scritture durante questa operazione. Sono consentite solo le letture. Per le tabelle partizionate, è possibile analizzare le singole partizioni utilizzando un'istruzione ALTER TABLE ... ANALYZE PARTITION.
ALTER INDEX ... REBUILD ONLINE Ricrea un indice senza creare un blocco esclusivo nella tabella. No Non supportati.
Compressione degli indici Riduce le dimensioni dell'indice. No N/D
Alloca indice in uno spazio delle tabelle Crea uno spazio della tabella di indice che può essere archiviato su un disco separato dai dati della tabella per ridurre i colli di bottiglia dei I/O del disco. In parte Per impostazione predefinita, i dati dell'indice e della tabella sono archiviati nello stesso file dello spazio della tabella, sebbene sia possibile archiviare le tabelle in uno spazio della tabella condiviso.
Metadati degli indici (tabelle/visualizzazioni) Oracle DBA_INDEXES
DBA_PART_INDEXES
DBA_IND_COLUMNS
Cloud SQL per MySQL SHOW INDEX FROM tablename;
INFORMATION_SCHEMA.STATISTICS
INFORMATION_SCHEMA.INNODB_SYS_INDEXES
INFORMATION_SCHEMA.KEY_COLUMN_USAGE

Considerazioni sulle conversioni dell'indice

Nella maggior parte dei casi, gli indici Oracle possono essere convertiti in indici Cloud SQL per MySQL, perché questo tipo di indice in genere fornisce buoni risultati in termini di prestazioni sul motore di archiviazione InnoDB. Gli indici di Cloud SQL per MySQL possono essere specificati nell'istruzione di creazione della tabella utilizzando la parola chiave KEY. Quando crei una tabella, viene creato automaticamente un indice in cluster PRIMARY KEY. Quando aggiungi un vincolo UNIQUE alle colonne della tabella, viene creato anche un indice UNIQUE per impostazione predefinita. Qualsiasi altro tipo di indice è indicato come indice secondario nella terminologia di Cloud SQL per MySQL.

L'esempio seguente illustra come una tabella Oracle con diversi tipi di indice può essere convertita in Cloud SQL per MySQL:

SQL> CREATE TABLE ORA_IDX_TO_MYSQL (
        col1 INT PRIMARY KEY,
        col2 VARCHAR2(60),
        col3 DATE,
        col4 CLOB,
        col5 VARCHAR2(20)
      );

-- B-tree index
SQL> CREATE INDEX idx_col2 ON ora_idx_to_mysql(col2);

-- Composite index
SQL> CREATE INDEX idx_cols3_2 ON ora_idx_to_mysql(col3 DESC, col2);

-- Unique index
SQL> CREATE UNIQUE INDEX idx_col3_uni ON ora_idx_to_mysql(col3);

-- Function-based index
SQL> CREATE INDEX idx_func_col3 ON
        ora_idx_to_mysql(EXTRACT(MONTH FROM col3));

-- CLOB index
SQL> CREATE INDEX idx_col4 ON
       ora_idx_to_mysql(col4) INDEXTYPE IS CTXSYS.CONTEXT;

-- Invisible index
SQL> CREATE INDEX idx_col5_inv ON
        ora_idx_to_mysql(col5) INVISIBLE;

-- Drop index
SQL> DROP INDEX idx_col5_inv;

mysql> CREATE TABLE IF NOT EXISTS HR.ORA_IDX_TO_MYSQL (
          col1 DECIMAL(38,0) NOT NULL,
          col2 VARCHAR(60) DEFAULT NULL,
          col3 DATETIME DEFAULT NULL,
          col4 LONGTEXT DEFAULT NULL,
          col5 VARCHAR(20) DEFAULT NULL,
          PRIMARY KEY (COL1)
       );

-- B-tree index (supported)
mysql> CREATE INDEX IDX_COL2 ON ora_idx_to_mysql(COL2);

-- Unique index (supported)
mysql> CREATE UNIQUE INDEX idx_col3_uni ON ora_idx_to_mysql(COL3);

-- Composite index (supported)
mysql> CREATE INDEX IDX_COLS3_2 ON ora_idx_to_mysql(COL3 DESC, COL2);

-- Function-based index (not supported)
-- As an alternative solution add a GENERATED ALWAYS column
mysql> ALTER TABLE ora_idx_to_mysql ADD COLUMN col6 int GENERATED ALWAYS
          AS(EXTRACT(MONTH FROM col3));

-- Add an index to the GENERATED COLUMN (MySQL syntax)
mysql> ALTER TABLE ora_idx_to_mysql ADD INDEX idx_col6(col6);

-- CLOB (not supported)
-- As an alternative solution create PREFIX index
mysql> CREATE INDEX idx_col4 ON ORA_IDX_TO_MYSQL(col4(10));

-- Invisible index (not supported)
-- Optional - create the index as a b-tree index
mysql> CREATE INDEX idx_col5 ON ora_idx_to_mysql(col5);

-- Drop index
mysql> DROP INDEX idx_col2 on ora_idx_to_mysql;

mysql> ALTER TABLE ora_idx_to_mysql DROP INDEX idx_col4;

SQL> SELECT ui.table_name,
            ui.index_name,
            ui.index_type,
            ic.column_name
     FROM user_indexes ui JOIN user_ind_columns ic
     ON ui.index_name = ic.index_name
     WHERE ui.table_name = 'ORA_IDX_TO_MYSQL'
     ORDER BY 4;

mysql> SELECT table_name, index_name, non_unique, index_type
    -> FROM INFORMATION_SCHEMA.STATISTICS
    -> WHERE table_name = 'ORA_IDX_TO_MYSQL';

-- OR Use MySQL SHOW command:
mysql> SHOW INDEXES FROM ORA_IDX_TO_MYSQL;

mysql> SHOW CREATE TABLE ORA_IDX_TO_MYSQL \G;

Partizionamento tabella

Sia Oracle che Cloud SQL per MySQL condividono lo stesso concetto di partizionamento delle tabelle, fornendo supporto per tabelle e indici su larga scala. Questa partizione si ottiene suddividendo le tabelle in segmenti più piccoli di set di dati, anche se non tutti i tipi di partizioni Oracle sono supportati da Cloud SQL per MySQL.

La tabella seguente descrive i tipi di partizione Cloud SQL per MySQL e illustra ogni tipo con un esempio.

Tipo di partizione Descrizione Esempio
RANGE partizione Assegna le righe alle partizioni in base ai valori delle colonne che rientrano in un determinato intervallo. Ogni partizione contiene righe per le quali il valore dell'espressione di partizionamento si trova all'interno di un determinato intervallo. CREATE TABLE employees (
empid INT NOT NULL,
fname VARCHAR(30),
lname VARCHAR(30),
hired DATE NOT NULL,
separated DATE NOT NULL,
job_code INT NOT NULL,
store_id INT NOT NULL)

PARTITION BY RANGE (store_id) (
PARTITION p0 VALUES LESS THAN (6),
PARTITION p1 VALUES LESS THAN (11),
PARTITION p2 VALUES LESS THAN (16),
PARTITION p3 VALUES LESS THAN (21)
);
LIST partizione Simile al partizionamento per RANGE, salvo che la partizione è selezionata in base alla data corrispondente da un insieme predefinito di valori. CREATE TABLE employees (
empid INT NOT NULL,
fname VARCHAR(30),
lname VARCHAR(30),
hired DATE NOT NULL,
separated DATE NOT NULL,
job_code INT NOT NULL,
store_id INT NOT NULL)

PARTITION BY LIST(store_id) (
PARTITION pNorth VALUES IN(3,5,6),
PARTITION pEast VALUES IN (1,2,10),
PARTITION pWest VALUES IN (4,12,13),
PARTITION pCnrl VALUES IN (7,8,15));
HASH partizione Una partizione HASH è la più adatta quando l'obiettivo è quello di ottenere una distribuzione uniforme dei dati tra tutte le partizioni. Un valore o un'espressione di colonna basato su un valore di colonna da sottoporre ad hashing e il numero di partizioni deve essere specificato. CREATE TABLE employees (
empid INT NOT NULL,
fname VARCHAR(30),
lname VARCHAR(30),
hired DATE NOT NULL,
separated DATE NOT NULL,
job_code INT NOT NULL,
store_id INT NOT NULL)

PARTITION BY HASH(YEAR(hired))
PARTITIONS 4;
KEY partizione Il partizionamento KEY è simile al partizionamento HASH, ma il partizionamento HASH utilizza una funzione o un'espressione definita dall'utente. La funzione di hashing per il partizionamento delle chiavi viene fornita dal server Cloud SQL per MySQL stesso. Una partizione KEY richiede solo un elenco di zero o più nomi di colonna. Qualsiasi colonna utilizzata come chiave di partizionamento deve includere parte o tutta la chiave primaria della tabella. CREATE TABLE employees (
empid INT PRIMARY KEY,
fname VARCHAR(30),
lname VARCHAR(30),
hired DATE NOT NULL,
separated DATE NOT NULL,
job_code INT NOT NULL,
store_id INT NOT NULL)

PARTITION BY KEY()
PARTITIONS 3;
Partizione secondaria Un metodo per suddividere ulteriormente ciascuna partizione in una tabella partizionata. Tieni presente che tutte le partizioni devono avere lo stesso numero di partizioni. CREATE TABLE sales (
Saleid INT,
sale_date DATE,
cust_code VARCHAR(15),
income DECIMAL(8,2))

PARTITION BY RANGE(YEAR(sale_date))
SUBPARTITION BY HASH(TO_DAYS(sale_date))
SUBPARTITIONS 4 (
PARTITION p0 VALUES LESS THAN (2009),
PARTITION p1 VALUES LESS THAN (2014),
PARTITION p2 VALUES LESS THAN (2019),
PARTITION p3 VALUES LESS THAN MAXVALUE
);
Dividi partizioni Per suddividere le partizioni, Cloud SQL per MySQL fornisce l'istruzione REORGANIZE PARTITION. Tieni presente che le partizioni RANGE possono essere divise solo all'ultima partizione. CREATE TABLE employees (
empid INT NOT NULL,
fname VARCHAR(30),
lname VARCHAR(30),
hired_year DATE NOT NULL
)
PARTITION BY RANGE(YEAR(hired_year))
(
PARTITION p0 VALUES LESS THAN (2000),
PARTITION p1 VALUES LESS THAN (2005),
PARTITION p2 VALUES LESS THAN (2010)
);

-- Splitting the first partition into two partitions:

ALTER TABLE employees
REORGANIZE PARTITION p0 INTO (
PARTITION n0 VALUES LESS THAN (1995),
PARTITION n1 VALUES LESS THAN (2000)
);
Partizioni Exchange Abilitale per scambiare partizioni o partizioni tra altre tabelle non partizionate. ALTER TABLE sales
EXCHANGE PARTITION p1 WITH TABLE sales_year_2013;

La tabella seguente descrive dove sono i tipi di partizione Oracle e Cloud SQL per MySQL e dove è consigliata una conversione.

Tipo di partizione Oracle Supportato da Cloud SQL per MySQL Implementazione di Cloud SQL per MySQL
RANGE partizioni PARTITION BY RANGE
LIST partizioni PARTITION BY LIST
HASH partizioni PARTITION BY HASH
Suddivisione in partizioni SUBPARTITION BY
Partizioni intervalli No Non supportato, limitazioni di partizionamento di Cloud SQL per MySQL
Consulente delle partizioni No Non supportato, limitazioni di partizionamento di Cloud SQL per MySQL
Partizionamento per preferenze No Non supportato, limitazioni di partizionamento di Cloud SQL per MySQL
Partizionamento virtuale basato su colonne No Non supportato, limitazioni di partizionamento di Cloud SQL per MySQL
Partizionamento automatico degli elenchi No Non supportato, limitazioni di partizionamento di Cloud SQL per MySQL
Suddividi partizioni REORGANIZE PARTITION
Partizioni Exchange EXCHANGE PARTITION
Partizionamento di più tipi (partizionamento composito) Sì con soluzione alternativa Implementa tabelle di partizioni secondarie con il partizionamento RANGE, LIST, HAS o KEY
Metadati delle partizioni Oracle DBA_TAB_PARTITIONS
DBA_TAB_SUBPARTITIONS
Cloud SQL per MySQL INFORMATION_SCHEMA.PARTITIONS
SHOW CREATE TABLE
SHOW TABLE STATUS LIKE TableName;

Il codice seguente fornisce un esempio di conversione da Oracle a Cloud SQL per MySQL per una tabella partizionata. Tieni presente che Cloud SQL per MySQL non supporta il riferimento a uno spazio della tabella nella clausola PARTITIONS del comando CREATE TABLE.

SQL> CREATE TABLE payments (
        paymentid    NUMBER NOT NULL,
        payment_date  DATE   NOT NULL,
        payment_notes      VARCHAR2(500))
     PARTITION BY HASH (paymentid) (
      PARTITION p1 TABLESPACE users,
      PARTITION p2 TABLESPACE users,
      PARTITION p3 TABLESPACE users,
      PARTITION p4 TABLESPACE users
     );

mysql> CREATE TABLE payments (
          paymentid     INT PRIMARY KEY,
          payment_date  DATE   NOT NULL,
          payment_notes VARCHAR(500)
       )
       PARTITION BY HASH(paymentid)
        PARTITIONS 4;

mysql> SELECT table_schema,
              table_name,
              partition_name,
              partition_ordinal_position AS part_pos,
              partition_method,
              partition_expression AS part_exprs
       FROM information_schema.PARTITIONS
       WHERE table_name='payments';

+--------------+------------+----------------+----------+------------------+------------+
| table_schema | table_name | partition_name | part_pos | partition_method | part_exprs |
+--------------+------------+----------------+----------+------------------+------------+
| HR           | payments   | p0             |        1 | HASH             | paymentid  |
| HR           | payments   | p1             |        2 | HASH             | paymentid  |
| HR           | payments   | p2             |        3 | HASH             | paymentid  |
| HR           | payments   | p3             |        4 | HASH             | paymentid  |
+--------------+------------+----------------+----------+------------------+------------+

mysql> SHOW CREATE TABLE payments \G;

       Table: payments
Create Table: CREATE TABLE `payments` (
  `paymentid` int(11) NOT NULL,
  `payment_date` date NOT NULL,
  `payment_notes` varchar(500) DEFAULT NULL,
  PRIMARY KEY (`paymentid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
/*!50100 PARTITION BY HASH (paymentid)
PARTITIONS 4 */

Tabelle temporanee

In Oracle, le tabelle temporanee sono chiamate tabelle temporanee globali. In Cloud SQL per MySQL sono noti semplicemente come tabelle temporanee. La funzionalità di base di una tabella temporanea è identica per entrambe le piattaforme. Tuttavia, ci sono alcune differenze significative:

  • Oracle archivia la struttura temporanea della tabella per l'uso ripetuto anche dopo il riavvio di un database, mentre Cloud SQL per MySQL archivia la tabella temporanea solo per la durata di una sessione.
  • diversi utenti con le autorizzazioni appropriate possono accedere a una tabella temporanea in Oracle. Al contrario, è possibile accedere a una tabella temporanea in Cloud SQL per MySQL solo durante la sessione in cui è stata creata.
  • Se la clausola ON COMMIT viene omessa durante la creazione di una tabella temporanea, il comportamento predefinito in Oracle è ON COMMIT DELETE ROWS, il che significa che Oracle tronca la tabella temporanea dopo ogni commit. Al contrario, in Cloud SQL per MySQL il comportamento predefinito prevede il mantenimento delle righe nella tabella temporanea dopo ogni commit.

La tabella seguente evidenzia le differenze tra le tabelle temporanee tra Oracle e Cloud SQL per MySQL.

Funzionalità temporanea della tabella Implementazione Oracle Implementazione di Cloud SQL per MySQL
Syntax CREATE GLOBAL TEMPORARY TABLE CREATE TEMPORARY TABLE
Accessibilità Accessibile da più sessioni Sono accessibili solo dalla sessione del creator
Supporto dell'indice
Supporto per chiavi esterne
Conserva DDL No
ON COMMIT azione predefinita I record sono stati eliminati I record vengono conservati
ON COMMIT PRESERVE ROWS
ON COMMIT DELETE ROWS
ALTER TABLE assistenza
Raccolta di statistiche DBMS_STATS.GATHER_TABLE_STATS ANALYZE TABLE
Oracle 12c GLOBAL_TEMP_
TABLE_STATS
DBMS_STATS.SET_TABLE_PREFS ANALYZE TABLE

Colonne non utilizzate

La funzionalità di Oracle per contrassegnare colonne specifiche come UNUSED non è supportata da Cloud SQL per MySQL. Per eliminare una colonna di grandi dimensioni da una tabella in Cloud SQL per MySQL ed evitare la lunga attesa legata a questa operazione, crea una nuova tabella con lo schema modificato, basata sulla tabella originale, quindi rinomina le due tabelle.

Tieni presente che questa procedura richiede un tempo di inattività.

Tabelle di sola lettura

Le tabelle di sola lettura sono una funzionalità di Oracle che contrassegna le tabelle come di sola lettura utilizzando il comando ALTER TABLE. In Oracle 12c R2, questa funzionalità è disponibile anche per le tabelle con partizioni e partizioni. Cloud SQL per MySQL non offre una funzionalità equivalente, ma esistono due possibili soluzioni alternative:

  • Concedi a SELECT l'autorizzazione per le tabelle per utenti specifici. Tieni presente che ciò non impedisce al proprietario della tabella di eseguire operazioni DML sulle proprie tabelle.
  • Creare una replica di lettura Cloud SQL per MySQL e indirizzare gli utenti alle tabelle di replica, che sono di sola lettura. Questa soluzione richiede l'aggiunta di un'istanza di replica di lettura a un'istanza Cloud SQL Cloud SQL per MySQL esistente.

Set di caratteri

Oracle e Cloud SQL per MySQL offrono un'ampia varietà di set di caratteri, fascicoli e unicode, incluso il supporto per linguaggi a singolo byte e multibyte. Inoltre, ogni database Cloud SQL per MySQL creato può essere configurato con un proprio set di caratteri. I nomi di confronto in Cloud SQL per MySQL iniziano con il nome del set di caratteri seguito da uno o più finali che indicano altre caratteristiche del confronto. Tutti i set di caratteri hanno almeno un confronto, quello predefinito, mentre la maggior parte ne ha più di un. Tieni presente che due set di caratteri diversi non possono avere lo stesso confronto.

Con Oracle e Cloud SQL per MySQL, i set di caratteri sono specificati a livello di database. A differenza di Oracle, Cloud SQL per MySQL supporta anche la specifica di un set di caratteri a livello di tabella e granularità a livello di colonna.

mysql> CREATE DATABASE HR CHARACTER SET=latin1 COLLATE=latin1_swedish_ci;

mysql> ALTER DATABASE HR CHARACTER SET=latin2 COLLATE=latin2_general_ci;

mysql> SELECT SCHEMA_NAME, DEFAULT_CHARACTER_SET_NAME, DEFAULT_COLLATION_NAME
       FROM INFORMATION_SCHEMA.SCHEMATA;
+--------------------+----------------------------+------------------------+
| SCHEMA_NAME        | DEFAULT_CHARACTER_SET_NAME | DEFAULT_COLLATION_NAME |
+--------------------+----------------------------+------------------------+
| information_schema | utf8                       | utf8_general_ci        |
| HR                 | latin2                     | latin2_general_ci      |
| mysql              | utf8                       | utf8_general_ci        |
| performance_schema | utf8                       | utf8_general_ci        |
| sys                | utf8                       | utf8_general_ci        |
+--------------------+----------------------------+------------------------+

mysql> CREATE TABLE Emp(
         col1 CHAR(30) CHARACTER SET latin1 COLLATE latin1_swedish_ci,
         col2 CHAR(20) CHARACTER SET latin2
)
       DEFAULT CHARSET=utf8;

mysql> SELECT TABLE_NAME, TABLE_COLLATION
       FROM INFORMATION_SCHEMA.TABLES
       WHERE TABLE_NAME='Emp';
+------------+-------------------+
| TABLE_NAME | TABLE_COLLATION   |
+------------+-------------------+
| Emp        | latin2_general_ci |
+------------+-------------------+

mysql> SELECT TABLE_NAME, COLUMN_NAME, CHARACTER_SET_NAME, COLLATION_NAME
       FROM INFORMATION_SCHEMA.COLUMNS
       WHERE TABLE_NAME = 'Emp';
+------------+-------------+--------------------+-------------------+
| table_name | column_name | CHARACTER_SET_NAME | COLLATION_NAME    |
+------------+-------------+--------------------+-------------------+
| Emp        | col1        | latin1             | latin1_swedish_ci |
| Emp        | col2        | latin2             | latin2_general_ci |
+------------+-------------+--------------------+-------------------+

Visualizzazioni

Cloud SQL per MySQL supporta sia viste semplici che complesse. Ha inoltre lo stesso comportamento di Oracle nell'esecuzione di operazioni DML rispetto alle viste. Esistono alcune differenze tra Oracle e Cloud SQL per MySQL per le opzioni di creazione delle viste. La tabella riportata di seguito evidenzia queste differenze.

Funzionalità vista Oracle Descrizione Assistenza Cloud SQL per MySQL Considerazioni sulle conversioni
FORCE Crea una vista senza verificare se esistono tabelle o viste di origine. No Nessuna opzione equivalente disponibile.
CREATE OR REPLACE Crea una vista inesistente o sovrascrivi una vista esistente. Cloud SQL per MySQL supporta il comando CREATE OR REPLACE per le viste.
WITH CHECK OPTION Specifica il livello di applicazione forzata durante l'esecuzione di operazioni DML sulla vista. Il valore predefinito è CASCADED, che determina anche la valutazione delle viste di riferimento.

La parola chiave LOCAL fa sì che venga valutata solo la visualizzazione corrente.
WITH READ-ONLY Consente solo le operazioni di lettura sulla vista. Le operazioni DML sono vietate. No Per risolvere il problema, concedi a tutti gli utenti i privilegi SELECT per la vista.
VISIBLE|INVISIBLE (Oracle 12c) Specifica se una colonna basata sulla vista è visibile o invisibile all'utente. No Crea il VIEW solo con le colonne richieste.

L'esempio seguente illustra una conversione da Oracle a Cloud SQL per MySQL per le viste:

-- Create view to retrieve employees from department 100 using the WITH CHECK -- OPTION option
SQL> CREATE OR REPLACE FORCE VIEW vw_emp_dept100
AS
SELECT EMPLOYEE_ID,
       FIRST_NAME,
       LAST_NAME,
       SALARY,
       DEPARTMENT_ID
FROM EMPLOYEES
WHERE DEPARTMENT_ID=100
WITH CHECK OPTION;

-- Perform an UPDATE operation on the VIEW
SQL> UPDATE vw_emp_dept100
     SET salary=salary+1000;

mysql> CREATE OR REPLACE VIEW vw_emp_dept100
AS
SELECT EMPLOYEE_ID,
       FIRST_NAME,
       LAST_NAME,
       SALARY,
       DEPARTMENT_ID
FROM EMPLOYEES
WHERE DEPARTMENT_ID=100
WITH CHECK OPTION;

-- Perform an UPDATE operation on the VIEW
mysql>  UPDATE vw_emp_dept100
        SET salary=salary+1000;

-- Update one employee department ID to 60
mysql> UPDATE vw_emp_dept100
       SET DEPARTMENT_ID=60
       WHERE EMPLOYEE_ID=110;

ERROR 1369 (HY000): CHECK OPTION failed 'HR.vw_emp_dept100'

Gestione dell'accesso alla vista

L'utente che fa riferimento a una vista deve avere le autorizzazioni SELECT, INSERT, UPDATE o DELETE appropriate, come faresti con una tabella normale. Per creare una vista, un utente deve avere tutti i privilegi necessari per utilizzare gli oggetti di primo livello a cui si fa riferimento nella vista (tabelle/visualizzazioni). Inoltre, un utente deve disporre dei privilegi per ciascuna colonna di riferimento nell'elenco SELECT della vista. I privilegi per tutti gli oggetti a cui si accede dalla vista vengono valutati in base ai privilegi dell'utente che crea la vista o dell'utente che la attiva, a seconda che SQL SECURITY sia impostato su DEFINER o INVOKER.

Passaggi successivi