Questo documento fa parte di una serie che fornisce informazioni chiave e indicazioni relative alla pianificazione e all'esecuzione delle migrazioni dei database Oracle® 11g/12c in Cloud SQL per MySQL versione 5.7, istanze di seconda generazione. La serie include le seguenti parti:
- Migrazione degli utenti Oracle a Cloud SQL per MySQL: terminologia e funzionalità (questo documento)
- Migrazione degli utenti Oracle a Cloud SQL per MySQL: tipi di dati, utenti e tabelle
- Migrazione degli utenti Oracle a Cloud SQL per MySQL: query, stored procedure, funzioni e trigger
- Migrazione degli utenti Oracle a Cloud SQL per MySQL: sicurezza, operazioni, monitoraggio e logging
Terminologia
Questa sezione descrive le somiglianze e le differenze nella terminologia dei database tra Oracle e Cloud SQL per MySQL. Esamina e confronta gli aspetti principali di ciascuna piattaforma di database. Il confronto fa una distinzione tra le versioni di Oracle 11g e 12c, a causa delle differenze di architettura (ad esempio, Oracle 12c introduce la funzionalità multi-tenant). La versione di Cloud SQL per MySQL a cui si fa riferimento qui è 5.7.x.
Differenze nella terminologia tra Oracle 11g e Cloud SQL per MySQL
Oracle 11g | Descrizione | Cloud SQL per MySQL | Differenze principali |
---|---|---|---|
Istanza | Una singola istanza Oracle 11g può contenere un solo database. | Istanza | Un'istanza MySQL può contenere più database. |
Database | Un database è idoneo come singola istanza (il nome del database è identico al nome dell'istanza). | Database | Più database o singoli database gestiscono più applicazioni. |
Schema | Schema e utenti sono identici perché entrambi sono considerati proprietari degli oggetti di database (un utente può essere creato senza specificare o essere allocato a uno schema). | Schema | Uno schema è definito database, mentre gli oggetti di database vengono creati in un determinato schema/database. |
User | Identici allo schema perché entrambi sono proprietari di oggetti di database, ad esempio istanza → database → schemi/utenti → oggetti di database. | User | Un utente di database con autorizzazioni specifiche per connettere o modificare gli oggetti di database su schemi/database specifici, ad esempio istanza → database/schemi → oggetti di database. |
Role | Set definito di autorizzazioni per il database che possono essere concatenate come gruppi e assegnate a utenti del database. | Privilegi MySQL | MySQL 5.7 non supporta la gestione dei ruoli. È possibile configurare le autorizzazioni utilizzando la clausola GRANT per concedere agli utenti privilegi sugli oggetti di database a diversi livelli (READ/WRITE e così via). |
Utenti amministratori/sistemi | Utenti amministratori Oracle con il più alto livello di accesso:SYS SYSTEM |
Utenti super | Dopo il deployment, Cloud SQL per MySQL ha l'utente root@'%' (può connettersi da qualsiasi host) e un altro utente di nome
mysql.sys , che può connettersi solo dal localhost. |
Dizionario/metadati | Oracle utilizza le seguenti tabelle di metadati:USER_TableName ALL_TableName DBA_TableName |
Dizionario/metadati | MySQL utilizza diversi database/schemi per dizionario/metadati:MYSQL INFORMATION_SCHEMA PERFORMANCE_SCHEMA SYSCiascuno di questi database è anche database di sistema e viene creato con ogni deployment di Cloud SQL per MySQL. |
Visualizzazioni dinamiche di sistema | Visualizzazioni dinamiche Oracle:V$ViewName |
Visualizzazioni dinamiche di sistema | Le visualizzazioni dinamiche MySQL sono disponibili in diversi database di sistema:INFORMATION_SCHEMA PERFORMANCE_SCHEMA SYS |
Spazio tabella | Le strutture di archiviazione logiche principali dei database Oracle; ogni spazio tabella può contenere uno o più file di dati. | Spazio tabella | Analogamente a Oracle, uno spazio tabella MySQL è un'unità logica, ma rappresenta solo una singola tabella, a differenza dello spazio tabella Oracle, che può avere più file di dati (contiene i dati per più tabelle). MySQL supporta la creazione di un nuovo spazio delle tabelle con un file di dati allocato e poi la creazione di una nuova tabella associata allo spazio delle tabelle appena creato. Tieni presente che le impostazioni di configurazione dello spazio delle tabelle, come dimensioni e limiti, vengono impostate utilizzando i parametri del database e non durante la creazione dello spazio delle tabelle. |
File di dati | Gli elementi fisici di un database Oracle che contengono i dati e sono definiti in uno spazio tabella specifico. Un singolo file di dati è definito dalla dimensione iniziale e massima e può contenere dati per più tabelle. I file di dati Oracle utilizzano il suffisso .dbf (non obbligatorio). |
File di dati | Cloud SQL per MySQL utilizza il parametro innodb_file_per_table con il valore "ON " (impostazione predefinita); questa configurazione genera un nuovo file di dati per ogni tabella e uno spazio tabella dedicato.I file di dati MySQL utilizzano file .ibd (di dati) e .frm (metadati). |
Spazio delle tabelle di sistema | Contiene le tabelle del dizionario dei dati e gli oggetti delle viste per l'intero database Oracle. | Spazio delle tabelle di sistema | Come per Oracle, contiene le tabelle di dizionario/metadati. Archiviata nello spazio tabella innodb_system allegato al file di dati ibdata1 . |
Spazio delle tabelle temporaneo | Contiene oggetti schema validi per la durata di una sessione; inoltre, supporta operazioni che non possono contenere spazio nella memoria del server. | Spazio delle tabelle temporaneo | Lo scopo è identico a quello di Oracle, archiviato nello spazio tabella MySQL innodb_temporary allegato al file di dati ibtmp1 . |
Annulla tablespace |
Uno speciale tipo di spazio delle tabelle permanente del sistema utilizzato da Oracle per gestire le operazioni di rollback durante l'esecuzione del database in modalità di gestione automatica dell'annullamento (impostazione predefinita). | Annulla spazio tabella | Analogamente a Oracle, l'opzione Annulla tablespace di MySQL contiene log di annullamento per scopi di rollback. Per impostazione predefinita, questa opzione è impostata su OFF e viene menzionata come obsoleta per le future release di MySQL. |
ASM | La gestione automatica dell'archiviazione Oracle è un file system e un gestore di dischi di database integrati ad alte prestazioni, tutti eseguiti automaticamente da un database Oracle configurato con ASM. | Funzionalità non supportata | MySQL utilizza il termine motori di archiviazione per descrivere diverse implementazioni di gestione dei dati, ma non supporta Oracle ASM. Cloud SQL per MySQL supporta molte funzionalità che forniscono l'automazione dell'archiviazione, come gli aumenti automatici dello spazio di archiviazione, le prestazioni e la scalabilità. |
Tabelle/visualizzazioni | Oggetti di database di base creati dall'utente. | Tabelle/visualizzazioni | Identico a Oracle. |
Viste materializzate | Definite con istruzioni SQL specifiche e possono essere aggiornate manualmente o automaticamente in base a configurazioni specifiche. | Non supportato da MySQL | Come soluzione alternativa, è possibile utilizzare trigger/visualizzazioni al posto delle viste materializzate Oracle. |
Sequenza | Generatore di valori univoci Oracle. | Incremento automatico | MySQL non supporta le sequenze Oracle. Utilizza AUTO_INCREMENT come soluzione alternativa alla funzionalità di generazione automatica delle sequenze. |
Sinonimo | Oggetti di database Oracle che fungono da identificatori alternativi per altri oggetti di database. | Funzionalità non supportata | MySQL non supporta il sinonimo Oracle; come soluzione alternativa, le viste possono essere utilizzate mentre l'impostazione delle autorizzazioni appropriate. |
Partizionamento | Oracle offre molte soluzioni di partizionamento per la suddivisione di tabelle di grandi dimensioni in parti gestite più piccole. | Partizionamento | MySQL supporta il partizionamento più limitato per migliorare le prestazioni, mantenendo al contempo operazioni di gestione e manutenzione dei dati, come le partizioni Oracle. |
Database Flashback | Caratteristica proprietaria di Oracle che può essere utilizzata per inizializzare un database Oracle a un intervallo di tempo definito in precedenza, permettendoti di eseguire query o di ripristinare i dati che sono stati modificati o danneggiati per errore. | Funzionalità non supportata | Per una soluzione alternativa, puoi utilizzare i backup di Cloud SQL e il ripristino point-in-time per ripristinare lo stato precedente di un database (ad esempio il ripristino prima dell'eliminazione della tabella). |
sqlplus | Interfaccia a riga di comando Oracle che consente di eseguire query e gestire l'istanza del database. | mysql | Interfaccia a riga di comando equivalente a MySQL per l'esecuzione di query e la gestione. Può essere collegato da qualsiasi client con le autorizzazioni appropriate a Cloud SQL. |
PL/SQL | Oracle ha esteso il linguaggio procedurale a SQL ANSI. | MySQL | MySQL ha un proprio linguaggio procedurale esteso con sintassi e implementazione diverse e non ha una denominazione aggiuntiva per questo linguaggio esteso. |
Corpo del pacco e della confezione | Funzionalità specifiche di Oracle per raggruppare le stored procedure e le funzioni sotto lo stesso riferimento logico. | Funzionalità non supportata | MySQL supporta stored procedure e funzioni come oggetti singoli con allocazione di gruppi. |
Archiviate procedure e funzioni | Utilizza PL/SQL per implementare la funzionalità di codice. | stored procedure e funzioni | La creazione di stored procedure e funzioni è supportata da MySQL con implementazione del linguaggio procedurale proprietario. |
Trigger | Oggetto Oracle utilizzato per controllare l'implementazione di DML sulle tabelle. | Trigger | Identico a Oracle. |
PFILE/SPFILE | I parametri a livello di istanza e database Oracle sono conservati in un file binario chiamato SPFILE (nelle versioni precedenti, il file si chiamava PFILE ), che può essere utilizzato come file di testo per impostare manualmente i parametri. |
Flag di database Cloud SQL per MySQL | Puoi impostare o modificare i parametri Cloud SQL per MySQL tramite l'utilità dei flag di database. Non puoi modificare i parametri del database in Cloud SQL per MySQL utilizzando l'interfaccia a riga di comando del client MySQL (ad esempio, mysql>
SET GLOBAL ... ). Puoi modificare questi parametri solo utilizzando l'utilità dei flag di database. |
SGA/PGA/AMM | Parametri di memoria Oracle che controllano l'allocazione della memoria all'istanza del database. |
INNODB_BUFFER_POOL_SIZE
|
MySQL ha parametri di memoria propri. Un parametro equivalente potrebbe essere INNODB_BUFFER_POOL_SIZE . In Cloud SQL per MySQL, questo parametro è predefinito in base al tipo di istanza scelto e il valore cambia di conseguenza. |
Cache dei risultati | Riduce le operazioni di I/O SQL recuperando le righe dalla cache del buffer, che può essere gestita utilizzando parametri di database e suggerimenti a livello di sessione. | Cache delle query | Ha lo stesso scopo fondamentale di Oracle Result Cache e può essere gestito a livello di database e di sessione. |
Suggerimenti per il database | Impatto controllato sulle istruzioni SQL che influenzano il comportamento dell'ottimizzatore per ottenere prestazioni migliori. Oracle offre oltre 50 hint di database diversi. | Suggerimenti per il database | MySQL supporta un set limitato di hint di database rispetto a Oracle (suggerimenti di ottimizzazione e indice). Ricorda che MySQL utilizza suggerimenti, sintassi e denominazione dei database. |
RMAN | Utilità Oracle Recovery Manager. Utilizzato per eseguire backup di database con funzionalità estesa per supportare più scenari di ripristino di emergenza e altro ancora (clonazione e così via). | Backup di Cloud SQL per MySQL | Cloud SQL per MySQL offre due metodi per applicare un backup completo: backup on demand e automatici. |
Pompa dati (EXPDP/IMPDP) | Utilità di generazione del dump Oracle che può essere utilizzata per molte funzionalità, come esportazione/importazione, backup del database (a livello di schema o oggetto), metadati di schema, generazione di file SQL di schema e altro ancora. | mysqldump/mysqlimport |
Utilità di dump (esportazione) MySQL che può essere connessa come client (da remoto) e generare un file di dump (SQL). Successivamente, puoi comprimere il file di dump
e spostarlo in Cloud Storage. L'utilità mysqldump è destinata solo
al passaggio dell'esportazione. |
SQL*Loader | Strumento che consente di caricare i dati da file esterni, come file di testo, file CSV e altro ancora. | mysqlimport/ |
L'utilità mysqlimport consente di caricare file di testo o CSV (Oracle supporta formati di file aggiuntivi) in una tabella di database con una struttura corrispondente. |
Protezione dei dati | Soluzione di ripristino di emergenza Oracle utilizzando un'istanza in standby, che consente agli utenti di eseguire operazioni "READ" dall'istanza in standby. | Alta disponibilità e replica di Cloud SQL per MySQL | Per ottenere il ripristino di emergenza o l'alta disponibilità, Cloud SQL per MySQL offre l'architettura della replica di failover e per le operazioni di sola lettura (separazione READ/WRITE) utilizzando la Replica di lettura. |
Active Data Guard/Golden Gate | Principali soluzioni di replica di Oracle, utili per vari scopi, come standby (RE), istanza di sola lettura, replica bidirezionale (multiorigine), data warehousing e altro ancora. | Replica di lettura di Cloud SQL per MySQL | Replica di lettura di Cloud SQL per MySQL per implementare il clustering con separazione READ/WRITE. Al momento, non è disponibile il supporto per la configurazione multi-origine, come la replica bidirezionale di Golden Gate o la replica eterogenea. |
RAC | Oracle Real Application Cluster. Soluzione di clustering proprietaria Oracle per fornire alta disponibilità eseguendo il deployment di più istanze di database con una singola unità di archiviazione. | Funzionalità non supportata | L'architettura multi-origine non è ancora supportata in Google Cloud Cloud SQL. Per ottenere l'architettura di clustering con la separazione READ/WRITE e l'alta disponibilità, utilizza l'alta disponibilità e la replica di lettura di Cloud SQL. |
Grid/Cloud Control (OEM) | Software Oracle per la gestione e il monitoraggio di database e altri servizi correlati in un formato di app web. È uno strumento utile per l'analisi dei database in tempo reale, al fine di comprendere carichi di lavoro elevati. | Console Cloud SQL per MySQL, Cloud Monitoring | Utilizza Cloud SQL per MySQL per il monitoraggio, inclusi grafici dettagliati basati su tempo e risorse. Utilizza Cloud Monitoring anche per l'archiviazione di metriche di monitoraggio specifiche e l'analisi dei log di MySQL per funzionalità di monitoraggio avanzate. |
RIPETI i log | Log delle transazioni Oracle costituiti da due (o più) file definiti preallocati in cui sono archiviate tutte le modifiche ai dati man mano che si verificano. Lo scopo del log di ripetizione è proteggere il database in caso di errore di un'istanza. | RIPETI i log | MySQL dispone anche di file di log di ripristino, che vengono utilizzati durante il ripristino in seguito a un arresto anomalo per correggere i dati scritti dal meccanismo dei log di ripristino di transazioni incomplete. |
Archiviare i log | I log di archiviazione forniscono supporto per operazioni di backup e replica e altro ancora. Oracle scrive nei log di archiviazione (se abilitati) dopo ogni operazione di ripristino dei log. | binlog | Implementazione di MySQL della conservazione dei log delle transazioni. Utilizzato principalmente a scopo di replica (attivato per impostazione predefinita con Cloud SQL). |
File di controllo | Il file di controllo Oracle contiene informazioni sul database, come file di dati, nomi e posizioni dei log di ripetizione, il numero di sequenza di log corrente e informazioni sul checkpoint dell'istanza. | MySQL | L'architettura MySQL non include un file di controllo simile all'implementazione Oracle. Ciò viene controllato attraverso i parametri MySQL e utilizzando il comando SHOW MASTER STATUS per visualizzare la posizione attuale del log binario. |
SCN | Oracle SCN (System Change Number) è il metodo principale per mantenere la coerenza dei dati da parte di tutti i componenti del database Oracle al fine di soddisfare il modello ACID della transazione. | Numero di sequenza del log | L'implementazione di MySQL per la coerenza del database utilizza il numero di sequenza di log (LSN). |
AWR | Oracle AWR (Automatic Workload Repository) è un report dettagliato che fornisce informazioni dettagliate sulle prestazioni delle istanze del database Oracle ed è considerato uno strumento di gestione del database per la diagnostica delle prestazioni. | performance_schema |
MySQL non dispone di un report equivalente a Oracle AWR, ma MySQL raccoglie
i dati sulle prestazioni raccolti da performance_schema . Una soluzione alternativa sarebbe utilizzare le dashboard delle prestazioni di MySQL Workbench. |
DBMS_SCHEDULER |
Utilità Oracle utilizzata per impostare e impostare il tempo delle operazioni predefinite. | EVENT_SCHEDULER |
Funzionalità di scheduler interno del database MySQL. Per impostazione predefinita, questa funzionalità è impostata su OFF . |
Crittografia dei dati trasparente | Cripta i dati archiviati sui dischi come protezione dei dati at-rest. | Cloud SQL Advanced Encryption Standard | Cloud SQL per MySQL utilizza l'algoritmo Advanced Encryption Standard (AES-256) a 256 bit per la protezione dei dati at-rest, nonché per i dati in transito |
Compressione avanzata | Per migliorare l'utilizzo dello spazio di archiviazione del database, ridurre i costi di archiviazione e migliorare le prestazioni del database, Oracle fornisce funzionalità di compressione avanzate per dati (tabelle/indici). | Compressione delle tabelle InnoDB | MySQL offre la compressione delle tabelle creando una tabella con il set di parametri ROW_FORMAT su COMPRESSED . Scopri di più sulla compressione dell'indice. |
Sviluppatore SQL | GUI SQL gratuita di Oracle per la gestione e l'esecuzione di istruzioni SQL e PL/SQL (può essere utilizzata anche con MySQL). | MySQL Workbench | GUI SQL gratuita di MySQL per la gestione e l'esecuzione di istruzioni di codice SQL e MySQL. |
Log avvisi | Log principale Oracle per errori e operazioni generali del database. | Log degli errori MySQL | Utilizza il visualizzatore dei log di Cloud Logging per visualizzare i log degli errori MySQL |
DUAL tabella |
Tabella speciale Oracle contenente principalmente per recuperare valori di pseudo colonne
come SYSDATE o
USER |
Tabella DUAL | MySQL consente di specificare DUAL come tabella nelle istruzioni SQL
che non dipendono dai dati di nessuna tabella. |
Tabella esterna | Oracle consente agli utenti di creare tabelle esterne con i dati di origine su file esterni al database. | Non supportata. | Nessun equivalente diretto. |
Listener | Processo di rete Oracle incaricato di esaminare le connessioni ai database in entrata | Reti autorizzate Cloud SQL | MySQL accetta le connessioni da origini remote una volta consentite nella pagina di configurazione Reti autorizzate di Cloud SQL |
TNSNAMES | File di configurazione di rete Oracle che definisce gli indirizzi di database per stabilire le connessioni tramite alias di connessione. | Inesistente | MySQL accetta connessioni esterne utilizzando il nome di connessione dell'istanza Cloud SQL o l'indirizzo IP privato/pubblico. Il proxy Cloud SQL è un ulteriore metodo di accesso sicuro per la connessione a Cloud SQL per MySQL (istanze di seconda generazione) senza dover consentire indirizzi IP specifici o configurare SSL. |
Porta predefinita dell'istanza | 1521 | Porta predefinita dell'istanza | 3306 |
Link al database | Oggetti schema Oracle che possono essere utilizzati per interagire con oggetti di database locali/remoti. | Funzionalità non supportata | Per una soluzione alternativa, utilizza il codice dell'applicazione per connetterti e recuperare i dati da un database remoto. |
Differenze nella terminologia tra Oracle 12c e Cloud SQL per MySQL
Oracle 12c | Descrizione | Cloud SQL per MySQL | Differenze principali |
---|---|---|---|
Istanza | La funzionalità multi-tenant introdotta nell'istanza Oracle 12c che può contenere più database come database modulare (PDB), al contrario di Oracle 11g, in cui un'istanza Oracle può ottenere un solo database. | Istanza | Cloud SQL per MySQL può gestire più database con diverse denominazioni, fornendo più servizi e applicazioni. |
CDB | Un database di container multi-tenant (CDB) può supportare uno o più PDB, mentre è possibile creare oggetti globali CDB (interessa tutti i PDB), ad esempio i ruoli. | Istanza MySQL | L'istanza MySQL è paragonabile a Oracle CDB. Entrambi forniscono un livello di sistema per i PDB. |
PDB | I PDB (database collegabili) possono essere utilizzati per isolare servizi e applicazioni l'uno dall'altro e come una raccolta portabile di schemi. | Database/schemi MySQL | Un database MySQL può gestire più servizi e applicazioni, nonché molti utenti di database. |
Sequenze di sessione | A partire da Oracle 12c, le sequenze possono essere create a livello di sessione (restituire valori univoci solo all'interno di una sessione) o a livello globale (ad esempio, quando si utilizzano tabelle temporanee). | Incremento automatico |
Le sequenze non sono supportate da MySQL, ma gli utenti possono utilizzare la proprietà della colonna AUTO_INCREMENT come soluzione alternativa. |
Colonne Identity | Il tipo IDENTITY di Oracle 12c genera una sequenza e la associa a una colonna di tabella senza dover creare manualmente un oggetto sequenza separato. |
Incremento automatico | Utilizza la proprietà della colonna AUTO_INCREMENT per simulare la stessa funzionalità della colonna identità Oracle 12c (una soluzione alternativa alla funzionalità di generazione automatica delle sequenze). |
Spartizionamento | Lo sharding Oracle è una soluzione in cui un database Oracle è partizionato in più database (shard) più piccoli per consentire scalabilità, disponibilità e distribuzione geografica per ambienti OLTP. | Non supportata (come funzionalità) | MySQL non ha una funzionalità dello sharding equivalente. Lo sharding può essere implementato utilizzando MySQL (come piattaforma dati) con un livello di applicazione di supporto. |
Database in memoria | Oracle offre una suite di funzionalità in grado di migliorare le prestazioni del database per OLTP e per carichi di lavoro misti. | Funzionalità non supportata | MySQL non ha una funzionalità equivalente. Puoi utilizzare Memorystore come alternativa. |
Oscuramento | Nell'ambito delle funzionalità di sicurezza avanzate di Oracle, l'oscuramento può eseguire il mascheramento delle colonne per impedire la visualizzazione di dati sensibili da parte di utenti e applicazioni. | Funzionalità non supportata | MySQL non ha una funzionalità equivalente. |
Funzionalità
Sebbene i database Oracle 11g/12c e Cloud SQL per MySQL funzionino su architetture diverse (infrastruttura e linguaggi procedurali estesi), condividono gli stessi aspetti fondamentali di un database relazionale. Supportano oggetti di database, carichi di lavoro di contemporaneità multiutente e transazioni (compatibilità ACID). Gestiscono inoltre i conflitti di blocco che supportano più livelli di isolamento (in base alle esigenze aziendali) e soddisfano i requisiti dell'applicazione continui come datastore relazionale per le operazioni OLTP (Online Transactional Processing) e per l'elaborazione analitica online (OLAP).
La seguente sezione fornisce una panoramica di alcune delle principali differenze funzionali tra Oracle e Cloud SQL per MySQL. In alcuni casi, ove necessario, la sezione include confronti tecnici dettagliati.
Creazione e visualizzazione dei database esistenti
Oracle 11g/12c | Cloud SQL per MySQL 5.7 |
---|---|
In genere, puoi creare database e visualizzare quelli esistenti utilizzando l'utilità Oracle Database Creation Assistant (DBCA). I database o le istanze creati manualmente richiedono di specificare parametri aggiuntivi:SQL> CREATE DATABASE ORADB USER SYS IDENTIFIED BY password USER SYSTEM IDENTIFIED BY password EXTENT MANAGEMENT LOCAL DEFAULT TEMPORARY TABLESPACE temp UNDO TABLESPACE undotbs1 DEFAULT TABLESPACE users; |
Usa un'istruzione nel formato CREATE DATABASE Name; , come
in questo esempio:
mysql> CREATE DATABASE MYSQLDB; |
Oracle 12c | Cloud SQL per MySQL 5.7 |
In Oracle 12c, puoi creare PDB dal seed, da un modello di database di container (CDB) o clonando un PDB da un PDB esistente. Puoi utilizzare diversi parametri:SQL> CREATE PLUGGABLE DATABASE PDB ADMIN USER usr IDENTIFIED BY passwd ROLES = (dba) DEFAULT TABLESPACE sales DATAFILE '/disk1/ora/dbs/db/db.dbf' SIZE 250M AUTOEXTEND ON FILE_NAME_CONVERT = ('/disk1/oracle/dbs/pdbseed/', '/disk1/oracle/dbs/salespdb/') STORAGE (MAXSIZE 2G) PATH_PREFIX = '/disk1/oracle/dbs/salespdb/'; |
Usa un'istruzione nel formato CREATE DATABASE Name; , come
in questo esempio:mysql> CREATE DATABASE MYSQLDB; |
Elenca tutti i PDB:SQL> SHOW is PDBS; |
Elenca tutti i database esistenti:mysql> SHOW DATABASES; |
Connettiti a un PDB diverso:SQL> ALTER SESSION SET CONTAINER=pdb; |
Connettiti a un altro database:mysql> use databaseName;In alternativa: mysql> \u databaseName; |
Apri o chiudi un PDB specifico (aperto/di sola lettura):SQL> ALTER PLUGGABLE DATABASE pdb CLOSE; |
Non supportato per un singolo database. Tutti i database si trovano nella stessa istanza Cloud SQL per MySQL, pertanto tutti i database sono attivi o inattivi. |
Gestione di un database tramite la console Cloud SQL
Nella console Google Cloud, vai a Archiviazione > SQL > Istanza > Database > Visualizza/crea.
Database e schemi di sistema
Le istanze di database Oracle ricevono determinati schemi di sistema, ad esempio SYS/SYSTEM
, con il ruolo di proprietario degli oggetti di metadati del database.
Al contrario, MySQL contiene diversi database di sistema (al contrario degli schemi Oracle), che gestiscono il livello dei metadati (tieni presente che i nomi dei database sono sensibili alle maiuscole):
-
Il database di sistema
mysql
contiene tabelle che archiviano le informazioni richieste dal server MySQL durante l'esecuzione, ad esempio:- Tabelle dei privilegi di sistema
- Tabelle di informazioni sugli oggetti
- Registra tabelle di sistema
- Tabelle di sistema di replica
- Tabelle di sistema dell'ottimizzatore
- Tabelle di sistema dei fusi orari
-
INFORMATION_SCHEMA
funge da dizionario dati principale del database e catalogo di sistema. Consente di accedere ai metadati del database, ovvero informazioni del database interno sul server MySQL, come il nome di un database o di una tabella, il tipo di dati della colonna e i privilegi di accesso. -
Un database di sistema che raccoglie informazioni statistiche sull'istanza MySQL. Il database di sistema
performance_schema
contiene metriche per il monitoraggio dell'esecuzione del server a un livello molto granulare. Lo schema fornisce l'ispezione dell'esecuzione interna del server in fase di esecuzione e può fungere da origine principale per l'analisi dei problemi di prestazioni del database.performance_schema
non è abilitato per impostazione predefinita utilizzando Cloud SQL per MySQL. Per abilitare lo schema, utilizza lo strumento a riga di comandogcloud
:gcloud sql instances patch INSTANCE_NAME --database-flags performance_schema=on
Per completare questa configurazione, è necessario riavviare l'istanza. Non puoi modificare il parametro
--database-flags
utilizzando la pagina dei flag di database di Cloud SQL per MySQL nella console Google Cloud. -
Lo schema
sys
esiste a partire dalla versione 5.5.7 di MySQL e contiene principalmente visualizzazioni nelle tabelle di sistemaperformance_schema
. Questo schema fornisce un insieme più leggibile di viste che riepilogano i dati diperformance_schema
in un formato più facilmente comprensibile. Lo schemasys
include anche diverse procedure e funzioni archiviate per eseguire operazioni come la configurazione diperformance_schema
e la generazione di report diagnostici.Lo schema
sys
mostra informazioni solo quandoperformance_schema
è abilitato.
Visualizzazione dei metadati e delle visualizzazioni dinamiche del sistema
Questa sezione fornisce una panoramica di alcune delle tabelle di metadati e delle visualizzazioni dinamiche di sistema più comuni utilizzate in Oracle e degli oggetti di database corrispondenti in Cloud SQL per MySQL versione 5.7.
Oracle offre centinaia di tabelle e visualizzazioni di metadati di sistema, mentre MySQL ne contiene solo diverse dozzine. Per ogni caso, può esistere più di un oggetto di database, con uno scopo specifico.
Oracle offre diversi livelli di oggetti di metadati, ognuno dei quali richiede privilegi diversi:
USER_TableName
: può essere visualizzato dall'utente.ALL_TableName
: può essere visualizzato da tutti gli utenti.DBA_TableName
: può essere visualizzata solo dagli utenti con il privilegio DBA, comeSYS
eSYSTEM
.
Per le viste prestazioni dinamiche, Oracle utilizza i prefissi V$
e GV$
. Affinché un utente MySQL possa visualizzare le tabelle o le viste di metadati di sistema, deve disporre di autorizzazioni specifiche per gli oggetti di sistema. Per ulteriori informazioni sulla sicurezza, consulta la sezione Sicurezza.
Tipo di metadati | Tabella/visualizzazione Oracle | Tabella/visualizzazione/mostra MySQL (CMD MySQL) |
---|---|---|
Sessioni aperte | V$SESSION |
SHOW PROCESSLIST INFORMATION_SCHEMA.PROCESSLIST performance_schema.threads |
Transazioni in corso | V$TRANSACTION |
INFORMATION_SCHEMA.INNODB_TRX |
Oggetti di database | DBA_OBJECTS |
Non supportati. Esegui una query su ogni oggetto in base al tipo. |
Tables | DBA_TABLES |
INFORMATION_SCHEMA.TABLES INFORMATION_SCHEMA.INNODB_SYS_TABLES |
Colonne della tabella | DBA_TAB_COLUMNS |
INFORMATION_SCHEMA.COLUMNS INFORMATION_SCHEMA.INNODB_SYS_COLUMNS |
Privilegi per tabelle e colonne | TABLE_PRIVILEGES DBA_COL_PRIVS ROLE_TAB_PRIVS |
INFORMATION_SCHEMA.COLUMN_PRIVILEGES |
Partizioni | DBA_TAB_PARTITIONS DBA_TAB_SUBPARTITIONS |
INFORMATION_SCHEMA.PARTITIONS SHOW CREATE TABLE TableName SHOW TABLE STATUS LIKE 'TableName' |
Visualizzazioni | DBA_VIEWS |
INFORMATION_SCHEMA.VIEWS |
Vincoli | DBA_CONSTRAINTS |
INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS SHOW CREATE TABLE TableName |
Indici | DBA_INDEXES DBA_PART_INDEXES |
INFORMATION_SCHEMA.STATISTICS INFORMATION_SCHEMA.INNODB_SYS_INDEXES INFORMATION_SCHEMA.KEY_COLUMN_USAGE |
Viste materializzate | DBA_MVIEWS |
Non supportata |
Archiviati procedure | DBA_PROCEDURES |
INFORMATION_SCHEMA.ROUTINES |
Funzioni archiviate | DBA_PROCEDURES |
INFORMATION_SCHEMA.ROUTINES |
Trigger | DBA_TRIGGERS |
INFORMATION_SCHEMA.TRIGGERS |
Utenti | DBA_USERS |
mysql.user |
Privilegi utente | DBA_SYS_PRIVS DBA_ROLE_PRIVS SESSION_PRIVS |
INFORMATION_SCHEMA.USER_PRIVILEGES |
Job/ Scheduler |
DBA_JOBS DBA_JOBS_RUNNING DBA_SCHEDULER_JOBS DBA_SCHEDULER_JOB_LOG |
INFORMATION_SCHEMA.EVENTS |
Spazi tabella | DBA_TABLESPACES |
INFORMATION_SCHEMA.INNODB_SYS_TABLESPACES |
File di dati | DBA_DATA_FILES |
INFORMATION_SCHEMA.FILES INFORMATION_SCHEMA.INNODB_SYS_DATAFILES |
Sinonimi | DBA_SYNONYMS |
Non supportata |
Sequenze | DBA_SEQUENCES |
Non supportata |
Link al database | DBA_DB_LINKS |
Non supportata |
Statistiche | DBA_TAB_STATISTICS DBA_TAB_COL_STATISTICS DBA_SQLTUNE_STATISTICS DBA_CPU_USAGE_STATISTICS |
INFORMATION_SCHEMA.STATISTICS INFORMATION_SCHEMA.KEY_COLUMN_USAGE SHOW INDEXES FROM TableName |
Serrature | DBA_LOCK DBA_DDL_LOCKS DBA_DML_LOCKS V$SESSION_BLOCKERS V$LOCKED_OBJECT |
INFORMATION_SCHEMA.INNODB_LOCKS INFORMATION_SCHEMA.INNODB_LOCK_WAITS INFORMATION_SCHEMA.INNODB_TRX performance_schema.metadata_locks performance_schema.rwlock_instances SHOW PROCESSLIST |
Parametri del database | V$PARAMETER V$NLS_PARAMETERS SHOW PARAMETER Param |
performance_schema.global_variables performance_schema.session_variables INFORMATION_SCHEMA.CHARACTER_SETS SHOW VARIABLES LIKE '%variable%'; |
Segmenti | DBA_SEGMENTS |
La tabella dei segmenti non è supportata. Esegui una query su ogni oggetto in base al tipo. |
Ruoli | DBA_ROLES DBA_ROLE_PRIVS USER_ROLE_PRIVS |
Roles not supported use instead: information_schema.COLUMN_PRIVILEGES information_schema.SCHEMA_PRIVILEGES information_schema.TABLE_PRIVILEGES information_schema.USER_PRIVILEGES mysql.columns_priv mysql.procs_priv mysql.proxies_priv mysql.tables_priv |
Cronologia delle sessioni | V$ACTIVE_SESSION_HISTORY DBA_HIST_* |
sys.statement_analysis performance_schema.events_stages_history performance_schema.events_stages_history_long performance_schema.events_statements_history performance_schema.events_statements_history_long performance_schema.events_transactions_history performance_schema.events_transactions_history_long performance_schema.events_waits_history performance_schema.events_waits_history_long |
Versione | V$VERSION |
sys.version SHOW VARIABLES LIKE '%version%'; |
Eventi di attesa | V$WAITCLASSMETRIC V$WAITCLASSMETRIC_HISTORY V$WAITSTAT V$WAIT_CHAINS |
performance_schema.events_waits_current performance_schema.events_waits_history performance_schema.events_waits_history_long sys.innodb_lock_waits sys.io_global_by_wait_by_bytes sys.io_global_by_wait_by_latency sys.schema_table_lock_waits sys.wait_classes_global_by_avg_latency sys.wait_classes_global_by_latency sys.waits_by_host_by_latency sys.waits_by_user_by_latency sys.waits_global_by_latency |
Ottimizzazione e analisi SQL |
V$SQL V$SQLAREA V$SESS_IO V$SYSSTAT V$STATNAME V$OSSTAT V$ACTIVE_SESSION_HISTORY V$SESSION_WAIT V$SESSION_WAIT_CLASS V$SYSTEM_WAIT_CLASS V$LATCH V$SYS_OPTIMIZER_ENV V$SQL_PLAN V$SQL_PLAN_STATISTICS |
performance_schema.events_statements_current performance_schema.events_statements_history performance_schema.events_statements_history_long sys.statement_analysis sys.host_summary_by_statement_latency sys.host_summary_by_statement_type sys.statements_with_errors_or_warnings sys.statements_with_full_table_scans sys.statements_with_runtimes_in_95th_percentile sys.statements_with_sorting sys.statements_with_temp_tables sys.user_summary_by_statement_latency sys.user_summary_by_statement_type slow-query-log general-log SHOW STATUS LIKE '%StatusName%'; |
Ottimizzazione della memoria dell'istanza |
V$SGA V$SGASTAT V$SGAINFO V$SGA_CURRENT_RESIZE_OPS V$SGA_RESIZE_OPS V$SGA_DYNAMIC_COMPONENTS V$SGA_DYNAMIC_FREE_MEMORY V$PGASTAT |
information_schema.INNODB_CMPMEM_RESET information_schema.INNODB_CMPMEM performance_schema.memory_summary_by_account_by_event_name performance_schema.memory_summary_by_host_by_event_name performance_schema.memory_summary_by_thread_by_event_name performance_schema.memory_summary_by_user_by_event_name performance_schema.memory_summary_global_by_event_name performance_schema.replication_group_member_stats performance_schema.replication_group_members sys.memory_by_host_by_current_bytes sys.memory_by_thread_by_current_bytes sys.memory_by_user_by_current_bytes sys.memory_global_by_current_bytes sys.memory_global_total |
Motori di archiviazione MySQL
A differenza di molti altri RDBMS (incluso Oracle), MySQL può funzionare in modo polimorfico grazie al suo sistema di archiviazione modulare. L'architettura del motore di archiviazione modulare MySQL consente a un amministratore di database di selezionare un motore di archiviazione specializzato per una particolare esigenza dell'applicazione.
Il componente del motore di archiviazione modulare MySQL nel server di database MySQL è responsabile dell'esecuzione delle operazioni di I/O dei dati, inclusa l'archiviazione dei dati nei dischi o nei buffer di memoria. L'architettura del motore di archiviazione modulare fornisce un set standard di servizi di gestione e assistenza comuni a tutti i motori di archiviazione sottostanti.
A partire dalla versione 5.5 di MySQL, il motore di archiviazione predefinito è il motore di archiviazione InnoDB, mentre InnoDB gestisce anche le tabelle temporanee. Puoi configurare i motori di archiviazione durante la tabella CREATE
o ALTER
, come nell'esempio seguente:
mysql> SHOW CREATE TABLE JOBS \G;
L'output è il seguente:
*************************** 1. row *************************** Table: JOBS Create Table: CREATE TABLE `JOBS` ( `JOB_ID` varchar(10) NOT NULL, `JOB_TITLE` varchar(35) NOT NULL, `MIN_SALARY` decimal(6,0) DEFAULT NULL, `MAX_SALARY` decimal(6,0) DEFAULT NULL, PRIMARY KEY (`JOB_ID`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8
Per ulteriori informazioni, consulta la pagina sui
motori di archiviazione diversi di MySQL.
Puoi visualizzare la configurazione del motore di archiviazione utilizzando la seguente query:
mysql> SHOW VARIABLES LIKE '%storage%';
L'output è simile al seguente:
+----------------------------------+--------+ | Variable_name | Value | +----------------------------------+--------+ | default_storage_engine | InnoDB | | default_tmp_storage_engine | InnoDB | | disabled_storage_engines | | | enforce_storage_engine | Innodb | | internal_tmp_disk_storage_engine | InnoDB | +----------------------------------+--------+
Puoi visualizzare tutti i motori di archiviazione integrati:
mysql> SHOW STORAGE ENGINES;
L'output è simile al seguente:
+--------------------+---------+----------------------------------------------------------------+--------------+------+------------+ | Engine | Support | Comment | Transactions | XA | Savepoints | +--------------------+---------+----------------------------------------------------------------+--------------+------+------------+ | CSV | YES | CSV storage engine | NO | NO | NO | | PERFORMANCE_SCHEMA | YES | Performance Schema | NO | NO | NO | | MRG_MYISAM | YES | Collection of identical MyISAM tables | NO | NO | NO | | BLACKHOLE | YES | /dev/null storage engine (anything you write to it disappears) | NO | NO | NO | | MyISAM | YES | MyISAM storage engine | NO | NO | NO | | FEDERATED | NO | Federated MySQL storage engine | NULL | NULL | NULL | | MEMORY | YES | Hash based, stored in memory, useful for temporary tables | NO | NO | NO | | InnoDB | DEFAULT | Supports transactions, row-level locking, and foreign keys | YES | YES | YES | +--------------------+---------+----------------------------------------------------------------+--------------+------+------------+
Tieni presente che InnoDB è il motore di archiviazione predefinito ed è l'unico motore di archiviazione a supportare le transazioni (conforme ACID). Poiché InnoDB è l'unico motore di archiviazione che si avvicina alle funzionalità di Oracle, ti consigliamo di utilizzare sempre InnoDB. Cloud SQL per MySQL di seconda generazione supporta solo il motore di archiviazione InnoDB.
Parametri di sistema
Entrambi i database Oracle e Cloud SQL per MySQL possono essere configurati in modo specifico per ottenere determinate funzionalità oltre alla configurazione predefinita. Per modificare i parametri di configurazione in Oracle, sono necessarie alcune autorizzazioni di amministrazione (principalmente le autorizzazioni utente SYS/SYSTEM
).
Di seguito è riportato un esempio di modifica della configurazione di Oracle utilizzando l'istruzione ALTER SYSTEM
. In questo esempio, l'utente modifica il parametro "Numero massimo di tentativi per accessi non riusciti" solo a livello di configurazione spfile
(la modifica è valida solo dopo un riavvio):
SQL> ALTER SYSTEM SET SEC_MAX_FAILED_LOGIN_ATTEMPTS=2 SCOPE=spfile;
Nell'esempio successivo, l'utente richiede di visualizzare semplicemente il valore del parametro Oracle:
SQL> SHOW PARAMETER SEC_MAX_FAILED_LOGIN_ATTEMPTS;
L'output è simile al seguente:
NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ sec_max_failed_login_attempts integer 2
La modifica dei parametri Oracle funziona in tre ambiti:
- SPFILE: le modifiche dei parametri vengono scritte in Oracle
spfile
, ma è necessario il riavvio dell'istanza affinché il parametro abbia effetto. - MEMORY: le modifiche dei parametri vengono applicate solo nel livello di memoria, mentre non è consentita la modifica di parametri statici.
- BOTH: le modifiche dei parametri vengono applicate sia nel file dei parametri del server sia nella memoria dell'istanza, dove non è consentita alcuna modifica dei parametri statici.
Flag di configurazione di Cloud SQL per MySQL
Puoi modificare i parametri di sistema di Cloud SQL per MySQL utilizzando i flag di configurazione nella console Google Cloud, gcloud CLI o CURL. Consulta l'elenco completo di tutti i parametri supportati da Cloud SQL per MySQL che puoi modificare.
I parametri MySQL possono essere suddivisi in diversi ambiti:
- Parametri dinamici: possono essere modificati in fase di esecuzione.
- Parametri statici: per applicare il riavvio è necessario che l'istanza venga riavviata.
- Parametri globali: hanno effetto globale su tutte le sessioni attuali e future.
- Parametri di sessione: possono essere modificati a livello di sessione solo per la durata della sessione corrente, isolati dalle altre sessioni.
Il parametro di memoria di Cloud SQL per MySQL innodb_buffer_pool_size
(uno dei parametri fondamentali da considerare durante la pianificazione e il dimensionamento di un ambiente MySQL) è determinato dal tipo di istanza e non può essere modificato utilizzando i flag di configurazione o qualsiasi altro metodo, ad esempio:
- Il tipo di istanza
db-n1-standard-1
ha 1,4 GB di allocazione della memoria. - Il tipo di istanza
db-n1-highmem-8
ha 38 GB di memoria allocata.
Esempi di modifica dei parametri di Cloud SQL per MySQL
Console
Utilizza la console Google Cloud per abilitare il parametro event_scheduler
.
Vai alla pagina Modifica istanza di Cloud Storage.
In Flag, fai clic su Aggiungi elemento e cerca
event_scheduler
come nello screenshot seguente.
gcloud
Utilizza gcloud CLI per abilitare il parametro
event_scheduler
.gcloud sql instances patch INSTANCE_NAME \ --database-flags event_scheduler=on
L'output è il seguente:
WARNING: This patch modifies database flag values, which may require your instance to be restarted. Check the list of supported flags - /sql/docs/mysql/flags - to see if your instance will be restarted when this patch is submitted. Do you want to continue (Y/n)?
Sessione MySQL
Disattiva la modalità AUTOCOMMIT
a livello di sessione. Questa modifica rimane in vigore per la sessione corrente e si applica solo per la sua durata.
Mostra variabili come
autocommit
:mysql> SHOW VARIABLES LIKE '%autoc%';
Vedrai il seguente output, dove
autocommit
èON
:+---------------+-------+ | Variable_name | Value | +---------------+-------+ | autocommit | ON | +---------------+-------+
Disattiva
autocommit
:mysql> SET autocommit=off;
Mostra variabili come
autocommit
:mysql> SHOW VARIABLES LIKE '%autoc%';
Vedrai il seguente output, dove
autocommit
èOFF
:+---------------+-------+ | Variable_name | Value | +---------------+-------+ | autocommit | OFF | +---------------+-------+
Transazioni e livelli di isolamento
Questa sezione descrive le principali differenze tra Oracle e Cloud SQL per MySQL in relazione alle migrazioni a livello di transazione e isolamento.
Modalità di commit
Per impostazione predefinita, Oracle funziona in modalità non di commit automatico, in cui ogni transazione DML deve essere determinata con istruzioni COMMIT/ROLLBACK
. Una delle differenze fondamentali tra Oracle e MySQL è che MySQL funziona per impostazione predefinita in modalità di commit automatico e ogni transazione DML viene eseguita automaticamente specificando esplicitamente le istruzioni COMMIT/ROLLBACK
.
Per forzare il funzionamento di MySQL in modalità non di commit automatico, sono disponibili diverse opzioni:
- Quando gestisci le transazioni nell'ambito delle stored procedure, utilizza la clausola
START TRANSACTION
per attivare la stessa modalità di transazione di Oracle. Utilizza la seguente istruzione per impostare il parametro di sistema
autocommit
suOFF
a livello di sessione e utilizzare esplicitamente le istruzioniCOMMIT/ROLLBACK
nelle transazioni DML:mysql> SET autocommit=off;
Livelli di isolamento
Lo standard ANSI/ISO SQL (SQL92) definisce quattro livelli di isolamento. Ogni livello offre un approccio diverso per la gestione dell'esecuzione contemporanea di transazioni del database:
- Lettura senza commit: una transazione attualmente elaborata può visualizzare i dati di cui non è stato eseguito il commit. Se viene eseguito un rollback, tutti i dati vengono ripristinati allo stato precedente.
- Lettura impegnata: una transazione vede solo le modifiche ai dati di cui è stato eseguito il commit; le modifiche di cui non è stato eseguito il commit("letture sporche") non sono possibili.
- Lettura ripetibile: una transazione può visualizzare le modifiche apportate dall'altra
transazione solo dopo il rollback di entrambe le transazioni che hanno emesso un
COMMIT
. - Serializzabile: il livello di isolamento più rigoroso/più forte. Questo livello blocca tutti i record a cui viene eseguito l'accesso e blocca la risorsa in modo che non sia possibile aggiungere record alla tabella.
I livelli di isolamento delle transazioni gestiscono la visibilità dei dati modificati come vengono visti da altre transazioni in esecuzione. Inoltre, quando più transazioni simultanee accedono agli stessi dati, il livello di isolamento delle transazioni selezionato influisce sul modo in cui le diverse transazioni interagiscono.
Oracle supporta i seguenti livelli di isolamento:
- Impegno di lettura (impostazione predefinita)
- Serializzabile
- Sola lettura (non fa parte dello standard ANSI/ISO SQL (SQL92)
Oracle MVCC (Multiversion Concurrency Control):
- Oracle utilizza il meccanismo MVCC per fornire coerenza automatica di lettura nell'intero database e in tutte le sessioni.
- Oracle si basa sul numero di modifica del sistema (SCN) della transazione corrente per ottenere una visualizzazione coerente del database; pertanto, tutte le query del database restituiscono solo i dati impegnati in relazione alla SCN al momento dell'esecuzione della query.
- I livelli di isolamento possono essere modificati a livello di transazione e sessione.
Ecco un esempio di impostazione dei livelli di isolamento:
-- Transaction Level
SQL> SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
SQL> SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
SQL> SET TRANSACTION READ ONLY;
-- Session Level
SQL> ALTER SESSION SET ISOLATION_LEVEL = SERIALIZABLE;
SQL> ALTER SESSION SET ISOLATION_LEVEL = READ COMMITTED;
Cloud SQL per MySQL, come Oracle, supporta i seguenti quattro livelli di isolamento delle transazioni specificati nello standard ANSI SQL:92:
READ UNCOMMITTED
READ COMMITTED
REPEATABLE READ (default)
SERIALIZABLE
Il livello di isolamento predefinito di Cloud SQL per MySQL è REPEATABLE READ
. Tutti i nuovi dati saranno disponibili per entrambi solo dopo che entrambe le transazioni avranno emesso un comando COMMIT
. Questi livelli di isolamento possono essere modificati a livello di SESSION
e a livello di GLOBAL
(la modifica a livello globale è attualmente in fase beta utilizzando i flag di configurazione).
Per verificare i livelli di isolamento attuali sia a livello di SESSION
che di GLOBAL
, utilizza
la seguente istruzione:
mysql> SELECT @@GLOBAL.tx_isolation, @@tx_isolation;
L'output è il seguente:
+-----------------------+-----------------+ | @@GLOBAL.tx_isolation | @@tx_isolation | +-----------------------+-----------------+ | REPEATABLE-READ | REPEATABLE-READ | +-----------------------+-----------------+
Puoi modificare la sintassi del livello di isolamento come segue:
SET [SESSION] TRANSACTION ISOLATION LEVEL [READ WRITE | READ ONLY]
| REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED | SERIALIZABLE]
Inoltre, puoi modificare il livello di isolamento a livello di SESSION
:
mysql> SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-- Verify
mysql> SELECT @@GLOBAL.tx_isolation, @@tx_isolation;
L'output è il seguente:
+-----------------------+------------------+ | @@GLOBAL.tx_isolation | @@tx_isolation | +-----------------------+------------------+ | REPEATABLE-READ | READ-UNCOMMITTED | +-----------------------+------------------+
Struttura delle transazioni di Cloud SQL per MySQL
Transazioni sintassi:
START TRANSACTION [transaction_characteristic [, transaction_characteristic] ...] |
---|
Le transazioni possono essere implementate con START TRANSACTION
o BEGIN
.
L'opzione WITH CONSISTENT SNAPSHOT
avvia una transazione READ
coerente,
che equivale a inviare un START TRANSACTION
, seguito da un
SELECT
da qualsiasi tabella. La clausola WITH CONSISTENT SNAPSHOT
che avvia un READ
coerente (un'operazione READ
che utilizza le informazioni degli snapshot per presentare i risultati delle query in base a un momento specifico) non modifica il livello di isolamento della transazione ed è supportata solo dal livello di isolamento REPEATABLE READ
.
Un READ
coerente utilizza le informazioni degli snapshot per rendere disponibili i risultati delle query in base a un dato point-in-time, indipendentemente dalle modifiche eseguite dalle transazioni simultanee. Se i dati oggetto di query sono stati modificati da un'altra transazione, i dati originali vengono ricostruiti utilizzando il log di annullamento. In questo modo, eviterai problemi di blocco che potrebbero ridurre la contemporaneità.
Con il livello di isolamento REPEATABLE READ
, lo snapshot si basa sull'ora in cui viene eseguita
la prima operazione READ
. Con il livello di isolamento READ COMMITTED
, lo snapshot viene reimpostato in base all'ora di ogni operazione READ
coerente.
Ecco un esempio di impostazione del livello di transazione e isolamento:
mysql> SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
mysql> START TRANSACTION;
mysql> INSERT INTO tbl1 VALUES (1, 'A');
mysql> UPDATE tbl2 SET col1 = 'Done' WHERE KeyColumn = 1;
mysql> COMMIT;