MYSQL METADATA LOCK (MDL LOCK) Theorie und Sperrtyptest
MYSQL METADATA LOCK (MDL LOCK) Lerntheorie und SperrtyptestVorwort: Quellcode-Version: 5.7.14 1. Vorläufiges Verständnis MDL-Sperren in MySQL haben schon immer Kopfschmerzen bereitet. Wenn wir über Sperren sprechen, sprechen wir normalerweise über Lückensperren, nächste Schlüsselsperren, Zeilensperren usw. auf der unteren Ebene von INNODB. ----Auf der Ebene: MySQL SERVER-Ebene wird MDL LOCK tatsächlich bereits in der Funktion open_table erworben. Man kann sagen, dass es sich um die früheste erworbene LOCK-Struktur handelt Aufrufstapelrahmen:
#0 open_table_get_mdl_lock (thd=0x7fffd0000df0, ot_ctx=0x7fffec06fb00,
Tabellenliste=0x7fffd00067d8, Flags=0, mdl_ticket=0x7fffec06f950)
unter /root/mysql5.7.14/percona-server-5.7.14-7/sql/sql_base.cc:2789
#1 0x0000000001516e17 in open_table (thd=0x7fffd0000df0,
Tabellenliste = 0x7fffd00067d8, ot_ctx = 0x7fffec06fb00)
unter /root/mysql5.7.14/percona-server-5.7.14-7/sql/sql_base.cc:3237 ----Fehlercode bei der Deadlock-Erkennung:
2. Grundlegende wichtige Datenstrukturen (Klassen) und Konzepte 1. MDL-TYPMDL_INTENTION_EXCLUSIVE(IX) MDL_SHARED(S) MDL_SHARED_HIGH_PRIO(SH) MDL_SHARED_READ(SR) MDL_SHARED_WRITE(SW) MDL_SHARED_WRITE_LOW_PRIO(SWL) MDL_SHARED_UPGRADABLE (SU) MDL_SHARED_READ_ONLY (SRO) MDL_SHARED_NO_WRITE(SNW) MDL_SHARED_NO_READ_WRITE(SNRW) MDL_EXCLUSIVE(X) Jeder TYP wird später ausführlich getestet und die Erklärung im Quellcode wird am Ende gegeben. 2. MDL-NAMENSRAUM In MDL wird MDL_KEY durch NAMESPACE+DB+OBJECT_NAME dargestellt. Der sogenannte Namespace ist nicht wichtig. Nachfolgend finden Sie die Klassifizierung von NAMESPACE
- GLOBAL wird für die globale Lesesperre verwendet.
- TABLESPACE ist für Tablespaces.
- SCHEMA ist für Schemata (auch bekannt als Datenbanken).
- TABLE ist für Tabellen und Ansichten.
- FUNCTION ist für gespeicherte Funktionen.
- PROCEDURE ist für gespeicherte Prozeduren.
- TRIGGER steht für Auslöser.
- EVENT ist für Event-Scheduler-Ereignisse.
- COMMIT dient zum Aktivieren der globalen Lesesperre, um Commits zu blockieren.
- USER_LEVEL_LOCK ist für Sperren auf Benutzerebene.
- LOCKING_SERVICE steht für das Namensplugin RW-Lock Service3. Klassifizierung implementieren Bereichssperre: entspricht im Allgemeinen der globalen
/**
Hilfsstruktur, die definiert, wie verschiedene Arten von Sperren behandelt werden
für einen bestimmten MDL_lock. In der Praxis verwenden wir nur zwei Strategien: „scoped“
Sperrstrategie für Sperren in den Namespaces GLOBAL, COMMIT, TABLESPACE und SCHEMA
und „Objekt“-Sperrstrategie für alle anderen Namespaces.
*/4. MDL-KompatibilitätsmatrixZielfernrohrverriegelung: | Art der aktiven | Anfrage | Bereichssperre | Typ | IS(*) IX SX | ---------+------------------+ IST | + + + + | + + - - | + - + - | X | + - - - | Objektsperre:
Anfrage | Gewährte Anfragen für Sperre |
Typ | S SH SR SW SWLP SU SRO SNW SNRW X |
----------+---------------------------------------------+
S |
SCH | + + + + + + + + + - |
SR | + + + + + + + + - - |
SW | + + + + + + - - - - |
+ + + + + + - - - - |
SO | + + + + + - + - - - |
SRO |
+ + + - - - + - - - |
+ + - - - - - - - - |
X | - - - - - - - - - - - |
5. Dauer der MDL und wann dauert die MDL?Siehe Quellcode-Kommentare:
MDL_STATEMENT: Sperren mit Anweisungsdauer werden am Ende automatisch freigegeben
der Abrechnung oder Transaktion.
MDL_TRANSACTION: Sperren mit Transaktionsdauer werden am Ende automatisch freigegeben
der Transaktion
MDL_EXPLICIT: Sperren mit expliziter Dauer überdauern das Ende der Anweisung und Transaktion.
Sie müssen explizit durch den Aufruf von MDL_context::release_lock() freigegeben werden.6. MDL LOCK FAST PATH (unaufdringlich) ODER SLOW PATH (aufdringlich) Der Zweck der Verwendung zweier unterschiedlicher Methoden besteht darin, die Implementierung der MDL-Sperre zu optimieren. Nachfolgend finden Sie die Kommentare im Quellcode.
A) „unauffällige“ Schlossarten
1) Jeder Typ aus diesem Set sollte mit allen anderen kompatibel sein
Typen aus dem Set (einschließlich sich selbst).
2) Diese Typen sollten für DML-Operationen üblich sein
Unser Ziel ist die Optimierung der Beschaffung und Freigabe von Sperren dieser
Typ durch Vermeidung komplexer Prüfungen und Manipulationen an m_waiting/
m_granted Bitmaps/Listen. Wir ersetzen sie durch eine Prüfung von und
Inkrementieren/Dekrementieren von Ganzzahlzählern.
Wir nennen die letztere Art der Erfassung/Freigabe „Fast Path“.
Die Verwendung des „Fast Path“ reduziert die Größe des kritischen Abschnitts
mit MDL_lock::m_rwlock Sperre im Normalfall und erhöht somit
Skalierbarkeit.
Der Betrag, um den der Erwerb/die Freigabe einer bestimmten Art
"unauffällige" Sperre erhöht/verringert gepackten Zähler in
MDL_lock::m_fast_path_state wird von dieser Funktion zurückgegeben.
B) „aufdringliche“ Schlossarten
1) Gewährte oder ausstehende Sperren dieser Art sind inkompatibel mit
einigen anderen Schlosstypen oder mit sich selbst.
2) Nicht üblich für DML-Operationen
Diese Schlösser müssen immer mit Manipulationen an
m_waiting/m_granted Bitmaps/Listen, d. h. wir müssen den „langsamen Pfad“ verwenden
für sie. Darüber hinaus bei Vorhandensein von aktiven/ausstehenden Sperren von
"aufdringliche" Menge, die wir mit "langsamen Pfaden" erwerben müssen, sogar Sperren von
"unaufdringlicher" Typ.7. MDL_request-KlasseDas heißt, die MDL LOCK-Anforderung muss nach der Anweisungsanalyse abgerufen werden. Anschließend wird die MDL LOCK-Anwendung im MDL-Subsystem über dieses Klassenobjekt ausgeführt, das wahrscheinlich die folgenden Eigenschaften enthält
/** Typ der Metadatensperre. */
enum enum_mdl_type Typ; //Erforderlicher Typ/** Dauer der angeforderten Sperre. */
enum enum_mdl_duration Dauer; //Dauer/**
Zeiger zur Teilnahme an der Liste der Sperranforderungen für diesen Kontext.
*/
MDL_request *next_in_list; //Implementierung einer doppelt verketteten Liste MDL_request **prev_in_list;
/**
Zeiger auf das Sperrticketobjekt für diese Sperranforderung.
Nur gültig, wenn dieser Sperranforderung entsprochen wird.
*/
MDL_ticket *ticket; //Beachten Sie, dass bei erfolgreicher Anwendung (keine Wartezeit) auf ein tatsächliches TICKET verwiesen wird, andernfalls ist es NULL
/** Eine Sperre wird basierend auf einem vollqualifizierten Namen und Typ angefordert. */
MDL_key key; //Beachten Sie, dass dies ein MDL_KEY-Typ ist. Das Wichtigste ist der oben erwähnte NAMESPACE+DB+OBJECT_NAME7. MDL_key-Klasse Es handelt sich um den tatsächlichen uint16 m_Länge; uint16 m_db_name_länge; char m_ptr[MAX_MDLKEY_LENGTH]; //Hier einfügen 8. MDL_ticket Wenn Sie MDL LOCK erwerben, müssen Sie wie bei einem Ticket ein Ticket an MDL_request zurückgeben. Wenn Sie warten, erhalten Sie kein MDL_context::acquire_lock
/**
Zeiger zur Teilnahme an der Liste der Sperranforderungen für diesen Kontext.
Kontext privat. Wie hier erklärt wird, ist die Bildung der verknüpften Liste im Kontext, der Thread privat ist*/
MDL_Ticket *nächstes_im_Kontext;
MDL_ticket **vorheriger_im_Kontext;
/**
Hinweise zur Aufnahme in die Liste der erfüllten/ausstehenden Anfragen
für das Schloss. Extern zugänglich. Wie hier erklärt ist die Bildung der verknüpften Liste in MDL_LOCK, die global ist */
MDL_Ticket *nächstes_in_Sperre;
MDL_ticket **vorheriges_in_Sperre;
/**
Kontext des Besitzers des Metadaten-Sperrtickets. Extern zugänglich.
Dies verweist offensichtlich auf den Besitzer des Tickets, nämlich MDL_context, ein Thread-Attribut*/
MDL_Kontext *m_ctx;
/**
Zeiger auf das Sperrobjekt für dieses Sperrticket. Extern zugänglich.
Offensichtlich ist dies ein Zeiger auf MDL_LOCK*/
MDL_lock *m_lock;
/**
Zeigt an, dass das Ticket einer Sperre entspricht, die über den „Fast Path“ erworben wurde
Algorithmus. Dies bedeutet insbesondere, dass er nicht in
MDL_lock::m_granted bitmap/list und wird stattdessen berücksichtigt durch
MDL_lock::m_fast_path_locks_granted_counter
Dies gibt an, ob es sich um FAST PATH handelt. Aus den Kommentaren geht hervor, dass die Fast-Path-Methode die gewährte Bitmap und die verknüpfte Liste in MDL LOCK nicht belegt. Stattdessen wird ein Zähler m_fast_path_locks_granted_counter verwendet.
So sind die Kosten auf jeden Fall geringer*/
bool m_ist_fast_path;
/**
Zeigt an, dass das Ticket einer Sperranforderung entspricht, die
Speicher-Engine-Benachrichtigung während der Übernahme und erfordert
Speicher-Engine-Benachrichtigung nach ihrer Veröffentlichung.
*/
bool m_hton_notified;
9. MDL_SperreJeder MDL_key entspricht einem MDL_lock, der die sogenannte GRANTED-Verknüpfungsliste und die WAIT-Verknüpfungsliste enthält. Angesichts der Komplexität können Sie direkt auf die Quellcodekommentare verweisen, die ebenfalls sehr detailliert sind. Hier sind die verschiedenen Eigenschaften, die ich beschrieben habe. /** Der Schlüssel des zu schützenden Objekts (Daten). */ MDL_key-Schlüssel; /** Liste der gewährten Tickets für dieses Schloss. */ Ticketliste m_zuerkannt; /** Tickets für Kontexte, die auf die Erlangung einer Sperre warten. */ Ticketliste m_waiting; 10. MDL_KontextDies ist eine sogenannte Kontextstruktur für die Interaktion des gesamten MySQL-Threads mit dem MDL-Sperrsubsystem. Sie enthält viele Methoden und Eigenschaften. Die Eigenschaften, die mich mehr interessieren, sind die folgenden:
/**
Wenn unsere Anfrage für eine Sperre geplant ist oder durch den Deadlock abgebrochen wird
Detektor, das Ergebnis wird in dieser Klasse aufgezeichnet.
*/
MDL_warten m_warten;
/**
Listen aller über diese Verbindung erworbenen MDL-Tickets.
Dies ist ein verknüpftes Listenarray mit unterschiedlichen MDL-Sperrdauern. Tatsächlich handelt es sich um eine verknüpfte Liste von MDL_STATEMENT, eine verknüpfte Liste von MDL_TRANSACTION und eine verknüpfte Liste von MDL_EXPLICIT*/
Ticketliste m_tickets[MDL_DURATION_END];
//Dies ist ein Zeiger der übergeordneten Klasse, der auf ein Objekt der untergeordneten Klasse zeigt, ein typisches Beispiel für das Überschreiben virtueller Funktionen. Tatsächlich zeigt er auf einen Thread/*
Klasse THD: öffentlicher MDL_context_owner,
öffentliche Query_arena,
öffentlicher Open_tables_state
*/
MDL_Kontextbesitzer *m_owner;
11. MDL_wait Diese Klasse enthält hauptsächlich den aktuellen Ticketerwerbsstatus enum_wait_status m_wait_status; Enthalten:
12. Warten auf das Ziel
PSI_stage_info MDL_Schlüssel::m_Namespace_to_wait_state_name[NAMESPACE_END]=
{
{0, "Warten auf globale Lesesperre", 0},
{0, "Warten auf Sperre der Tablespace-Metadaten", 0},
{0, "Warten auf Schema-Metadatensperre", 0},
{0, "Warten auf Sperre der Tabellenmetadaten", 0},
{0, "Warten auf Sperre der gespeicherten Funktionsmetadaten", 0},
{0, "Warten auf Sperre der Metadaten der gespeicherten Prozedur", 0},
{0, "Warten auf Trigger-Metadatensperre", 0},
{0, "Warten auf Sperre der Ereignismetadaten", 0},
{0, "Warten auf Commit-Sperre", 0},
{0, "Benutzersperre", 0}, /* Mit altem Status kompatibel sein. */
{0, "Warten auf Sperren des Service-Locks", 0},
{0, "Warten auf Backup-Sperre", 0},
{0, "Warten auf Binlog-Sperre", 0}
};3. MDL LOCK-Druckfunktion hinzufügen Der beste Weg, MDL LOCK zu studieren, besteht darin, den Prozess des Sperrens, Aktualisierens und Herabstufens von MDL zu verstehen. Da der Quellcode zu groß ist, ist es unmöglich, alles abzudecken. Obwohl 5.7 die folgende Methode zur Ansicht hinzufügt
Es ist jedoch immer noch schwierig zu überprüfen, welche MDL-LOCKs eine Anweisung erhalten hat. Daher habe ich mdl.cc einen Funktionsprototyp wie folgt hinzugefügt :
Und in der Klasse Die folgenden Informationen zu MDL LOCK werden hauptsächlich abgerufen und im MySQL-Fehlerprotokoll gedruckt: Die Ausgabeinformationen lauten wie folgt:
Tatsächlich sind die Informationen denen in
mysql> wähle * aus performance_schema.metadata_locks\G
*************************** 1. Reihe ***************************
OBJECT_TYPE: TABELLE
OBJECT_SCHEMA: Test
OBJEKTNAME: Test
OBJECT_INSTANCE_BEGIN: 140734412907760
SPERRTYP: SHARED_WRITE
LOCK_DURATION: TRANSAKTION
LOCK_STATUS: GEWÄHRT
QUELLE: sql_parse.cc:6314
Eigentümer-Thread-ID: 39
Eigentümer_Veranstaltungs-ID: 241
4. Fügen Sie an der entsprechenden Stelle eine Druckfunktion zur Beobachtung hinzu Da wir das Sperren, Upgraden und Downgraden von MDL LOCK untersuchen möchten, müssen wir deren Funktionseintrag finden und dann zur Beobachtung die Druckfunktion an der entsprechenden Stelle hinzufügen. Die Druckstelle ist unten markiert und der größte Teil des Quellcodes wurde gelöscht. Bitte beziehen Sie sich selbst darauf. Quellcode anzeigen: 1. Sperre: MDL_context::acquire_lock
bool
MDL_context::acquire_lock(MDL_request *mdl_request, ulong Sperrwartezeitüberschreitung)
{
if (mdl_request->ticket) //Ticket erfolgreich erhalten
{
/*
Es ist uns gelungen, die Sperre ohne Wartezeit zu erlangen.
MDL_lock, MDL_context und MDL_request wurden aktualisiert
Dementsprechend können wir den Erfolg einfach zurückgeben.
*/
//REQUESET erhält TICKET erfolgreich, print returniert hier FALSE;
}
/*
Unser Versuch, die Sperre zu erhalten, ohne zu warten, ist fehlgeschlagen.
Als Ergebnis dieses Versuchs erhielten wir MDL_ticket mit m_lock
Mitglied, das auf das entsprechende MDL_lock-Objekt zeigt, das
hat MDL_lock::m_rwlock schreibgesperrt.
*/
//Nicht erfolgreicher Erwerb, trete der MDL_lock-Warteschlange bei lock= ticket->m_lock;
Sperre->m_waiting.add_ticket(Ticket);
will_wait_for(ticket); //Deadlock-Erkennung/* Für das Objekt liegt eine gemeinsame oder exklusive Sperre vor. */
DEBUG_SYNC(get_thd(), "mdl_acquire_lock_wait");
deadlock_finden();
//Ticket hier ausdrucken und in den Wartevorgang einsteigen, wenn (Sperre->Notification(Ticket) || Sperre->Verbindungsprüfung())
{
}
done_waiting_for(); //Warten Sie, bis der Wartegraph zur Deadlock-Erkennung angepasst ist und entfernen Sie die Wartekante (ungerichteter Graph)
//Natürlich ist es hier nach einer Weile gelungen und der Status lautet GEWÄHRT
DBUG_ASSERT(Wartestatus == MDL_wait::GRANTED);
m_tickets[mdl_request->Dauer].push_front(Ticket);
mdl_request->ticket = Ticket;
mysql_mdl_set_status(Ticket->m_psi, MDL_Ticket::GEWÄHRT);
//Hier wird das TICKET gedruckt, das durch das Warten auf die ANFRAGE erhalten wurde
gibt FALSE zurück;
}
2. Herabstufungvoid MDL_ticket::downgrade_lock(enum_mdl_type neuer_typ)
void MDL_ticket::downgrade_lock(enum_mdl_type neuer_typ)
{
/* Erlaube nur Downgrades von EXCLUSIVE und SHARED_NO_WRITE. */
DBUG_ASSERT(m_type == MDL_EXCLUSIVE ||
m_type == MDL_SHARED_NO_WRITE);
//Drucken Sie das TICKET vor dem Downgrade hier aus
wenn (m_hton_notified)
{
mysql_mdl_set_status(m_psi, MDL_ticket::POST_RELEASE_NOTIFY);
m_ctx->get_owner()->notify_hton_post_release_exclusive(&m_lock->key);
m_hton_notified = falsch;
mysql_mdl_set_status(m_psi, MDL_ticket::GEWÄHRT);
}
//Das Ende der Funktion verspricht die Ausgabe des herabgestuften TICKET
}
3. Upgrade
bool
MDL_context::upgrade_shared_lock(MDL_ticket *mdl_ticket,
enum_mdl_type neuer_Typ,
ulong Sperre_Wartezeitüberschreitung)
{
MDL_REQUEST_INIT_BY_KEY(&mdl_neue_Sperranforderung,
&mdl_ticket->m_lock->key, neuer_Typ,
MDL_TRANSACTION); //Eine Anfrage erstellen
//Der hier ausgedruckte TICKET-Typ, wenn (acquire_lock(&mdl_new_lock_request, lock_wait_timeout)) //Versuchen Sie, mit dem neuen LOCK_TYPE zu sperren DBUG_RETURN(TRUE);
ist_neues_Ticket = ! hat_Sperre(mdl_svp, mdl_new_lock_request.ticket);
Sperre = mdl_ticket->m_lock;
//Es folgt eine Reihe von Wartungsarbeiten an MDL_LOCK und der sogenannten Zusammenführungsoperation./* Der folgende Code geht davon aus, dass wir auf den Sperrtyp „aufdringlich“ aktualisiert haben. */
DBUG_ASSERT(Sperre->ist_aufdringliche_Sperre(neuer_Typ));
/* Die erworbene und die ursprüngliche Sperre zusammenführen. @todo: Zu einer Methode wechseln. */
mysql_prlock_wrlock(&lock->m_rwlock);
if (ist_neues_Ticket)
{
m_tickets[MDL_TRANSACTION].entfernen(mdl_new_lock_request.ticket);
MDL_ticket::zerstören(mdl_new_lock_request.ticket);
}
//Der aktualisierte TICKET-Typ wird hier gedruckt DBUG_RETURN(FALSE);
}
Natürlich drucke ich jetzt nur an diesen Stellen. Bei Bedarf kann ich in Zukunft auch an anderen Stellen Funktionen hinzufügen. 5. Verschiedene MDL LOCK TYPE Sperrtests1. MDL_INTENTION_EXCLUSIVE (IX) Diese Sperre tritt bei vielen Vorgängen auf und wird beispielsweise durch jeden DML/DDL-Vorgang ausgelöst. Unten sehen Sie die GLOABLIX MDL LOCK, die durch DELETE ausgelöst wurde
Nachfolgend sehen Sie die GLOABLIX MDL LOCK und die SCHEMA-level MDL LOCK, die durch die ALETER-Anweisung ausgelöst werden.
2. MDL_SHARED(S)
mysql> Tabellen mit Lesesperre leeren; Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)
Wir stellen fest, dass ihr Namensraum GLOBAL ist und COMMIT offensichtlich SCOPED LOCK ist und ihr TYPE S ist. Daher ist es offensichtlich, dass gemäß dem Kompatibilitätsprinzip 3. MDL_SHARED_HIGH_PRIO (SH)Dieses Schloss wird grundsätzlich von jedem häufig verwendet, aber Sie spüren es nicht. Beispielsweise verwenden wir normalerweise die desc-Operation Kompatibilität:
Anfrage | Gewährte Anfragen für Sperre |
Typ | S SH SR SW SWLP SU SRO SNW SNRW X |
----------+---------------------------------------------+
SCH | + + + + + + + + + - |
mysql> Beschreibung test.testsort10;
Dieser Typ hat eine höhere Priorität, ist aber mit X inkompatibel. Es ist auch leicht zu verstehen, dass beispielsweise der Desc-Vorgang während der Umbenennungsphase nicht ausgeführt werden kann. 4. MDL_SHARED_READ(SR)
Kompatibilität:
Anfrage | Gewährte Anfragen für Sperre |
Typ | S SH SR SW SWLP SU SRO SNW SNRW X |
----------+---------------------------------------------+
SR | + + + + + + + + - - |
mysql> wähle * aus test.testsort10, Limit 1;
5. MDL_SHARED_WRITE (SW)
Kompatibilität:
Anfrage | Gewährte Anfragen für Sperre |
Typ | S SH SR SW SWLP SU SRO SNW SNRW X |
----------+---------------------------------------------+
SW | + + + + + + - - - - |
mysql> wähle * aus test.testsort10, Limit 1 für Update;
6. MDL_SHARED_WRITE_LOW_PRIO (SWL) Diese Sperre wird selten verwendet. Nur Quellcodekommentare Kompatibilität:
Anfrage | Gewährte Anfragen für Sperre |
Typ | S SH SR SW SWLP SU SRO SNW SNRW X |
----------+---------------------------------------------+
+ + + + + + - - - - |
mysql> aktualisiere LOW_PRIORITY test.testsort10, setze id1=1000, wobei id1= 96282;
7. MDL_SHARED_UPGRADABLE (SU) Diese Sperre wird normalerweise in der Anweisung ALTER TABLE verwendet. Sie kann auf SNW, SNRW, X hochgestuft werden, und zumindest die X-Sperre kann auf SU herabgestuft werden. Kompatibilität:
Anfrage | Gewährte Anfragen für Sperre |
Typ | S SH SR SW SWLP SU SRO SNW SNRW X |
----------+---------------------------------------------+
SO | + + + + + - + - - - |
Wir müssen die Kompatibilität untersuchen. Wir können sehen, dass (SELECT)SR (DML)SW alle in OBJECT LOCK zulässig sind. In SCOPED LOCK sind DML DDL zwar in GLOBAL gesperrt, aber ihre Typen sind alle IX, sodass diese SU-Sperre die Lese- und Schreibvorgänge von DML/SELECT nicht blockiert.
Wie die folgende Aussage mysql> Tabelle ändern, testsort12, Spalte hinzufügen, int nicht null; Abfrage OK, 0 Zeilen betroffen (6,27 Sek.) Datensätze: 0 Duplikate: 0 Warnungen: 0 Eine einfache Analyse:
Holen Sie sich zunächst die Tabelle Testsort12
Denn unabhängig davon, dass dieser Alterbetrieb noch zeitaufwändig ist 8. Mdl_Shared_no_write (SNW)
Kompatibilität:
Anfrage |.
Typ |.
----------+------------------------------------------+
SNW |.
Sie können sehen, dass SR aber SW nicht.
9. Mdl_Shared_read_only (SRO)
Die Kompatibilität ist wie folgt
Anfrage |.
Typ |.
----------+------------------------------------------+
Sro |.
Blöcke DML (SW), aber ausgewählt (SR) ist noch möglich.
10. mdl_shared_no_read_write (SNRW)
Kompatibilität:
Anfrage |.
Typ |.
----------+------------------------------------------+
Snrw |.
Es ist ersichtlich, dass DML (SW) und Select (SR) blockiert sind, nur SH verfügbar ist und Desc (SH) ebenfalls erhältlich ist.
11. MDL_EXCLUSIVE (x) Wird für verschiedene DDL -Operationen verwendet, kommentiert als Create/Drop/ -umbenennen Tabellenoperationen. Kompatibilität:
Anfrage |.
Typ |.
----------+------------------------------------------+
X |.
Es gibt keine zufällige Blockierung von allem oben, aber es wird auch durch alles blockiert, wie z. B. die Säulenoperation hinzufügen.
6. Quellcodekommentare
enum enum_mdl_type {
/*
Eine ausschließliche Absicht, die nur für Scoped -Schlösser verwendet wird.
Der Eigentümer dieser Art von Schloss kann aktualisierbare exklusive Schlösser erwerben
Einzelne Objekte.
Kompatibel mit anderen IX -Schlössern, ist aber unvereinbar mit Scoped S und
X Locken.
*/
Mdl_intentention_exclusive = 0,,
/*
Ein gemeinsames Metadatenschloss.
In Fällen zu verwenden, wenn wir nur an Objektmetadaten interessiert sind
und es besteht keine Absicht, auf Objektdaten zuzugreifen (z. B. für gespeicherte
Routinen oder während der Vorbereitung vorbereitete Aussagen).
Wir verwenden diese Art von Schloss auch für offene Handler, seit Sperre
Von dieser Aussage erworbene Erklärung muss mit dem erworbenen Lock kompatibel sein
nach Sperrtabellen ... Schreibanweisung, dh SNRW (wir können nicht vorbeikommen
Erwerben von S -Schloss bei Handler ... OPENTIONEN und aktualisiert es auf SR
Sperren Sie für Handler ... Lesen Sie, da es kein Problem mit den Bedürfnissen löst
DML
Öffnen Sie den Handler in derselben Verbindung).
Um eine Deadlock zu vermeiden, die auftreten kann, wenn SNRW Lock auf aktualisiert wird
X Sperre für Tisch, auf der es ein aktives S -Schloss gibt, das im Besitz von Tisch gibt
Faden, der sich in der Reihe auf Tischebene im Besitz des Threads wartet
Durchführung von Upgrade Wir müssen Thr_abort_locks_for_thread () verwenden.)
Einrichtungen in einer solchen Situation.
Dieses Problem entsteht nicht für Sperren auf gespeicherten Routinen, wie wir es nicht tun
Verwenden Sie SNRW -Schlösser für sie.
Während der Vorbereitung von Anrufen als Schlösser auf Tischebene werden hier nicht erworben
Fall.
*/
Mdl_shared,
/*
Eine hochprioritäts gemeinsame Metadatenschloss.
Wird für Fälle verwendet, in denen keine Absicht besteht, auf Objektdaten zuzugreifen (dh
Daten in der Tabelle).
"Hohe Priorität" bedeutet, dass es im Gegensatz zu anderen gemeinsamen Schlössern gewährt wird
Ignorieren Sie anhängige Anfragen für exklusive Schlösser.
Fälle, in denen wir nur auf Metadaten und nicht auf Daten zugreifen müssen, z
Füllen Sie eine Tabelle Information_Schema.
Da SH -Lock mit SNRW Lock kompatibel ist, ist die Verbindung, die
Hält Sh Lock Lock nicht, um irgendeine Art von Tischebene zu erwerben
oder ROW-Ebene, da dies zu einem Deadlock führen kann
Wenn Sie SH -Sperren erwerben, sollte die Verbindung nicht auf andere warten
Ressource, da dies für X -Schlösser und ein Potenzial verhungern kann
Deadlock während des Upgrades von SNW oder SNRW auf X Lock (zB wenn die
Die Upgrade -Verbindung hält die Ressource, auf die gewartet wird).
*/
Mdl_shared_high_prio,
/*
Eine gemeinsame Metadatenschloss für Fälle, in denen die Absicht besteht, Daten zu lesen
vom Tisch.
Eine Verbindung, die diese Art von Schloss hält, kann Tabellenmetadaten lesen und lesen
Tabellendaten (nach Erfassen geeigneter Tabellen- und Zeilenebene-Sperren).
Dies bedeutet, dass man nur tl_read, tl_read_no_insert und erwerben kann und
Ähnliche Schlösser auf Tabellenebene auf der Tabelle, wenn man die SR-MDL-Sperre enthält.
Für Tabellen in Auswahl, Unterabfragen und Sperrtabelle verwendet werden ... lesen Sie
Aussagen.
*/
Mdl_shared_read,
/*
Eine gemeinsame Metadatenschloss für Fälle, in denen die Änderung der Absicht besteht
(und nicht nur lesen) Daten in der Tabelle.
Eine Verbindung, die SW -Sperre hält, kann Tabellenmetadaten lesen und ändern oder lesen
Tabellendaten (nach Erfassen geeigneter Tabellen- und Zeilenebene-Sperren).
Für die Änderung von Tabellen durch Einfügen, Aktualisieren, Löschen verwendet werden
Aussagen, aber keine Sperrentabelle ... Schreiben oder DDL)
Wählen Sie ... für das Update.
*/
Mdl_shared_write,
/*
Eine Version der MDL_SHARDEL -Write -Sperre, die eine geringere Priorität hat als
MDL_SHARD_READ_ONLY LOCKS.
Tabellen und Verwendung der Low_Priority -Klausel.
*/
Mdl_shared_write_low_prio,
/*
Ein aufrüstbares freigegebenes Metadatenschloss, das gleichzeitige Updates ermöglicht und
Reads von Tabellendaten.
Eine Verbindung, die diese Art von Schloss hält, kann Tabellenmetadaten lesen und lesen
Tabellendaten.
SRO -Schlösser.
Kann auf SNW, SNRW und X -Schlösser verbessert werden.
oder SNRW -Sperrdatenänderungen können frei erfolgen.
Für die erste Phase der Alter Tabelle verwendet werden.
*/
Mdl_shared_upgradable,
/*
Eine gemeinsam genutzte Metadatenschloss für Fälle, in denen wir Daten aus der Tabelle lesen müssen
und blockieren Sie alle gleichzeitigen Modifikationen (für Daten und Metadaten).
Verwendet von Lock Tables Read Anweisung.
*/
Mdl_shared_read_only,
/*
Ein aufrüstbares freigegebenes Metadatenschloss, das alle Versuche zum Aktualisieren blockiert
Tabellendaten, die Lesevorgänge ermöglichen.
Eine Verbindung, die diese Art von Schloss hält, kann Tabellenmetadaten lesen und lesen
Tabellendaten.
Kann auf X Metadata Lock verbessert werden.
Beachten Sie, dass, da diese Art von Schloss nicht mit SNRW oder SW kompatibel ist
Sperrtypen und erwerben geeignete Schlösser auf Motorebene zum Lesen
(TL_READ* Für MyISAM sollte freigegebene Zeilensperrungen in InnoDB sein) sein
korrigierenfrei.
Für die erste Phase der Alterentabelle verwendet werden, wenn Daten zwischen Daten kopieren
Tabellen, um eine gleichzeitige Auswahl aus der Tabelle zuzulassen, jedoch nicht Aktualisierungen.
*/
Mdl_shared_no_write,
/*
Ein aufrüstbares gemeinsames Metadatenschloss, das andere Verbindungen ermöglicht
Zugriff auf Tabellenmetadaten, aber keine Daten.
Es blockiert alle Versuche, Tabellendaten zu lesen oder zu aktualisieren, während es zulässig ist
Information_schema und Anfragen anzeigen.
Eine Verbindung, die diese Art von Schloss hält, kann Tabellenmetadaten modifizieren und
Tabellendaten lesen.
Kann auf X Metadata Lock verbessert werden.
Für Sperrtabellen Schreibanweisung verwendet werden.
Nicht kompatibel mit einem anderen Sperrtyp außer S und SH.
*/
Mdl_shared_no_read_write,
/*
Ein exklusives Metadatenschloss.
Eine Verbindung, die diese Sperre hält, kann die Metadaten und die Daten beider Tabellen ändern.
Während dieses Schlosses kann keine andere Art von Metadatenschloss gewährt werden.
Zum Erstellen/Drop-/Umbenennen von Tabellenanweisungen und zur Ausführung von verwendet werden
Bestimmte Phasen anderer DDL -Anweisungen.
*/
Mdl_exclusive,
/ * Dies sollte der letzte sein !!! */
Mdl_type_end};
/** Dauer der Metadatenschloss.
enum enum_mdl_duration {
/**
Sperren mit Anweisungsdauer werden am Ende automatisch veröffentlicht
der Anweisung oder Transaktion.
*/
Mdl_statement = 0,,
/**
Schlösser mit Transaktionsdauer werden am Ende automatisch freigegeben
der Transaktion.
*/
Mdl_transaction,
/**
Schlösser mit explizitem Dauer überleben das Ende der Aussage und der Transaktion.
Sie müssen explizit veröffentlicht werden, indem sie mdl_context :: Release_lock () aufrufen.
*/
Mdl_explicit,
/ * Dies sollte der letzte sein!
Mdl_duration_end};
/**
Objekt -Namespaces.
SIC: Wenn Sie dieses Enum ein neues Mitglied hinzufügen
Aktualisieren Sie M_NameSpace_TO_WAIT_STATE_NAME -Array in MDL.
In verschiedenen Namespaces gibt es verschiedene Arten von Objekten
- Global wird für das Global Read Lock verwendet.
- Tablespace ist für Tablespaces.
- Schema ist für Schemas (auch bekannt als Datenbanken).
- Die Tabelle ist für Tabellen und Ansichten.
- Funktion ist für gespeicherte Funktionen.
- Verfahren ist für gespeicherte Verfahren.
- Trigger ist für Auslöser.
- Ereignis ist für Veranstaltungen für Veranstaltungen geeignet.
- Commit ist für die Ermöglichung des globalen Leseschloss, Commits zu blockieren.
- User_level_lock ist für Sperren von Benutzerebene.
- Locking_Service ist für den Namen Plugin RW-Lock-Service
Beachten
Es ist notwendig, einen separaten Namespace für sie zu haben
MDL_Key wird auch außerhalb des MDL -Subsystems verwendet.
Beachten Sie auch, dass das Warten auf Spezialverschlüsse auf Benutzerebene ist, um Spezial zu erhalten
Der Behandlungserweiter wird abgebrochen, wenn die Verbindung zum Klienten verloren geht.
*/
enum enum_mdl_namespace {global = 0,,
Tablespace,
SCHEMA,
TISCH,
FUNKTION,
VERFAHREN,
AUSLÖSEN,
EREIGNIS,
BEGEHEN,
User_level_lock,
Locking_service,
Backup,
Binlog,
/ * Dies sollte der letzte sein!
Namespace_end};
Die oben genannten Details der MySQL -Metadata -Sperre (MDL Lock) -Theorie und des Sperrenentyps. Das könnte Sie auch interessieren:
|
>>: Erfahren Sie, wie Sie mit dem Docker-Maven-Plugin die Bereitstellung automatisieren
Artikel empfehlen
Detaillierte Erklärung des JavaScript-Statuscontainers Redux
Inhaltsverzeichnis 1. Warum Redux 2. Redux-Datenf...
Das WeChat-Applet „Scroll-View“ implementiert eine Lösung zum doppelten Laden von Daten beim Hochziehen
In der Scroll-Ansicht des WeChat-Applets treten b...
Einige Details zu Semikolons in JavaScript
Vorwort Semikolons sind in JavaScript optional un...
Detaillierte Beispiele für Docker-Compose-Netzwerke
Ich habe heute mit den Netzwerkeinstellungen unte...
MySQL-Onlineprobleme mit langsamem Log und Optimierungslösungen
Das MySQL-Slow-Log ist ein Informationstyp, auf d...
Docker-Compose-Tutorial: Installation und Schnellstart
Inhaltsverzeichnis 1. Einführung in Compose 2. Co...
HTML-Tutorial: DOCTYPE-Abkürzung
Beim Schreiben von HTML-Code sollte die erste Zei...
Detaillierte grafische Beschreibung des Datenbankinstallationsprozesses der MySQL-Version 5.7.24
MySQL ist das beliebteste relationale Datenbankma...
So verwenden Sie uni-app, um Schaltflächen und Suchfelder in der oberen Navigationsleiste anzuzeigen
Vor Kurzem bereitete sich das Unternehmen auf die...
CentOS 6 Kompilieren und installieren Sie ZLMediaKit-Analyse
Installieren Sie ZLMediaKit auf centos6 Der Autor...
Eine Codezeile zeigt Ihnen, wie Sie Linux-Prozesse verbergen
Freunde fragen mich immer, wie man Linux-Prozesse...
Detaillierte Erklärung der MySQL EXPLAIN-Ausgabespalten
1. Einleitung Die EXPLAIN-Anweisung liefert Infor...
Detaillierte Analyse der MySQL-Sperrblockierung
Bei der täglichen Wartung werden Threads häufig b...
Mac+IDEA+Tomcat-Konfigurationsschritte
Inhaltsverzeichnis 1. Herunterladen 2. Installati...
MySQL5.7.27-winx64 Version Win10 Download- und Installations-Tutorial-Diagramm
MySQL 5.7-Installation Wir lernen in der Schule M...