MySQL und MariaDB¶

Unterstützung für die MySQL / MariaDB Datenbank.

Die folgende Tabelle fasst die aktuellen Support-Level für Datenbank-Release-Versionen zusammen.

**Unterstützte MySQL / MariaDB-Versionen**¶
Support-Typ	Versionen
Supported version	5.6+ / 10+
Best effort	5.0.2+ / 5.0.2+

DBAPI-Unterstützung¶

Die folgenden Dialekt-/DBAPI-Optionen sind verfügbar. Bitte beachten Sie die einzelnen DBAPI-Abschnitte für Verbindungsinformationen.

mysqlclient (gepflegter Fork von MySQL-Python)
PyMySQL
MariaDB Connector/Python
MySQL Connector/Python
asyncmy
aiomysql
CyMySQL
PyODBC

Unterstützte Versionen und Funktionen¶

SQLAlchemy unterstützt MySQL ab Version 5.0.2 bis zu modernen Versionen sowie alle modernen Versionen von MariaDB. Detaillierte Informationen zu den in den einzelnen Serverversionen unterstützten Funktionen finden Sie in der offiziellen MySQL-Dokumentation.

Geändert in Version 1.4: Die unterstützte minimale MySQL-Version ist nun 5.0.2.

MariaDB-Unterstützung¶

Die MariaDB-Variante von MySQL behält eine grundlegende Kompatibilität mit den MySQL-Protokollen bei, die Entwicklung dieser beiden Produkte divergiert jedoch weiterhin. Im Bereich von SQLAlchemy gibt es eine geringe Anzahl von syntaktischen und Verhaltensunterschieden zwischen den beiden Datenbanken, die SQLAlchemy automatisch berücksichtigt. Um sich mit einer MariaDB-Datenbank zu verbinden, sind keine Änderungen an der Datenbank-URL erforderlich

engine = create_engine(
    "mysql+pymysql://user:pass@some_mariadb/dbname?charset=utf8mb4"
)

Bei der ersten Verbindung verwendet das SQLAlchemy-Dialekt ein Schema zur Erkennung der Serverversion, das ermittelt, ob die zugrunde liegende Datenbank als MariaDB gemeldet wird. Basierend auf dieser Kennzeichnung kann das Dialekt in den Bereichen, in denen sein Verhalten unterschiedlich sein muss, andere Entscheidungen treffen.

MariaDB-Only-Modus¶

Das Dialekt unterstützt auch einen **optionalen** „MariaDB-Only“-Modus für die Verbindung, der nützlich sein kann, wenn eine Anwendung MariaDB-spezifische Funktionen verwendet und nicht mit einer MySQL-Datenbank kompatibel ist. Um diesen Betriebsmodus zu verwenden, ersetzen Sie das Token „mysql“ in der obigen URL durch „mariadb“

engine = create_engine(
    "mariadb+pymysql://user:pass@some_mariadb/dbname?charset=utf8mb4"
)

Die obige Engine löst bei der ersten Verbindung einen Fehler aus, wenn die Erkennung der Serverversion feststellt, dass die zugrunde liegende Datenbank keine MariaDB ist.

Bei Verwendung einer Engine mit "mariadb" als Dialektnamen heißen **alle mysql-spezifischen Optionen, die den Namen „mysql“ enthalten, nun mit „mariadb“**. Das bedeutet, Optionen wie mysql_engine sollten mariadb_engine genannt werden usw. Sowohl „mysql“- als auch „mariadb“-Optionen können gleichzeitig für Anwendungen verwendet werden, die URLs mit sowohl „mysql“- als auch „mariadb“-Dialekten verwenden.

my_table = Table(
    "mytable",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("textdata", String(50)),
    mariadb_engine="InnoDB",
    mysql_engine="InnoDB",
)

Index(
    "textdata_ix",
    my_table.c.textdata,
    mysql_prefix="FULLTEXT",
    mariadb_prefix="FULLTEXT",
)

Ein ähnliches Verhalten tritt auf, wenn die obigen Strukturen reflektiert werden, d. h. der Präfix „mariadb“ ist in den Optionsnamen vorhanden, wenn die Datenbank-URL auf dem Namen „mariadb“ basiert.

Neu in Version 1.4: Der Dialektnamen „mariadb“ wurde hinzugefügt, der den „MariaDB-Only-Modus“ für das MySQL-Dialekt unterstützt.

Verbindungszeitüberschreitungen und Trennungen¶

MySQL / MariaDB verfügen über ein automatisches Schließverhalten für Verbindungen, die für eine feste Zeitspanne inaktiv waren, standardmäßig acht Stunden. Um dieses Problem zu umgehen, verwenden Sie die Option create_engine.pool_recycle, die sicherstellt, dass eine Verbindung verworfen und durch eine neue ersetzt wird, wenn sie für eine feste Anzahl von Sekunden im Pool vorhanden war.

engine = create_engine("mysql+mysqldb://...", pool_recycle=3600)

Für eine umfassendere Erkennung von getrennten Verbindungen im Pool, einschließlich der Berücksichtigung von Server-Neustarts und Netzwerkproblemen, kann ein Pre-Ping-Ansatz verwendet werden. Siehe Umgang mit Trennungen für aktuelle Ansätze.

Siehe auch

Umgang mit Trennungen - Hintergrund zu verschiedenen Techniken für den Umgang mit abgelaufenen Verbindungen sowie Datenbank-Neustarts.

CREATE TABLE Argumente, einschließlich Storage Engines¶

Die CREATE TABLE-Syntax von MySQL und MariaDB enthält eine breite Palette von Sonderoptionen, einschließlich ENGINE, CHARSET, MAX_ROWS, ROW_FORMAT, INSERT_METHOD und viele mehr. Um die Wiedergabe dieser Argumente zu ermöglichen, geben Sie die Form mysql_argument_name="wert" an. Um beispielsweise eine Tabelle mit ENGINE von InnoDB, CHARSET von utf8mb4 und KEY_BLOCK_SIZE von 1024 anzugeben

Table(
    "mytable",
    metadata,
    Column("data", String(32)),
    mysql_engine="InnoDB",
    mysql_charset="utf8mb4",
    mysql_key_block_size="1024",
)

Bei Unterstützung des MariaDB-Only-Modus müssen ähnliche Schlüssel mit dem Präfix „mariadb“ ebenfalls enthalten sein. Die Werte können natürlich unabhängig voneinander variieren, sodass unterschiedliche Einstellungen für MySQL vs. MariaDB beibehalten werden können.

# support both "mysql" and "mariadb-only" engine URLs

Table(
    "mytable",
    metadata,
    Column("data", String(32)),
    mysql_engine="InnoDB",
    mariadb_engine="InnoDB",
    mysql_charset="utf8mb4",
    mariadb_charset="utf8",
    mysql_key_block_size="1024",
    mariadb_key_block_size="1024",
)

Die MySQL / MariaDB-Dialekte übertragen normalerweise jedes als mysql_keyword_name angegebene Schlüsselwort so, dass es in der CREATE TABLE-Anweisung als KEYWORD_NAME gerendert wird. Eine Handvoll dieser Namen wird mit einem Leerzeichen anstelle eines Unterstrichs gerendert; um dies zu unterstützen, hat das MySQL-Dialekt Kenntnis von diesen speziellen Namen, zu denen DATA DIRECTORY (z. B. mysql_data_directory), CHARACTER SET (z. B. mysql_character_set) und INDEX DIRECTORY (z. B. mysql_index_directory) gehören.

Das häufigste Argument ist mysql_engine, das sich auf die Speicher-Engine für die Tabelle bezieht. Historisch gesehen würden MySQL-Serverinstallationen standardmäßig MyISAM für diesen Wert verwenden, obwohl neuere Versionen möglicherweise auf InnoDB standardisieren. Die InnoDB-Engine wird aufgrund ihrer Unterstützung für Transaktionen und Fremdschlüssel typischerweise bevorzugt.

Eine Table, die in einer MySQL / MariaDB-Datenbank mit einer Speicher-Engine von MyISAM erstellt wird, ist im Wesentlichen nicht transaktional, was bedeutet, dass jede INSERT/UPDATE/DELETE-Anweisung, die sich auf diese Tabelle bezieht, als Autocommit aufgerufen wird. Sie hat auch keine Unterstützung für Fremdschlüssel-Constraints; obwohl die CREATE TABLE-Anweisung Fremdschlüssel-Optionen akzeptiert, werden bei Verwendung der MyISAM-Speicher-Engine diese Argumente verworfen. Das Reflektieren einer solchen Tabelle liefert ebenfalls keine Informationen über Fremdschlüssel-Constraints.

Für vollständig atomare Transaktionen sowie für die Unterstützung von Fremdschlüssel-Constraints müssen alle teilnehmenden CREATE TABLE-Anweisungen eine transaktionale Engine angeben, die in den allermeisten Fällen InnoDB ist.

Partitionierung kann auf ähnliche Weise mit ähnlichen Optionen angegeben werden. Im folgenden Beispiel gibt die create table-Anweisung PARTITION_BY, PARTITIONS, SUBPARTITIONS und SUBPARTITION_BY an.

# can also use mariadb_* prefix
Table(
    "testtable",
    MetaData(),
    Column("id", Integer(), primary_key=True, autoincrement=True),
    Column("other_id", Integer(), primary_key=True, autoincrement=False),
    mysql_partitions="2",
    mysql_partition_by="KEY(other_id)",
    mysql_subpartition_by="HASH(some_expr)",
    mysql_subpartitions="2",
)

Dies wird gerendert

CREATE TABLE testtable (
        id INTEGER NOT NULL AUTO_INCREMENT,
        other_id INTEGER NOT NULL,
        PRIMARY KEY (id, other_id)
)PARTITION BY KEY(other_id) PARTITIONS 2 SUBPARTITION BY HASH(some_expr) SUBPARTITIONS 2

Groß-/Kleinschreibung und Tabellenreflexion¶

Sowohl MySQL als auch MariaDB haben eine inkonsistente Unterstützung für die Groß-/Kleinschreibung von Bezeichnernamen, wobei die Unterstützung auf spezifischen Details des zugrunde liegenden Betriebssystems basiert. Es wurde jedoch beobachtet, dass unabhängig vom Verhalten der Groß-/Kleinschreibung die Namen von Tabellen in Fremdschlüsseldeklarationen *immer* als Kleinbuchstaben von der Datenbank empfangen werden, was es unmöglich macht, ein Schema genau zu reflektieren, bei dem miteinander verbundene Tabellen gemischt-groß-/kleingeschriebene Bezeichnernamen verwenden.

Daher wird dringend empfohlen, Tabellennamen sowohl innerhalb von SQLAlchemy als auch in der MySQL / MariaDB-Datenbank selbst als Kleinbuchstaben zu deklarieren, insbesondere wenn Datenbank-Reflexionsfunktionen verwendet werden sollen.

Transaktionsisolationslevel¶

Alle MySQL / MariaDB-Dialekte unterstützen die Einstellung des Transaktionsisolationsgrads sowohl über einen dialektspezifischen Parameter create_engine.isolation_level, der von create_engine() akzeptiert wird, als auch über das Argument Connection.execution_options.isolation_level, das an Connection.execution_options() übergeben wird. Dieses Feature funktioniert, indem der Befehl SET SESSION TRANSACTION ISOLATION LEVEL <level> für jede neue Verbindung ausgegeben wird. Für den speziellen AUTOCOMMIT-Isolationsgrad werden DBAPI-spezifische Techniken verwendet.

Isolationslevel mit create_engine() einstellen

engine = create_engine(
    "mysql+mysqldb://scott:tiger@localhost/test",
    isolation_level="READ UNCOMMITTED",
)

Einstellung über per-Verbindungs-Ausführungsoptionen

connection = engine.connect()
connection = connection.execution_options(isolation_level="READ COMMITTED")

Gültige Werte für isolation_level sind

READ COMMITTED
READ UNCOMMITTED
REPEATABLE READ
SERIALIZABLE
AUTOCOMMIT

Der spezielle Wert AUTOCOMMIT nutzt die verschiedenen „autocommit“-Attribute, die von spezifischen DBAPIs bereitgestellt werden, und wird derzeit von MySQLdb, MySQL-Client, MySQL-Connector Python und PyMySQL unterstützt. Bei Verwendung wird die Datenbankverbindung für den Wert von SELECT @@autocommit; true zurückgeben.

Es gibt auch weitere Optionen für Isolationslevel-Konfigurationen, wie z. B. „Sub-Engine“-Objekte, die mit einer Haupt- Engine verknüpft sind und jeweils unterschiedliche Isolationslevel-Einstellungen anwenden. Siehe die Diskussion unter Einstellung von Transaktionsisolationsleveln einschließlich DBAPI-Autocommit für Hintergrundinformationen.

Siehe auch

Einstellung von Transaktionsisolationsleveln einschließlich DBAPI-Autocommit

AUTO_INCREMENT Verhalten¶

Beim Erstellen von Tabellen setzt SQLAlchemy automatisch AUTO_INCREMENT auf die erste Integer Primärschlüsselspalte, die nicht als Fremdschlüssel gekennzeichnet ist.

>>> t = Table(
...     "mytable", metadata, Column("mytable_id", Integer, primary_key=True)
... )
>>> t.create()
CREATE TABLE mytable (
        id INTEGER NOT NULL AUTO_INCREMENT,
        PRIMARY KEY (id)
)

Sie können dieses Verhalten deaktivieren, indem Sie False an das Argument Column.autoincrement von Column übergeben. Dieses Flag kann auch verwendet werden, um Auto-Increment auf einer sekundären Spalte in einem mehrspaltigen Schlüssel für einige Speicher-Engines zu aktivieren.

Table(
    "mytable",
    metadata,
    Column("gid", Integer, primary_key=True, autoincrement=False),
    Column("id", Integer, primary_key=True),
)

Serverseitige Cursor¶

Die Unterstützung für serverseitige Cursor ist für die Dialekte mysqlclient, PyMySQL, mariadbconnector verfügbar und möglicherweise auch für andere. Dies nutzt entweder das Flag „buffered=True/False“, falls verfügbar, oder durch die interne Verwendung einer Klasse wie MySQLdb.cursors.SSCursor oder pymysql.cursors.SSCursor.

Serverseitige Cursor werden pro Anweisung aktiviert, indem die Verbindungs-Ausführungsoption Connection.execution_options.stream_results verwendet wird.

with engine.connect() as conn:
    result = conn.execution_options(stream_results=True).execute(
        text("select * from table")
    )

Beachten Sie, dass einige Arten von SQL-Anweisungen möglicherweise nicht mit serverseitigen Cursor unterstützt werden; im Allgemeinen sollten nur SQL-Anweisungen, die Zeilen zurückgeben, mit dieser Option verwendet werden.

Veraltet seit Version 1.4: Das Flag server_side_cursors auf Dialektebene ist veraltet und wird in einer zukünftigen Version entfernt. Bitte verwenden Sie die Ausführungsoption Connection.stream_results für die Unterstützung von unbuffered Cursor.

Siehe auch

Verwendung von serverseitigen Cursern (auch bekannt als Stream-Ergebnisse)

Unicode¶

Zeichensatz Auswahl¶

Die meisten MySQL / MariaDB DBAPIs bieten die Option, den Client-Zeichensatz für eine Verbindung festzulegen. Dies wird typischerweise mit dem Parameter charset in der URL übermittelt, wie zum Beispiel

e = create_engine(
    "mysql+pymysql://scott:tiger@localhost/test?charset=utf8mb4"
)

Dieser Zeichensatz ist der **Client-Zeichensatz** für die Verbindung. Einige MySQL DBAPIs setzen diesen standardmäßig auf einen Wert wie latin1, und einige nutzen die Einstellung default-character-set in der my.cnf-Datei. Die Dokumentation des verwendeten DBAPIs sollte für spezifisches Verhalten konsultiert werden.

Die für Unicode verwendete Kodierung war traditionell 'utf8'. Für MySQL-Versionen 5.5.3 und MariaDB 5.5 und höher wurde jedoch eine neue MySQL-spezifische Kodierung 'utf8mb4' eingeführt, und ab MySQL 8.0 wird eine Warnung vom Server ausgegeben, wenn einfaches utf8 in serverseitigen Direktiven angegeben wird, ersetzt durch utf8mb3. Der Grund für diese neue Kodierung liegt darin, dass die Legacy-UTF-8-Kodierung von MySQL nur Codepoints bis zu drei Bytes unterstützt und nicht vier. Wenn Sie daher mit einer MySQL- oder MariaDB-Datenbank kommunizieren, die Codepoints mit mehr als drei Bytes Größe enthält, wird diese neue Zeichenkodierung bevorzugt, sofern sie sowohl von der Datenbank als auch vom Client-DBAPI unterstützt wird, wie z. B. hier

e = create_engine(
    "mysql+pymysql://scott:tiger@localhost/test?charset=utf8mb4"
)

Alle modernen DBAPIs sollten die utf8mb4-Zeichenkodierung unterstützen.

Um die utf8mb4-Kodierung für ein Schema zu verwenden, das mit Legacy utf8 erstellt wurde, können Änderungen am MySQL/MariaDB-Schema und/oder an der Serverkonfiguration erforderlich sein.

Siehe auch

Die utf8mb4 Zeichenkodierung - in der MySQL-Dokumentation

Umgang mit Warnungen zu Binärdaten und Unicode¶

MySQL-Versionen 5.6, 5.7 und höher (zur Zeit der Erstellung dieses Textes nicht MariaDB) geben nun eine Warnung aus, wenn versucht wird, Binärdaten an die Datenbank zu übergeben, während auch eine Zeichensatzkodierung vorhanden ist und die Binärdaten selbst für diese Kodierung nicht gültig sind.

default.py:509: Warning: (1300, "Invalid utf8mb4 character string:
'F9876A'")
  cursor.execute(statement, parameters)

Diese Warnung entsteht dadurch, dass die MySQL-Clientbibliothek versucht, den Binärstring als Unicode-Objekt zu interpretieren, selbst wenn ein Datentyp wie LargeBinary verwendet wird. Um dies zu lösen, erfordert die SQL-Anweisung einen binären „Zeichensatz-Introducer“, der vor jedem nicht-NULL-Wert steht, der wie folgt gerendert wird:

INSERT INTO table (data) VALUES (_binary %s)

Diese Zeichensatz-Introducer werden vom DBAPI-Treiber bereitgestellt, unter der Annahme der Verwendung von mysqlclient oder PyMySQL (beide werden empfohlen). Fügen Sie den Abfragezeichenkettenparameter binary_prefix=true zur URL hinzu, um diese Warnung zu beheben.

# mysqlclient
engine = create_engine(
    "mysql+mysqldb://scott:tiger@localhost/test?charset=utf8mb4&binary_prefix=true"
)

# PyMySQL
engine = create_engine(
    "mysql+pymysql://scott:tiger@localhost/test?charset=utf8mb4&binary_prefix=true"
)

Das Flag binary_prefix wird von anderen MySQL-Treibern möglicherweise nicht unterstützt.

SQLAlchemy selbst kann dieses _binary-Präfix nicht zuverlässig rendern, da es nicht mit dem NULL-Wert funktioniert, der als gebundener Parameter gesendet werden kann. Da der MySQL-Treiber Parameter direkt in den SQL-String rendert, ist dies der effizienteste Ort, an dem dieses zusätzliche Schlüsselwort übergeben werden kann.

Siehe auch

Zeichensatz-Introducer - auf der MySQL-Website

ANSI-Quoting-Stil¶

MySQL / MariaDB bieten zwei Varianten des Bezeichner-„Quoting-Stils“, eine, die Backticks verwendet, und eine andere, die Anführungszeichen verwendet, z. B. `some_identifier` im Gegensatz zu "some_identifier". Alle MySQL-Dialekte erkennen, welche Version verwendet wird, indem sie den Wert von sql_mode überprüfen, wenn eine Verbindung zum ersten Mal mit einer bestimmten Engine hergestellt wird. Dieser Quoting-Stil kommt beim Rendern von Tabellen- und Spaltennamen sowie bei der Reflexion bestehender Datenbankstrukturen zum Einsatz. Die Erkennung erfolgt vollautomatisch, und es ist keine spezielle Konfiguration erforderlich, um einen der beiden Quoting-Stile zu verwenden.

Ändern des sql_mode¶

MySQL unterstützt den Betrieb in mehreren Server SQL Modes sowohl für Server als auch für Clients. Um den sql_mode für eine gegebene Anwendung zu ändern, kann ein Entwickler das SQLAlchemy Events System nutzen.

Im folgenden Beispiel wird das Ereignissystem verwendet, um den sql_mode bei den Ereignissen first_connect und connect festzulegen.

from sqlalchemy import create_engine, event

eng = create_engine(
    "mysql+mysqldb://scott:tiger@localhost/test", echo="debug"
)


# `insert=True` will ensure this is the very first listener to run
@event.listens_for(eng, "connect", insert=True)
def connect(dbapi_connection, connection_record):
    cursor = dbapi_connection.cursor()
    cursor.execute("SET sql_mode = 'STRICT_ALL_TABLES'")


conn = eng.connect()

Im oben gezeigten Beispiel ruft das „connect“-Ereignis die „SET“-Anweisung auf der Verbindung aus, sobald eine bestimmte DBAPI-Verbindung zum ersten Mal für einen Pool erstellt wird, bevor die Verbindung dem Connection-Pool zur Verfügung gestellt wird. Da die Funktion außerdem mit insert=True registriert wurde, wird sie am Anfang der internen Liste der registrierten Funktionen eingefügt.

MySQL / MariaDB SQL-Erweiterungen¶

Viele der MySQL / MariaDB SQL-Erweiterungen werden über die generische Funktions- und Operatorunterstützung von SQLAlchemy behandelt.

table.select(table.c.password == func.md5("plaintext"))
table.select(table.c.username.op("regexp")("^[a-d]"))

Und natürlich kann jede gültige SQL-Anweisung auch als String ausgeführt werden.

Einige begrenzte direkte Unterstützung für MySQL / MariaDB-Erweiterungen von SQL ist derzeit verfügbar.

INSERT..ON DUPLICATE KEY UPDATE: Siehe INSERT…ON DUPLICATE KEY UPDATE (Upsert)
SELECT pragma, verwenden Sie Select.prefix_with() und Query.prefix_with()
```
select(...).prefix_with(["HIGH_PRIORITY", "SQL_SMALL_RESULT"])
```

UPDATE mit LIMIT

update(...).with_dialect_options(mysql_limit=10, mariadb_limit=10)

DELETE mit LIMIT
```
delete(...).with_dialect_options(mysql_limit=10, mariadb_limit=10)
```
Neu in Version 2.0.37: Löschen mit Limit hinzugefügt
Optimizer-Hints, verwenden Sie Select.prefix_with() und Query.prefix_with()
```
select(...).prefix_with("/*+ NO_RANGE_OPTIMIZATION(t4 PRIMARY) */")
```
Index-Hints, verwenden Sie Select.with_hint() und Query.with_hint()
```
select(...).with_hint(some_table, "USE INDEX xyz")
```

Unterstützung für den MATCH-Operator

from sqlalchemy.dialects.mysql import match

select(...).where(match(col1, col2, against="some expr").in_boolean_mode())

Siehe auch

match

INSERT/DELETE…RETURNING¶

Das MariaDB-Dialekt unterstützt die Syntax INSERT..RETURNING (ab 10.5) und DELETE..RETURNING (ab 10.0). INSERT..RETURNING kann in einigen Fällen automatisch verwendet werden, um neu generierte Bezeichner anstelle des traditionellen Ansatzes mit cursor.lastrowid abzurufen, jedoch wird cursor.lastrowid für einfache Einzelsatzfälle wegen seiner besseren Leistung immer noch bevorzugt.

Um eine explizite RETURNING-Klausel anzugeben, verwenden Sie die Methode _UpdateBase.returning() auf Anweisungsebene.

# INSERT..RETURNING
result = connection.execute(
    table.insert().values(name="foo").returning(table.c.col1, table.c.col2)
)
print(result.all())

# DELETE..RETURNING
result = connection.execute(
    table.delete()
    .where(table.c.name == "foo")
    .returning(table.c.col1, table.c.col2)
)
print(result.all())

Neu in Version 2.0: Unterstützung für MariaDB RETURNING hinzugefügt

INSERT…ON DUPLICATE KEY UPDATE (Upsert)¶

MySQL / MariaDB ermöglichen „Upserts“ (Update oder Insert) von Zeilen in eine Tabelle über die Klausel ON DUPLICATE KEY UPDATE der INSERT-Anweisung. Eine Kandidatenzeile wird nur eingefügt, wenn diese Zeile nicht mit einem vorhandenen Primär- oder eindeutigen Schlüssel in der Tabelle übereinstimmt; andernfalls wird ein UPDATE durchgeführt. Die Anweisung ermöglicht die separate Angabe der Werte für INSERT gegenüber den Werten für UPDATE.

SQLAlchemy bietet Unterstützung für ON DUPLICATE KEY UPDATE über die MySQL-spezifische Funktion insert(), die die generative Methode Insert.on_duplicate_key_update() bereitstellt.

>>> fromsqlalchemy.dialects.mysqlimportinsert>>> insert_stmt=insert(my_table).values(...     id="some_existing_id", data="inserted value"... )>>> on_duplicate_key_stmt=insert_stmt.on_duplicate_key_update(...     data=insert_stmt.inserted.data, status="U"... )>>> print(on_duplicate_key_stmt)INSERT INTO my_table (id, data) VALUES (%s, %s)
ON DUPLICATE KEY UPDATE data = VALUES(data), status = %s

Im Gegensatz zur „ON CONFLICT“-Phrase von PostgreSQL stimmt die Phrase „ON DUPLICATE KEY UPDATE“ immer mit einem Primärschlüssel oder eindeutigen Schlüssel überein und führt immer ein Update durch, wenn eine Übereinstimmung vorliegt; es gibt keine Optionen, um einen Fehler auszulösen oder ein Update zu überspringen.

ON DUPLICATE KEY UPDATE wird verwendet, um die bereits vorhandene Zeile zu aktualisieren, wobei eine beliebige Kombination aus neuen Werten und Werten aus der vorgeschlagenen Einfügung verwendet wird. Diese Werte werden normalerweise mithilfe von Schlüsselwortargumenten angegeben, die an die Insert.on_duplicate_key_update() übergeben werden, wobei Spaltenschlüsselwerte (normalerweise der Name der Spalte, es sei denn, er gibt Column.key an) als Schlüssel und Literale oder SQL-Ausdrücke als Werte verwendet werden.

>>> insert_stmt=insert(my_table).values(...     id="some_existing_id", data="inserted value"... )>>> on_duplicate_key_stmt=insert_stmt.on_duplicate_key_update(...     data="some data",...     updated_at=func.current_timestamp(),... )>>> print(on_duplicate_key_stmt)INSERT INTO my_table (id, data) VALUES (%s, %s)
ON DUPLICATE KEY UPDATE data = %s, updated_at = CURRENT_TIMESTAMP

Ähnlich wie bei UpdateBase.values() werden andere Parameterformen akzeptiert, einschließlich eines einzelnen Wörterbuchs.

>>> on_duplicate_key_stmt = insert_stmt.on_duplicate_key_update(
...     {"data": "some data", "updated_at": func.current_timestamp()},
... )

sowie eine Liste von 2-Tupeln, die automatisch ein parameterreihenfolgen-Update-Statement liefert, ähnlich wie bei Parameter-reihenfolgen-Updates beschrieben. Im Gegensatz zum Update-Objekt ist kein spezielles Flag erforderlich, um die Absicht anzugeben, da die Argumentform in diesem Kontext eindeutig ist.

>>> on_duplicate_key_stmt=insert_stmt.on_duplicate_key_update(...     [...         ("data", "some data"),...         ("updated_at", func.current_timestamp()),...     ]... )>>> print(on_duplicate_key_stmt)INSERT INTO my_table (id, data) VALUES (%s, %s)
ON DUPLICATE KEY UPDATE data = %s, updated_at = CURRENT_TIMESTAMP

Geändert in Version 1.3: Unterstützung für parameterreihenfolgen-UPDATE-Klausel innerhalb von MySQL ON DUPLICATE KEY UPDATE.

Warnung

Die Methode Insert.on_duplicate_key_update() berücksichtigt **nicht** Python-seitige Standard-UPDATE-Werte oder Generierungsfunktionen, z. B. solche, die mit Column.onupdate angegeben werden. Diese Werte werden für einen UPDATE im Stil von ON DUPLICATE KEY nicht genutzt, es sei denn, sie werden manuell explizit in den Parametern angegeben.

Um auf die vorgeschlagene Einfügezeile zu verweisen, ist der spezielle Alias Insert.inserted als Attribut des Insert-Objekts verfügbar; dieses Objekt ist eine ColumnCollection, die alle Spalten der Zieltabelle enthält.

>>> stmt=insert(my_table).values(...     id="some_id", data="inserted value", author="jlh"... )>>> do_update_stmt=stmt.on_duplicate_key_update(...     data="updated value", author=stmt.inserted.author... )>>> print(do_update_stmt)INSERT INTO my_table (id, data, author) VALUES (%s, %s, %s)
ON DUPLICATE KEY UPDATE data = %s, author = VALUES(author)

Beim Rendern erzeugt der Namensraum „inserted“ den Ausdruck VALUES(<columnname>).

Neu in Version 1.2: Unterstützung für die MySQL ON DUPLICATE KEY UPDATE-Klausel hinzugefügt

rowcount Unterstützung¶

SQLAlchemy standardisiert das DBAPI-Attribut cursor.rowcount auf die übliche Definition von „Anzahl der Zeilen, die von einer UPDATE- oder DELETE-Anweisung betroffen sind“. Dies steht im Gegensatz zur Standardeinstellung bei den meisten MySQL DBAPI-Treibern, die „Anzahl der tatsächlich modifizierten/gelöschten Zeilen“ lautet. Aus diesem Grund fügen die SQLAlchemy MySQL-Dialekte bei der Verbindung immer das Flag constants.CLIENT.FOUND_ROWS oder dessen Äquivalent für das Ziel-Dialekt hinzu. Diese Einstellung ist derzeit fest codiert.

Siehe auch

CursorResult.rowcount

MySQL / MariaDB-spezifische Indexoptionen¶

MySQL und MariaDB-spezifische Erweiterungen des Index-Konstrukts sind verfügbar.

Indexlänge¶

MySQL und MariaDB bieten beide die Option, Indexeinträge mit einer bestimmten Länge zu erstellen, wobei „Länge“ sich auf die Anzahl der Zeichen oder Bytes in jedem Wert bezieht, der Teil des Indexes wird. SQLAlchemy stellt diese Funktion über die Parameter mysql_length und/oder mariadb_length bereit.

Index("my_index", my_table.c.data, mysql_length=10, mariadb_length=10)

Index("a_b_idx", my_table.c.a, my_table.c.b, mysql_length={"a": 4, "b": 9})

Index(
    "a_b_idx", my_table.c.a, my_table.c.b, mariadb_length={"a": 4, "b": 9}
)

Präfixlängen werden in Zeichen für nicht-binäre String-Typen und in Bytes für binäre String-Typen angegeben. Der an das Schlüsselwortargument übergebene Wert *muss* entweder eine Ganzzahl sein (und somit denselben Präfixlängenwert für alle Spalten des Indexes angeben) oder ein Wörterbuch, bei dem die Schlüssel Spaltennamen und die Werte Präfixlängenwerte für die entsprechenden Spalten sind. MySQL und MariaDB erlauben eine Länge für eine Spalte eines Indexes nur, wenn es sich um CHAR, VARCHAR, TEXT, BINARY, VARBINARY und BLOB handelt.

Indexpräfixe¶

MySQL-Speicher-Engines erlauben es Ihnen, beim Erstellen eines Indexes ein Indexpräfix anzugeben. SQLAlchemy stellt diese Funktion über den Parameter mysql_prefix für Index bereit.

Index("my_index", my_table.c.data, mysql_prefix="FULLTEXT")

Der an das Schlüsselwortargument übergebene Wert wird einfach an die zugrunde liegende CREATE INDEX-Anweisung weitergegeben und *muss* daher ein gültiges Indexpräfix für Ihre MySQL-Speicher-Engine sein.

Siehe auch

CREATE INDEX - MySQL-Dokumentation

Indextypen¶

Einige MySQL-Speicher-Engines erlauben es Ihnen, beim Erstellen eines Indexes oder einer Primärschlüssel-Constraint einen Indextyp anzugeben. SQLAlchemy stellt diese Funktion über den Parameter mysql_using für Index bereit.

Index(
    "my_index", my_table.c.data, mysql_using="hash", mariadb_using="hash"
)

Sowie den Parameter mysql_using für PrimaryKeyConstraint.

PrimaryKeyConstraint("data", mysql_using="hash", mariadb_using="hash")

Der an das Schlüsselwortargument übergebene Wert wird einfach an die zugrunde liegende CREATE INDEX- oder PRIMARY KEY-Klausel weitergeleitet, sodass er ein gültiger Index-Typ für Ihre MySQL-Speicher-Engine sein muss.

Weitere Informationen finden Sie unter

https://dev.mysql.com/doc/refman/5.0/en/create-index.html

https://dev.mysql.com/doc/refman/5.0/en/create-table.html

Index-Parser¶

CREATE FULLTEXT INDEX in MySQL unterstützt auch die Option „WITH PARSER“. Diese ist über das Schlüsselwortargument mysql_with_parser verfügbar.

Index(
    "my_index",
    my_table.c.data,
    mysql_prefix="FULLTEXT",
    mysql_with_parser="ngram",
    mariadb_prefix="FULLTEXT",
    mariadb_with_parser="ngram",
)

Neu in Version 1.3.

MySQL / MariaDB Fremdschlüssel¶

Das Verhalten von MySQL und MariaDB bezüglich Fremdschlüsseln hat einige wichtige Einschränkungen.

Zu vermeidende Fremdschlüsselargumente¶

Weder MySQL noch MariaDB unterstützen die Fremdschlüsselargumente „DEFERRABLE“, „INITIALLY“ oder „MATCH“. Die Verwendung des Schlüsselwortarguments deferrable oder initially mit ForeignKeyConstraint oder ForeignKey hat zur Folge, dass diese Schlüsselwörter in einem DDL-Ausdruck gerendert werden, was dann bei MySQL oder MariaDB zu einem Fehler führt. Um diese Schlüsselwörter für einen Fremdschlüssel zu verwenden und sie auf einem MySQL / MariaDB-Backend ignorieren zu lassen, verwenden Sie eine benutzerdefinierte Kompilierungsregel.

from sqlalchemy.ext.compiler import compiles
from sqlalchemy.schema import ForeignKeyConstraint


@compiles(ForeignKeyConstraint, "mysql", "mariadb")
def process(element, compiler, **kw):
    element.deferrable = element.initially = None
    return compiler.visit_foreign_key_constraint(element, **kw)

Das Schlüsselwort „MATCH“ ist tatsächlich heimtückischer und wird von SQLAlchemy in Verbindung mit den Backends MySQL oder MariaDB explizit nicht unterstützt. Dieses Argument wird von MySQL / MariaDB stillschweigend ignoriert, hat aber zusätzlich zur Folge, dass die Optionen ON UPDATE und ON DELETE ebenfalls vom Backend ignoriert werden. Daher sollte MATCH niemals mit den Backends MySQL / MariaDB verwendet werden; wie bei DEFERRABLE und INITIALLY können benutzerdefinierte Kompilierungsregeln verwendet werden, um eine ForeignKeyConstraint zur DDL-Definitionszeit zu korrigieren.

Reflektion von Fremdschlüsselbeschränkungen¶

Nicht alle MySQL / MariaDB-Speicher-Engines unterstützen Fremdschlüssel. Bei Verwendung der sehr gebräuchlichen MyISAM MySQL-Speicher-Engine werden die von der Tabellenreflexion geladenen Informationen keine Fremdschlüssel enthalten. Für diese Tabellen können Sie zur Reflexionszeit eine ForeignKeyConstraint angeben.

Table(
    "mytable",
    metadata,
    ForeignKeyConstraint(["other_id"], ["othertable.other_id"]),
    autoload_with=engine,
)

Siehe auch

CREATE TABLE Argumente, einschließlich Storage Engines

MySQL / MariaDB Eindeutigkeitsbeschränkungen und Reflexion¶

SQLAlchemy unterstützt sowohl das Index-Konstrukt mit dem Flag unique=True, das einen UNIQUE-Index angibt, als auch das UniqueConstraint-Konstrukt, das eine UNIQUE-Beschränkung darstellt. Beide Objekte/Syntaxen werden von MySQL / MariaDB beim Ausgeben von DDL zur Erstellung dieser Beschränkungen unterstützt. MySQL / MariaDB verfügt jedoch nicht über ein UNIQUE-Beschränkungskonstrukt, das von einem UNIQUE-Index getrennt ist; das heißt, die „UNIQUE“-Beschränkung auf MySQL / MariaDB entspricht der Erstellung eines „UNIQUE INDEX“.

Bei der Reflexion dieser Konstrukte geben die Methoden Inspector.get_indexes() und Inspector.get_unique_constraints() **beide** einen Eintrag für einen UNIQUE-Index in MySQL / MariaDB zurück. Bei der vollständigen Tabellenreflexion mit Table(..., autoload_with=engine) ist das UniqueConstraint-Konstrukt jedoch unter keinen Umständen Teil des vollständig reflektierten Table-Konstrukts; dieses Konstrukt wird immer durch einen Index mit der Einstellung unique=True in der Sammlung Table.indexes dargestellt.

TIMESTAMP / DATETIME-Probleme¶

Rendern von ON UPDATE CURRENT TIMESTAMP für explicit_defaults_for_timestamp von MySQL / MariaDB¶

MySQL und MariaDB haben historisch den DDL für den TIMESTAMP-Datentyp in die Phrase „TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP“ erweitert, die nicht-standardmäßigen SQL-Code enthält, der die Spalte automatisch mit dem aktuellen Zeitstempel aktualisiert, wenn ein UPDATE auftritt, wodurch die übliche Notwendigkeit entfällt, einen Trigger in einem solchen Fall zu verwenden, wenn serverseitige Update-Änderungen gewünscht sind.

MySQL 5.6 führte ein neues Flag explicit_defaults_for_timestamp ein, das das oben genannte Verhalten deaktiviert, und in MySQL 8 ist dieses Flag standardmäßig auf true gesetzt. Das bedeutet, um einen MySQL „on update timestamp“ zu erhalten, ohne dieses Flag zu ändern, muss der obige DDL explizit gerendert werden. Zusätzlich ist derselbe DDL für die Verwendung des DATETIME-Datentyps gültig.

Der MySQL-Dialekt von SQLAlchemy hat noch keine Option, die MySQL-Klausel „ON UPDATE CURRENT_TIMESTAMP“ zu generieren. Beachten Sie, dass dies kein allgemeiner „ON UPDATE“-Befehl ist, da es keine solche Syntax im Standard-SQL gibt. Der Parameter Column.server_onupdate von SQLAlchemy steht derzeit nicht in Zusammenhang mit diesem speziellen MySQL-Verhalten.

Um diesen DDL zu generieren, nutzen Sie den Parameter Column.server_default und übergeben Sie eine Textklausel, die auch die ON UPDATE-Klausel enthält.

from sqlalchemy import Table, MetaData, Column, Integer, String, TIMESTAMP
from sqlalchemy import text

metadata = MetaData()

mytable = Table(
    "mytable",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("data", String(50)),
    Column(
        "last_updated",
        TIMESTAMP,
        server_default=text(
            "CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"
        ),
    ),
)

Die gleichen Anweisungen gelten für die Verwendung der Datentypen DateTime und DATETIME.

from sqlalchemy import DateTime

mytable = Table(
    "mytable",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("data", String(50)),
    Column(
        "last_updated",
        DateTime,
        server_default=text(
            "CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"
        ),
    ),
)

Obwohl das Feature Column.server_onupdate diesen DDL nicht generiert, kann es dennoch wünschenswert sein, dem ORM mitzuteilen, dass dieser aktualisierte Wert abgerufen werden soll. Diese Syntax sieht wie folgt aus:

from sqlalchemy.schema import FetchedValue


class MyClass(Base):
    __tablename__ = "mytable"

    id = Column(Integer, primary_key=True)
    data = Column(String(50))
    last_updated = Column(
        TIMESTAMP,
        server_default=text(
            "CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"
        ),
        server_onupdate=FetchedValue(),
    )

TIMESTAMP-Spalten und NULL¶

MySQL erzwingt historisch, dass eine Spalte, die den TIMESTAMP-Datentyp angibt, implizit einen Standardwert von CURRENT_TIMESTAMP enthält, auch wenn dies nicht angegeben ist, und setzt die Spalte zusätzlich als NOT NULL, das entgegengesetzte Verhalten im Vergleich zu allen anderen Datentypen.

mysql> CREATE TABLE ts_test (
    -> a INTEGER,
    -> b INTEGER NOT NULL,
    -> c TIMESTAMP,
    -> d TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    -> e TIMESTAMP NULL);
Query OK, 0 rows affected (0.03 sec)

mysql> SHOW CREATE TABLE ts_test;
+---------+-----------------------------------------------------
| Table   | Create Table
+---------+-----------------------------------------------------
| ts_test | CREATE TABLE `ts_test` (
  `a` int(11) DEFAULT NULL,
  `b` int(11) NOT NULL,
  `c` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `d` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `e` timestamp NULL DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1

Oben sehen wir, dass eine INTEGER-Spalte standardmäßig NULL ist, es sei denn, sie wird mit NOT NULL angegeben. Wenn die Spalte jedoch vom Typ TIMESTAMP ist, wird ein impliziter Standardwert von CURRENT_TIMESTAMP generiert, der die Spalte auch als NOT NULL erzwingt, obwohl wir sie nicht als solche angegeben haben.

Dieses Verhalten von MySQL kann auf der MySQL-Seite mit dem Konfigurationsflag explicit_defaults_for_timestamp geändert werden, das in MySQL 5.6 eingeführt wurde. Mit dieser Servereinstellung sind TIMESTAMP-Spalten auf der MySQL-Seite in Bezug auf Standardwerte und Nullbarkeit wie jeder andere Datentyp.

Um die große Mehrheit der MySQL-Datenbanken, die dieses neue Flag nicht angeben, zu unterstützen, gibt SQLAlchemy den Spezifizierer „NULL“ explizit für jede TIMESTAMP-Spalte aus, die nicht nullable=False angibt. Um neuere Datenbanken zu unterstützen, die explicit_defaults_for_timestamp angeben, gibt SQLAlchemy auch NOT NULL für TIMESTAMP-Spalten aus, die nullable=False angeben. Das folgende Beispiel illustriert dies.

from sqlalchemy import MetaData, Integer, Table, Column, text
from sqlalchemy.dialects.mysql import TIMESTAMP

m = MetaData()
t = Table(
    "ts_test",
    m,
    Column("a", Integer),
    Column("b", Integer, nullable=False),
    Column("c", TIMESTAMP),
    Column("d", TIMESTAMP, nullable=False),
)


from sqlalchemy import create_engine

e = create_engine("mysql+mysqldb://scott:tiger@localhost/test", echo=True)
m.create_all(e)

Ausgabe

CREATE TABLE ts_test (
    a INTEGER,
    b INTEGER NOT NULL,
    c TIMESTAMP NULL,
    d TIMESTAMP NOT NULL
)

MySQL SQL-Konstrukte¶

Objektname	Beschreibung
match	Erzeugt eine `MATCH (X, Y) AGAINST ('TEXT')`-Klausel.

class sqlalchemy.dialects.mysql.match¶

Erzeugt eine MATCH (X, Y) AGAINST ('TEXT')-Klausel.

Z. B.

from sqlalchemy import desc
from sqlalchemy.dialects.mysql import match

match_expr = match(
    users_table.c.firstname,
    users_table.c.lastname,
    against="Firstname Lastname",
)

stmt = (
    select(users_table)
    .where(match_expr.in_boolean_mode())
    .order_by(desc(match_expr))
)

Würde einen SQL-Code erzeugen, der dem ähnelt

SELECT id, firstname, lastname
FROM user
WHERE MATCH(firstname, lastname) AGAINST (:param_1 IN BOOLEAN MODE)
ORDER BY MATCH(firstname, lastname) AGAINST (:param_2) DESC

Die Funktion match() ist eine eigenständige Version der Methode ColumnElement.match(), die auf allen SQL-Ausdrücken verfügbar ist, wie wenn ColumnElement.match() verwendet wird, ermöglicht aber die Übergabe mehrerer Spalten.

Parameter:

cols¶ – Spaltenausdrücke, gegen die abgeglichen werden soll.
against¶ – Ausdruck, mit dem verglichen werden soll.
in_boolean_mode¶ – boolean, setzt den „Boolean Mode“ auf true.
in_natural_language_mode¶ – boolean, setzt „Natural Language“ auf true.
with_query_expansion¶ – boolean, setzt „Query Expansion“ auf true.

Neu in Version 1.4.19.

Siehe auch

ColumnElement.match()

Mitglieder

in_boolean_mode(), in_natural_language_mode(), inherit_cache, with_query_expansion()

Klassensignatur

class sqlalchemy.dialects.mysql.match (sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.BinaryExpression)

method sqlalchemy.dialects.mysql.match.in_boolean_mode() → Self¶

Wendet den Modifikator „IN BOOLEAN MODE“ auf den MATCH-Ausdruck an.

Gibt zurück:: eine neue match-Instanz mit angewendeten Modifikationen.

method sqlalchemy.dialects.mysql.match.in_natural_language_mode() → Self¶

Wendet den Modifikator „IN NATURAL LANGUAGE MODE“ auf den MATCH-Ausdruck an.

Gibt zurück:: eine neue match-Instanz mit angewendeten Modifikationen.

attribute sqlalchemy.dialects.mysql.match.inherit_cache: bool | None = True¶

Gibt an, ob diese HasCacheKey-Instanz das Cache-Schlüssel-Generierungsschema ihrer direkten Oberklasse verwenden soll.

Das Attribut hat standardmäßig den Wert None, was bedeutet, dass ein Konstrukt noch nicht berücksichtigt hat, ob es für die Teilnahme an der Caching-Mechanik geeignet ist. Dies ist funktional äquivalent zum Setzen des Wertes auf False, außer dass auch eine Warnung ausgegeben wird.

Dieses Flag kann auf True für eine bestimmte Klasse gesetzt werden, wenn die SQL, die diesem Objekt entspricht, nicht auf Basis von Attributen geändert wird, die lokal zu dieser Klasse und nicht zu ihrer Oberklasse gehören.

Siehe auch

Unterstützung für Caching für benutzerdefinierte Konstrukte aktivieren - Allgemeine Richtlinien für die Einstellung des Attributs HasCacheKey.inherit_cache für SQL-Konstrukte von Drittanbietern oder benutzerdefinierte SQL-Konstrukte.

method sqlalchemy.dialects.mysql.match.with_query_expansion() → Self¶

Wendet den Modifikator „WITH QUERY EXPANSION“ auf den MATCH-Ausdruck an.

Gibt zurück:: eine neue match-Instanz mit angewendeten Modifikationen.

MySQL-Datentypen¶

Wie bei allen SQLAlchemy-Dialekten sind alle GROSSGESCHRIEBENEN Typen, die als gültig für MySQL bekannt sind, vom obersten Dialekt importierbar.

from sqlalchemy.dialects.mysql import (
    BIGINT,
    BINARY,
    BIT,
    BLOB,
    BOOLEAN,
    CHAR,
    DATE,
    DATETIME,
    DECIMAL,
    DECIMAL,
    DOUBLE,
    ENUM,
    FLOAT,
    INTEGER,
    LONGBLOB,
    LONGTEXT,
    MEDIUMBLOB,
    MEDIUMINT,
    MEDIUMTEXT,
    NCHAR,
    NUMERIC,
    NVARCHAR,
    REAL,
    SET,
    SMALLINT,
    TEXT,
    TIME,
    TIMESTAMP,
    TINYBLOB,
    TINYINT,
    TINYTEXT,
    VARBINARY,
    VARCHAR,
    YEAR,
)

Zusätzlich zu den oben genannten Typen unterstützt MariaDB auch Folgendes:

from sqlalchemy.dialects.mysql import (
    INET4,
    INET6,
)

Typen, die spezifisch für MySQL oder MariaDB sind oder spezifische Konstruktionsargumente haben, sind folgende:

Objektname	Beschreibung
BIGINT	MySQL BIGINTEGER-Typ.
BIT	MySQL BIT-Typ.
CHAR	MySQL CHAR-Typ für zeichenfeste Daten.
DATETIME	MySQL DATETIME-Typ.
DECIMAL	MySQL DECIMAL-Typ.
ENUM	MySQL ENUM-Typ.
FLOAT	MySQL FLOAT-Typ.
INET4	INET4-Spaltentyp für MariaDB.
INET6	INET6-Spaltentyp für MariaDB.
INTEGER	MySQL INTEGER-Typ.
JSON	MySQL JSON-Typ.
LONGBLOB	MySQL LONGBLOB-Typ für Binärdaten bis zu 2^32 Bytes.
LONGTEXT	MySQL LONGTEXT-Typ für Zeichenspeicherung, kodiert bis zu 2^32 Bytes.
MEDIUMBLOB	MySQL MEDIUMBLOB-Typ für Binärdaten bis zu 2^24 Bytes.
MEDIUMINT	MySQL MEDIUMINTEGER-Typ.
MEDIUMTEXT	MySQL MEDIUMTEXT-Typ für Zeichenspeicherung, kodiert bis zu 2^24 Bytes.
NCHAR	MySQL NCHAR-Typ.
NUMERIC	MySQL NUMERIC-Typ.
NVARCHAR	MySQL NVARCHAR-Typ.
REAL	MySQL REAL-Typ.
SET	MySQL SET-Typ.
SMALLINT	MySQL SMALLINTEGER-Typ.
TIME	MySQL TIME-Typ.
TIMESTAMP	MySQL TIMESTAMP-Typ.
TINYBLOB	MySQL TINYBLOB-Typ für Binärdaten bis zu 2^8 Bytes.
TINYINT	MySQL TINYINT-Typ.
TINYTEXT	MySQL TINYTEXT-Typ für Zeichenspeicherung, kodiert bis zu 2^8 Bytes.
VARCHAR	MySQL VARCHAR-Typ für Zeichen mit variabler Länge.
YEAR	MySQL YEAR-Typ für ein Byte zur Speicherung von Jahren 1901-2155.

class sqlalchemy.dialects.mysql.BIGINT¶

MySQL BIGINTEGER-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.BIGINT (sqlalchemy.dialects.mysql.types._IntegerType, sqlalchemy.types.BIGINT)

method sqlalchemy.dialects.mysql.BIGINT.__init__(display_width=None, **kw)¶

Konstruiert eine BIGINTEGER.

Parameter:

display_width¶ – Optional, maximale Anzeigebreite für diese Zahl.
unsigned¶ – ein Boolean, optional.
zerofill¶ – Optional. Wenn true, werden Werte als Zeichenketten links mit Nullen aufgefüllt. Beachten Sie, dass dies keine Auswirkung auf die Werte hat, die von der zugrunde liegenden Datenbank-API zurückgegeben werden, die weiterhin numerisch sind.

class sqlalchemy.dialects.mysql.BINARY: Der SQL BINARY-Typ.

Klassensignatur

class sqlalchemy.dialects.mysql.BINARY (sqlalchemy.types._Binary)

class sqlalchemy.dialects.mysql.BIT¶

MySQL BIT-Typ.

Dieser Typ ist für MySQL 5.0.3 oder neuer für MyISAM und 5.0.5 oder neuer für MyISAM, MEMORY, InnoDB und BDB. Für ältere Versionen verwenden Sie einen MSTinyInteger()-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.BIT (sqlalchemy.types.TypeEngine)

method sqlalchemy.dialects.mysql.BIT.__init__(length=None)¶

Konstruiert ein BIT.

Parameter:: length¶ – Optional, Anzahl der Bits.

class sqlalchemy.dialects.mysql.BLOB

Der SQL BLOB-Typ.

Klassensignatur

class sqlalchemy.dialects.mysql.BLOB (sqlalchemy.types.LargeBinary)

method sqlalchemy.dialects.mysql.BLOB.__init__(length: int | None = None)

geerbt von der sqlalchemy.types.LargeBinary.__init__ Methode von LargeBinary

Konstruiert einen LargeBinary-Typ.

Parameter:: length¶ – optional, eine Länge für die Spalte zur Verwendung in DDL-Anweisungen, für jene binären Typen, die eine Länge akzeptieren, wie der MySQL BLOB-Typ.

class sqlalchemy.dialects.mysql.BOOLEAN

Der SQL BOOLEAN-Typ.

Klassensignatur

class sqlalchemy.dialects.mysql.BOOLEAN (sqlalchemy.types.Boolean)

method sqlalchemy.dialects.mysql.BOOLEAN.__init__(create_constraint: bool = False, name: str | None = None, _create_events: bool = True, _adapted_from: SchemaType | None = None)

vererbt von der sqlalchemy.types.Boolean.__init__-Methode von Boolean

Konstruiert ein Boolean.

Parameter:

create_constraint¶ –
standardmäßig False. Wenn das Boolean als int/smallint generiert wird, wird auch eine CHECK-Beschränkung für die Tabelle erstellt, die 1 oder 0 als Wert sicherstellt.

Hinweis

Es wird dringend empfohlen, der CHECK-Beschränkung einen expliziten Namen zu geben, um Schemaverwaltungsbelange zu unterstützen. Dies kann entweder durch Setzen des Parameters Boolean.name oder durch Einrichten einer geeigneten Benennungskonvention erfolgen; siehe Konfigurieren von Benennungskonventionen für Beschränkungen für Hintergrundinformationen.

Geändert in Version 1.4: - dieses Flag ist jetzt standardmäßig False, d.h. es wird keine CHECK-Beschränkung für einen nicht-nativen Aufzählungstyp generiert.
name¶ – wenn eine CHECK-Beschränkung generiert wird, geben Sie den Namen der Beschränkung an.

class sqlalchemy.dialects.mysql.CHAR¶

MySQL CHAR-Typ für zeichenfeste Daten.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.CHAR (sqlalchemy.dialects.mysql.types._StringType, sqlalchemy.types.CHAR)

method sqlalchemy.dialects.mysql.CHAR.__init__(length=None, **kwargs)¶

Konstruiert ein CHAR.

Parameter:

length¶ – Maximale Datenlänge in Zeichen.
binary¶ – Optional, verwendet die Standard-Binär-Kollation für die nationale Zeichenmenge. Dies hat keine Auswirkung auf den gespeicherten Datentyp, verwenden Sie einen BINARY-Typ für Binärdaten.
collation¶ – Optional, fordert eine bestimmte Kollation an. Muss mit der nationalen Zeichenmenge kompatibel sein.

class sqlalchemy.dialects.mysql.DATE: Der SQL DATE-Typ.

Klassensignatur

class sqlalchemy.dialects.mysql.DATE (sqlalchemy.types.Date)

class sqlalchemy.dialects.mysql.DATETIME¶

MySQL DATETIME-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.DATETIME (sqlalchemy.types.DATETIME)

method sqlalchemy.dialects.mysql.DATETIME.__init__(timezone=False, fsp=None)¶

Konstruiert einen MySQL DATETIME-Typ.

Parameter:

timezone¶ – wird vom MySQL-Dialekt nicht verwendet.
fsp¶ –
Bruchteilige Sekundengenauigkeit. MySQL 5.6.4 unterstützt die Speicherung von Bruchteilen von Sekunden; dieser Parameter wird beim Rendern von DDL für den DATETIME-Typ verwendet.

Hinweis

Die DBAPI-Treiberunterstützung für Bruchteile von Sekunden kann begrenzt sein; die aktuelle Unterstützung umfasst MySQL Connector/Python.

class sqlalchemy.dialects.mysql.DECIMAL¶

MySQL DECIMAL-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.DECIMAL (sqlalchemy.dialects.mysql.types._NumericType, sqlalchemy.types.DECIMAL)

method sqlalchemy.dialects.mysql.DECIMAL.__init__(precision=None, scale=None, asdecimal=True, **kw)¶

Konstruiert ein DECIMAL.

Parameter:

precision¶ – Gesamtzahl der Ziffern in dieser Zahl. Wenn scale und precision beide None sind, werden Werte bis zu den vom Server erlaubten Grenzen gespeichert.
scale¶ – Die Anzahl der Ziffern nach dem Dezimalpunkt.
unsigned¶ – ein boolescher Wert, optional.
zerofill¶ – Optional. Wenn true, werden Werte als Strings gespeichert, die mit Nullen links aufgefüllt sind. Beachten Sie, dass dies die vom zugrunde liegenden Datenbank-API zurückgegebenen Werte nicht beeinflusst, die weiterhin numerisch sind.

class sqlalchemy.dialects.mysql.DOUBLE

MySQL DOUBLE Typ.

Klassensignatur

class sqlalchemy.dialects.mysql.DOUBLE (sqlalchemy.dialects.mysql.types._FloatType, sqlalchemy.types.DOUBLE)

method sqlalchemy.dialects.mysql.DOUBLE.__init__(precision=None, scale=None, asdecimal=True, **kw)

Konstruiert ein DOUBLE.

Hinweis

Der DOUBLE-Typ konvertiert standardmäßig von float zu Decimal und verwendet eine Trunkierung, die standardmäßig 10 Ziffern beträgt. Geben Sie entweder scale=n oder decimal_return_scale=n an, um diese Skala zu ändern, oder asdecimal=False, um Werte direkt als Python-Gleitkommazahlen zurückzugeben.

Parameter:

precision¶ – Gesamtzahl der Ziffern in dieser Zahl. Wenn scale und precision beide None sind, werden Werte bis zu den vom Server erlaubten Grenzen gespeichert.
scale¶ – Die Anzahl der Ziffern nach dem Dezimalpunkt.
unsigned¶ – ein boolescher Wert, optional.
zerofill¶ – Optional. Wenn true, werden Werte als Strings gespeichert, die mit Nullen links aufgefüllt sind. Beachten Sie, dass dies die vom zugrunde liegenden Datenbank-API zurückgegebenen Werte nicht beeinflusst, die weiterhin numerisch sind.

class sqlalchemy.dialects.mysql.ENUM¶

MySQL ENUM-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.ENUM (sqlalchemy.types.NativeForEmulated, sqlalchemy.types.Enum, sqlalchemy.dialects.mysql.types._StringType)

method sqlalchemy.dialects.mysql.ENUM.__init__(*enums, **kw)¶

Konstruiert eine ENUM.

Z. B.

Column("myenum", ENUM("foo", "bar", "baz"))

Parameter:

enums¶ –
Der Bereich der gültigen Werte für diese ENUM. Werte in enums werden nicht zitiert, sie werden beim Generieren des Schemas escaped und in einfache Anführungszeichen gesetzt. Dieses Objekt kann auch ein PEP-435-konformer aufgezählter Typ sein.
strict¶ –
Dieses Flag hat keine Auswirkung.

Geändert in Version The: Der MySQL ENUM-Typ sowie der Basis-Enum-Typ validieren jetzt alle Python-Datenwerte.
charset¶ – Optional, eine zeichenkettenbezogene Zeichenkodierung für diesen Zeichenkettenwert. Hat Vorrang vor den Kurzformen „ascii“ oder „unicode“.
collation¶ – Optional, eine zeichenkettenbezogene Sortierung für diesen Zeichenkettenwert. Hat Vorrang vor der Kurzform „binary“.
ascii¶ – Standardmäßig False: Kurzform für die latin1-Zeichenkodierung, generiert ASCII im Schema.
unicode¶ – Standardmäßig False: Kurzform für die ucs2-Zeichenkodierung, generiert UNICODE im Schema.
binary¶ – Standardmäßig False: Kurzform, wählt den binären Sortierungstyp, der zur Zeichenkodierung der Spalte passt. Generiert BINARY im Schema. Dies hat keinen Einfluss auf die Art der gespeicherten Daten, nur auf die Sortierung von Zeichendaten.

class sqlalchemy.dialects.mysql.FLOAT¶

MySQL FLOAT-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.FLOAT (sqlalchemy.dialects.mysql.types._FloatType, sqlalchemy.types.FLOAT)

method sqlalchemy.dialects.mysql.FLOAT.__init__(precision=None, scale=None, asdecimal=False, **kw)¶

Konstruiert ein FLOAT.

Parameter:

precision¶ – Gesamtzahl der Ziffern in dieser Zahl. Wenn scale und precision beide None sind, werden Werte bis zu den vom Server erlaubten Grenzen gespeichert.
scale¶ – Die Anzahl der Ziffern nach dem Dezimalpunkt.
unsigned¶ – ein boolescher Wert, optional.
zerofill¶ – Optional. Wenn true, werden Werte als Strings gespeichert, die mit Nullen links aufgefüllt sind. Beachten Sie, dass dies die vom zugrunde liegenden Datenbank-API zurückgegebenen Werte nicht beeinflusst, die weiterhin numerisch sind.

class sqlalchemy.dialects.mysql.INET4¶: INET4-Spaltentyp für MariaDB.

Neu in Version 2.0.37.

Klassensignatur

class sqlalchemy.dialects.mysql.INET4 (sqlalchemy.types.TypeEngine)

class sqlalchemy.dialects.mysql.INET6¶: INET6-Spaltentyp für MariaDB.

Neu in Version 2.0.37.

Klassensignatur

class sqlalchemy.dialects.mysql.INET6 (sqlalchemy.types.TypeEngine)

class sqlalchemy.dialects.mysql.INTEGER¶

MySQL INTEGER-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.INTEGER (sqlalchemy.dialects.mysql.types._IntegerType, sqlalchemy.types.INTEGER)

method sqlalchemy.dialects.mysql.INTEGER.__init__(display_width=None, **kw)¶

Konstruiert ein INTEGER.

Parameter:

display_width¶ – Optional, maximale Anzeigebreite für diese Zahl.
unsigned¶ – ein boolescher Wert, optional.
zerofill¶ – Optional. Wenn true, werden Werte als Strings gespeichert, die mit Nullen links aufgefüllt sind. Beachten Sie, dass dies die vom zugrunde liegenden Datenbank-API zurückgegebenen Werte nicht beeinflusst, die weiterhin numerisch sind.

class sqlalchemy.dialects.mysql.JSON¶

MySQL JSON-Typ.

MySQL unterstützt JSON ab Version 5.7. MariaDB unterstützt JSON (als Alias für LONGTEXT) ab Version 10.2.

Der Typ JSON wird automatisch verwendet, wenn der Basis-Datentyp JSON auf einem MySQL- oder MariaDB-Backend verwendet wird.

Siehe auch

JSON - Hauptdokumentation für den generischen plattformübergreifenden JSON-Datentyp.

Der JSON-Typ unterstützt die Persistenz von JSON-Werten sowie die Kern-Indexoperationen, die vom JSON-Datentyp bereitgestellt werden, indem die Operationen so angepasst werden, dass die Funktion JSON_EXTRACT auf Datenbankebene gerendert wird.

Klassensignatur

class sqlalchemy.dialects.mysql.JSON (sqlalchemy.types.JSON)

class sqlalchemy.dialects.mysql.LONGBLOB¶: MySQL LONGBLOB-Typ für Binärdaten bis zu 2^32 Bytes.

Klassensignatur

class sqlalchemy.dialects.mysql.LONGBLOB (sqlalchemy.types._Binary)

class sqlalchemy.dialects.mysql.LONGTEXT¶

MySQL LONGTEXT-Typ für Zeichenspeicherung, kodiert bis zu 2^32 Bytes.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.LONGTEXT (sqlalchemy.dialects.mysql.types._StringType)

method sqlalchemy.dialects.mysql.LONGTEXT.__init__(**kwargs)¶

Konstruiert ein LONGTEXT.

Parameter:

charset¶ – Optional, eine zeichenkettenbezogene Zeichenkodierung für diesen Zeichenkettenwert. Hat Vorrang vor den Kurzformen „ascii“ oder „unicode“.
collation¶ – Optional, eine zeichenkettenbezogene Sortierung für diesen Zeichenkettenwert. Hat Vorrang vor der Kurzform „binary“.
ascii¶ – Standardmäßig False: Kurzform für die latin1-Zeichenkodierung, generiert ASCII im Schema.
unicode¶ – Standardmäßig False: Kurzform für die ucs2-Zeichenkodierung, generiert UNICODE im Schema.
national¶ – Optional. Wenn true, wird die vom Server konfigurierte nationale Zeichenkodierung verwendet.
binary¶ – Standardmäßig False: Kurzform, wählt den binären Sortierungstyp, der zur Zeichenkodierung der Spalte passt. Generiert BINARY im Schema. Dies hat keinen Einfluss auf die Art der gespeicherten Daten, nur auf die Sortierung von Zeichendaten.

class sqlalchemy.dialects.mysql.MEDIUMBLOB¶: MySQL MEDIUMBLOB-Typ für Binärdaten bis zu 2^24 Bytes.

Klassensignatur

class sqlalchemy.dialects.mysql.MEDIUMBLOB (sqlalchemy.types._Binary)

class sqlalchemy.dialects.mysql.MEDIUMINT¶

MySQL MEDIUMINTEGER-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.MEDIUMINT (sqlalchemy.dialects.mysql.types._IntegerType)

method sqlalchemy.dialects.mysql.MEDIUMINT.__init__(display_width=None, **kw)¶

Konstruiert ein MEDIUMINTEGER.

Parameter:

display_width¶ – Optional, maximale Anzeigebreite für diese Zahl.
unsigned¶ – ein boolescher Wert, optional.
zerofill¶ – Optional. Wenn true, werden Werte als Strings gespeichert, die mit Nullen links aufgefüllt sind. Beachten Sie, dass dies die vom zugrunde liegenden Datenbank-API zurückgegebenen Werte nicht beeinflusst, die weiterhin numerisch sind.

class sqlalchemy.dialects.mysql.MEDIUMTEXT¶

MySQL MEDIUMTEXT-Typ für Zeichenspeicherung, kodiert bis zu 2^24 Bytes.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.MEDIUMTEXT (sqlalchemy.dialects.mysql.types._StringType)

method sqlalchemy.dialects.mysql.MEDIUMTEXT.__init__(**kwargs)¶

Konstruiert ein MEDIUMTEXT.

Parameter:

charset¶ – Optional, eine zeichenkettenbezogene Zeichenkodierung für diesen Zeichenkettenwert. Hat Vorrang vor den Kurzformen „ascii“ oder „unicode“.
collation¶ – Optional, eine zeichenkettenbezogene Sortierung für diesen Zeichenkettenwert. Hat Vorrang vor der Kurzform „binary“.
ascii¶ – Standardmäßig False: Kurzform für die latin1-Zeichenkodierung, generiert ASCII im Schema.
unicode¶ – Standardmäßig False: Kurzform für die ucs2-Zeichenkodierung, generiert UNICODE im Schema.
national¶ – Optional. Wenn true, wird die vom Server konfigurierte nationale Zeichenkodierung verwendet.
binary¶ – Standardmäßig False: Kurzform, wählt den binären Sortierungstyp, der zur Zeichenkodierung der Spalte passt. Generiert BINARY im Schema. Dies hat keinen Einfluss auf die Art der gespeicherten Daten, nur auf die Sortierung von Zeichendaten.

class sqlalchemy.dialects.mysql.NCHAR¶

MySQL NCHAR-Typ.

Für zeichen mit fester Länge in der vom Server konfigurierten nationalen Zeichenkodierung.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.NCHAR (sqlalchemy.dialects.mysql.types._StringType, sqlalchemy.types.NCHAR)

method sqlalchemy.dialects.mysql.NCHAR.__init__(length=None, **kwargs)¶

Konstruiert ein NCHAR.

Parameter:

length¶ – Maximale Datenlänge in Zeichen.
binary¶ – Optional, verwendet die standardmäßige binäre Sortierung für die nationale Zeichenkodierung. Dies hat keinen Einfluss auf die Art der gespeicherten Daten, verwenden Sie einen BINARY-Typ für Binärdaten.
collation¶ – Optional, fordert eine bestimmte Sortierung an. Muss mit der nationalen Zeichenkodierung kompatibel sein.

class sqlalchemy.dialects.mysql.NUMERIC¶

MySQL NUMERIC-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.NUMERIC (sqlalchemy.dialects.mysql.types._NumericType, sqlalchemy.types.NUMERIC)

method sqlalchemy.dialects.mysql.NUMERIC.__init__(precision=None, scale=None, asdecimal=True, **kw)¶

Konstruiert ein NUMERIC.

Parameter:

precision¶ – Gesamtzahl der Ziffern in dieser Zahl. Wenn scale und precision beide None sind, werden Werte bis zu den vom Server erlaubten Grenzen gespeichert.
scale¶ – Die Anzahl der Ziffern nach dem Dezimalpunkt.
unsigned¶ – ein boolescher Wert, optional.
zerofill¶ – Optional. Wenn true, werden Werte als Strings gespeichert, die mit Nullen links aufgefüllt sind. Beachten Sie, dass dies die vom zugrunde liegenden Datenbank-API zurückgegebenen Werte nicht beeinflusst, die weiterhin numerisch sind.

class sqlalchemy.dialects.mysql.NVARCHAR¶

MySQL NVARCHAR-Typ.

Für Zeichenketten mit variabler Länge in der vom Server konfigurierten nationalen Zeichenkodierung.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.NVARCHAR (sqlalchemy.dialects.mysql.types._StringType, sqlalchemy.types.NVARCHAR)

methode sqlalchemy.dialects.mysql.NVARCHAR.__init__(length=None, **kwargs)¶

Erstellt eine NVARCHAR.

Parameter:

Länge¶ – Maximale Datenlänge in Zeichen.
binär¶ – Optional, verwendet die Standard-Binärkollation für den nationalen Zeichensatz. Dies hat keinen Einfluss auf die Art der gespeicherten Daten, verwenden Sie einen BINARY-Typ für Binärdaten.
Kollation¶ – Optional, fordert eine bestimmte Kollation an. Muss mit dem nationalen Zeichensatz kompatibel sein.

klasse sqlalchemy.dialects.mysql.REAL¶

MySQL REAL-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.REAL (sqlalchemy.dialects.mysql.types._FloatType, sqlalchemy.types.REAL)

methode sqlalchemy.dialects.mysql.REAL.__init__(precision=None, scale=None, asdecimal=True, **kw)¶

Erstellt eine REAL.

Hinweis

Der Typ REAL konvertiert standardmäßig von Float zu Decimal, wobei eine Trunkierung mit Standardwerten von 10 Ziffern verwendet wird. Geben Sie entweder scale=n oder decimal_return_scale=n an, um diese Skala zu ändern, oder asdecimal=False, um Werte direkt als Python-Gleitkommazahlen zurückzugeben.

Parameter:

Präzision¶ – Gesamtzahl der Ziffern in dieser Zahl. Wenn Skala und Präzision beide None sind, werden Werte bis zu den vom Server erlaubten Grenzen gespeichert.
Skala¶ – Die Anzahl der Ziffern nach dem Dezimalpunkt.
vorzeichenlos¶ – ein boolescher Wert, optional.
zerofill¶ – Optional. Wenn True, werden Werte als Strings gespeichert, die mit Nullen links aufgefüllt sind. Beachten Sie, dass dies keinen Einfluss auf die von der zugrunde liegenden Datenbank-API zurückgegebenen Werte hat, die weiterhin numerisch sind.

klasse sqlalchemy.dialects.mysql.SET¶

MySQL SET-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.SET (sqlalchemy.dialects.mysql.types._StringType)

methode sqlalchemy.dialects.mysql.SET.__init__(*values, **kw)¶

Erstellt eine SET.

Z. B.

Column("myset", SET("foo", "bar", "baz"))

Die Liste der möglichen Werte ist erforderlich, falls dieses Set zur Generierung von DDL für eine Tabelle verwendet wird oder wenn das Flag SET.retrieve_as_bitwise auf True gesetzt ist.

Parameter:

Werte¶ – Der Bereich der gültigen Werte für dieses SET. Die Werte werden nicht zitiert, sie werden beim Generieren des Schemas escaped und von einfachen Anführungszeichen umschlossen.
convert_unicode¶ – Gleiches Flag wie bei String.convert_unicode.
Kollation¶ – wie bei String.collation
Zeichensatz¶ – wie bei VARCHAR.charset.
ascii¶ – wie bei VARCHAR.ascii.
unicode¶ – wie bei VARCHAR.unicode.
binär¶ – wie bei VARCHAR.binary.
retrieve_as_bitwise¶ –
wenn True, werden die Daten für den SET-Typ als Integer-Wert gespeichert und ausgewählt, wobei ein Set für die Persistenz in eine Bitmaske umgewandelt wird. MySQL erlaubt diesen Modus, der den Vorteil hat, Werte eindeutig speichern zu können, wie z. B. den leeren String ''. Der Datentyp erscheint in einer SELECT-Anweisung als Ausdruck col + 0, sodass der Wert in Ergebnissets in einen Integer-Wert umgewandelt wird. Dieses Flag ist erforderlich, wenn ein Set gespeichert werden soll, das den leeren String '' als Wert speichern kann.

Warnung

Bei Verwendung von SET.retrieve_as_bitwise ist es unerlässlich, dass die Liste der Set-Werte **genau in der gleichen Reihenfolge** wie in der MySQL-Datenbank angegeben wird.

klasse sqlalchemy.dialects.mysql.SMALLINT¶

MySQL SMALLINTEGER-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.SMALLINT (sqlalchemy.dialects.mysql.types._IntegerType, sqlalchemy.types.SMALLINT)

methode sqlalchemy.dialects.mysql.SMALLINT.__init__(display_width=None, **kw)¶

Erstellt eine SMALLINTEGER.

Parameter:

Anzeigebreite¶ – Optional, maximale Anzeigebreite für diese Zahl.
vorzeichenlos¶ – ein boolescher Wert, optional.
zerofill¶ – Optional. Wenn True, werden Werte als Strings gespeichert, die mit Nullen links aufgefüllt sind. Beachten Sie, dass dies keinen Einfluss auf die von der zugrunde liegenden Datenbank-API zurückgegebenen Werte hat, die weiterhin numerisch sind.

klasse sqlalchemy.dialects.mysql.TEXT

MySQL TEXT-Typ, für die Speicherung von Zeichen, die bis zu 2^16 Bytes kodiert sind.

Klassensignatur

class sqlalchemy.dialects.mysql.TEXT (sqlalchemy.dialects.mysql.types._StringType, sqlalchemy.types.TEXT)

methode sqlalchemy.dialects.mysql.TEXT.__init__(length=None, **kw)

Erstellt ein TEXT.

Parameter:

Länge¶ – Optional, wenn angegeben, kann der Server die Speicherung optimieren, indem er den kleinsten TEXT-Typ wählt, der ausreicht, um length Bytes an Zeichen zu speichern.
Zeichensatz¶ – Optional, ein zeichenbezogener Zeichensatz für diesen String-Wert. Hat Vorrang vor den Kurzformen 'ascii' oder 'unicode'.
Kollation¶ – Optional, eine spaltenbezogene Kollation für diesen String-Wert. Hat Vorrang vor der Kurzform 'binary'.
ascii¶ – Standardmäßig False: Kurzform für den Zeichensatz latin1, generiert ASCII im Schema.
unicode¶ – Standardmäßig False: Kurzform für den Zeichensatz ucs2, generiert UNICODE im Schema.
national¶ – Optional. Wenn True, wird der konfigurierte nationale Zeichensatz des Servers verwendet.
binär¶ – Standardmäßig False: Kurzform, wählt den Binärkollationstyp, der dem Zeichensatz der Spalte entspricht. Generiert BINARY im Schema. Dies hat keinen Einfluss auf die Art der gespeicherten Daten, nur auf die Kollation von Zeichendaten.

klasse sqlalchemy.dialects.mysql.TIME¶

MySQL TIME-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.TIME (sqlalchemy.types.TIME)

methode sqlalchemy.dialects.mysql.TIME.__init__(timezone=False, fsp=None)¶

Erstellt einen MySQL TIME-Typ.

Parameter:

Zeitzone¶ – wird vom MySQL-Dialekt nicht verwendet.
fsp¶ –
Wert für die Genauigkeit von Nachkommastellen. MySQL 5.6 unterstützt die Speicherung von Nachkommastellen; dieser Parameter wird beim Ausgeben von DDL für den TIME-Typ verwendet.

Hinweis

Die DBAPI-Treiberunterstützung für Bruchteile von Sekunden kann begrenzt sein; die aktuelle Unterstützung umfasst MySQL Connector/Python.

klasse sqlalchemy.dialects.mysql.TIMESTAMP¶

MySQL TIMESTAMP-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.TIMESTAMP (sqlalchemy.types.TIMESTAMP)

methode sqlalchemy.dialects.mysql.TIMESTAMP.__init__(timezone=False, fsp=None)¶

Erstellt einen MySQL TIMESTAMP-Typ.

Parameter:

Zeitzone¶ – wird vom MySQL-Dialekt nicht verwendet.
fsp¶ –
Wert für die Genauigkeit von Nachkommastellen. MySQL 5.6.4 unterstützt die Speicherung von Nachkommastellen; dieser Parameter wird beim Ausgeben von DDL für den TIMESTAMP-Typ verwendet.

Hinweis

Die DBAPI-Treiberunterstützung für Bruchteile von Sekunden kann begrenzt sein; die aktuelle Unterstützung umfasst MySQL Connector/Python.

klasse sqlalchemy.dialects.mysql.TINYBLOB¶: MySQL TINYBLOB-Typ für Binärdaten bis zu 2^8 Bytes.

Klassensignatur

class sqlalchemy.dialects.mysql.TINYBLOB (sqlalchemy.types._Binary)

klasse sqlalchemy.dialects.mysql.TINYINT¶

MySQL TINYINT-Typ.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.TINYINT (sqlalchemy.dialects.mysql.types._IntegerType)

methode sqlalchemy.dialects.mysql.TINYINT.__init__(display_width=None, **kw)¶

Erstellt eine TINYINT.

Parameter:

Anzeigebreite¶ – Optional, maximale Anzeigebreite für diese Zahl.
vorzeichenlos¶ – ein boolescher Wert, optional.
zerofill¶ – Optional. Wenn True, werden Werte als Strings gespeichert, die mit Nullen links aufgefüllt sind. Beachten Sie, dass dies keinen Einfluss auf die von der zugrunde liegenden Datenbank-API zurückgegebenen Werte hat, die weiterhin numerisch sind.

klasse sqlalchemy.dialects.mysql.TINYTEXT¶

MySQL TINYTEXT-Typ für Zeichenspeicherung, kodiert bis zu 2^8 Bytes.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.TINYTEXT (sqlalchemy.dialects.mysql.types._StringType)

methode sqlalchemy.dialects.mysql.TINYTEXT.__init__(**kwargs)¶

Erstellt ein TINYTEXT.

Parameter:

Zeichensatz¶ – Optional, ein zeichenbezogener Zeichensatz für diesen String-Wert. Hat Vorrang vor den Kurzformen 'ascii' oder 'unicode'.
Kollation¶ – Optional, eine spaltenbezogene Kollation für diesen String-Wert. Hat Vorrang vor der Kurzform 'binary'.
ascii¶ – Standardmäßig False: Kurzform für den Zeichensatz latin1, generiert ASCII im Schema.
unicode¶ – Standardmäßig False: Kurzform für den Zeichensatz ucs2, generiert UNICODE im Schema.
national¶ – Optional. Wenn True, wird der konfigurierte nationale Zeichensatz des Servers verwendet.
binär¶ – Standardmäßig False: Kurzform, wählt den Binärkollationstyp, der dem Zeichensatz der Spalte entspricht. Generiert BINARY im Schema. Dies hat keinen Einfluss auf die Art der gespeicherten Daten, nur auf die Kollation von Zeichendaten.

klasse sqlalchemy.dialects.mysql.VARBINARY: Der SQL VARBINARY-Typ.

Klassensignatur

class sqlalchemy.dialects.mysql.VARBINARY (sqlalchemy.types._Binary)

klasse sqlalchemy.dialects.mysql.VARCHAR¶

MySQL VARCHAR-Typ für Zeichen mit variabler Länge.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.dialects.mysql.VARCHAR (sqlalchemy.dialects.mysql.types._StringType, sqlalchemy.types.VARCHAR)

methode sqlalchemy.dialects.mysql.VARCHAR.__init__(length=None, **kwargs)¶

Erstellt eine VARCHAR.

Parameter:

Zeichensatz¶ – Optional, ein zeichenbezogener Zeichensatz für diesen String-Wert. Hat Vorrang vor den Kurzformen 'ascii' oder 'unicode'.
Kollation¶ – Optional, eine spaltenbezogene Kollation für diesen String-Wert. Hat Vorrang vor der Kurzform 'binary'.
ascii¶ – Standardmäßig False: Kurzform für den Zeichensatz latin1, generiert ASCII im Schema.
unicode¶ – Standardmäßig False: Kurzform für den Zeichensatz ucs2, generiert UNICODE im Schema.
national¶ – Optional. Wenn True, wird der konfigurierte nationale Zeichensatz des Servers verwendet.
binär¶ – Standardmäßig False: Kurzform, wählt den Binärkollationstyp, der dem Zeichensatz der Spalte entspricht. Generiert BINARY im Schema. Dies hat keinen Einfluss auf die Art der gespeicherten Daten, nur auf die Kollation von Zeichendaten.

klasse sqlalchemy.dialects.mysql.YEAR¶: MySQL YEAR-Typ für ein Byte zur Speicherung von Jahren 1901-2155.

Klassensignatur

class sqlalchemy.dialects.mysql.YEAR (sqlalchemy.types.TypeEngine)

MySQL DML-Konstrukte¶

Objektname	Beschreibung
insert(tabelle)	Konstruiert eine MySQL/MariaDB-spezifische Variante des `Insert`-Konstrukts.
Insert	MySQL-spezifische Implementierung von INSERT.

funktion sqlalchemy.dialects.mysql.insert(tabelle: _DMLTableArgument) → Insert¶

Konstruiert eine MySQL/MariaDB-spezifische Variante des Insert-Konstrukts.

Die Funktion sqlalchemy.dialects.mysql.insert() erstellt ein sqlalchemy.dialects.mysql.Insert. Diese Klasse basiert auf dem Dialekt-unabhängigen Konstrukt Insert, das mit der Funktion insert() in SQLAlchemy Core erstellt werden kann.

Der Konstrukt Insert beinhaltet zusätzliche Methoden wie Insert.on_duplicate_key_update().

class sqlalchemy.dialects.mysql.Insert¶

MySQL-spezifische Implementierung von INSERT.

Fügt Methoden für MySQL-spezifische Syntaxen wie ON DUPLICATE KEY UPDATE hinzu.

Das Objekt Insert wird über die Funktion sqlalchemy.dialects.mysql.insert() erstellt.

Neu seit Version 1.2.

Mitglieder

inherit_cache, inserted, on_duplicate_key_update()

Klassensignatur

class sqlalchemy.dialects.mysql.Insert (sqlalchemy.sql.expression.Insert)

attribute sqlalchemy.dialects.mysql.Insert.inherit_cache: bool | None = False¶

Gibt an, ob diese HasCacheKey-Instanz das Cache-Schlüssel-Generierungsschema ihrer direkten Oberklasse verwenden soll.

Das Attribut hat standardmäßig den Wert None, was bedeutet, dass ein Konstrukt noch nicht berücksichtigt hat, ob es für die Teilnahme an der Caching-Mechanik geeignet ist. Dies ist funktional äquivalent zum Setzen des Wertes auf False, außer dass auch eine Warnung ausgegeben wird.

Dieses Flag kann auf True für eine bestimmte Klasse gesetzt werden, wenn die SQL, die diesem Objekt entspricht, nicht auf Basis von Attributen geändert wird, die lokal zu dieser Klasse und nicht zu ihrer Oberklasse gehören.

Siehe auch

Unterstützung für Caching für benutzerdefinierte Konstrukte aktivieren - Allgemeine Richtlinien für die Einstellung des Attributs HasCacheKey.inherit_cache für SQL-Konstrukte von Drittanbietern oder benutzerdefinierte SQL-Konstrukte.

attribute sqlalchemy.dialects.mysql.Insert.inserted¶

Stellt den „inserted“-Namespace für eine ON DUPLICATE KEY UPDATE-Anweisung bereit.

Die ON DUPLICATE KEY UPDATE-Klausel von MySQL erlaubt den Verweis auf die Zeile, die eingefügt werden würde, über eine spezielle Funktion namens VALUES(). Dieses Attribut stellt alle Spalten dieser Zeile zur Verfügung, auf die so verwiesen werden kann, dass sie innerhalb einer VALUES()-Funktion in der ON DUPLICATE KEY UPDATE-Klausel gerendert werden. Das Attribut heißt .inserted, um Konflikte mit der bestehenden Methode Insert.values() zu vermeiden.

Tipp

Das Attribut Insert.inserted ist eine Instanz von ColumnCollection, die eine Schnittstelle bietet, die der des Table.c-Kollektion ähnelt, die unter Zugriff auf Tabellen und Spalten beschrieben wird. Mit dieser Kollektion sind normale Namen wie Attribute zugänglich (z.B. stmt.inserted.some_column), aber spezielle Namen und Methodennamen von Dictionaries sollten über indizierten Zugriff abgerufen werden, wie z.B. stmt.inserted["column name"] oder stmt.inserted["values"]. Weitere Beispiele finden Sie in der Docstring von ColumnCollection.

Siehe auch

INSERT…ON DUPLICATE KEY UPDATE (Upsert) - Beispiel zur Verwendung von Insert.inserted

method sqlalchemy.dialects.mysql.Insert.on_duplicate_key_update(*args: Mapping[Any, Any] | List[Tuple[str, Any]] | ColumnCollection[Any, Any], **kw: Any) → Self¶

Gibt die ON DUPLICATE KEY UPDATE-Klausel an.

Parameter:: **kw¶ – Spaltenschlüssel, die mit UPDATE-Werten verknüpft sind. Die Werte können beliebige SQL-Ausdrücke oder unterstützte literale Python-Werte sein.

Warnung

Dieses Wörterbuch berücksichtigt **keine** Python-spezifizierten Standard-UPDATE-Werte oder Generierungsfunktionen, z.B. jene, die mit Column.onupdate angegeben wurden. Diese Werte werden für einen UPDATE im Stil von ON DUPLICATE KEY UPDATE nicht berücksichtigt, es sei denn, die Werte werden hier manuell angegeben.

Parameter:

*args¶ –

Als Alternative zur Übergabe von Schlüssel/Wert-Parametern kann ein Wörterbuch oder eine Liste von 2-Tupeln als einzelnes positionsgebundenes Argument übergeben werden.

Die Übergabe eines einzelnen Wörterbuchs entspricht der Schlüsselwortargument-Form.

insert().on_duplicate_key_update({"name": "some name"})

Die Übergabe einer Liste von 2-Tupeln zeigt an, dass die Parameterzuweisungen in der UPDATE-Klausel in der Reihenfolge erfolgen sollen, wie sie gesendet werden, ähnlich wie für den Gesamtkonstrukt Update in Parameter-geordneten Updates beschrieben.

insert().on_duplicate_key_update(
    [
        ("name", "some name"),
        ("value", "some value"),
    ]
)

Geändert in Version 1.3: Parameter können als Wörterbuch oder als Liste von 2-Tupeln angegeben werden; letztere Form ermöglicht die Parameterreihenfolge.

Neu seit Version 1.2.

Siehe auch

INSERT…ON DUPLICATE KEY UPDATE (Upsert)

mysqlclient (Fork von MySQL-Python)¶

Unterstützung für die MySQL / MariaDB-Datenbank über den mysqlclient (gepflegter Fork von MySQL-Python) Treiber.

DBAPI¶

Dokumentations- und Downloadinformationen (falls zutreffend) für mysqlclient (gepflegter Fork von MySQL-Python) sind verfügbar unter: https://pypi.org/project/mysqlclient/

Verbindung¶

Verbindungszeichenfolge

mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

Treiberstatus¶

Der mysqlclient DBAPI ist ein gepflegter Fork des nicht mehr gewarteten MySQL-Python DBAPI. mysqlclient unterstützt Python 2 und Python 3 und ist sehr stabil.

Unicode¶

Bitte beachten Sie Unicode für aktuelle Empfehlungen zur Unicode-Handhabung.

SSL-Verbindungen¶

Die DBAPIs mysqlclient und PyMySQL akzeptieren ein zusätzliches Wörterbuch unter dem Schlüssel „ssl“, das über das Wörterbuch create_engine.connect_args angegeben werden kann.

engine = create_engine(
    "mysql+mysqldb://scott:tiger@192.168.0.134/test",
    connect_args={
        "ssl": {
            "ca": "/home/gord/client-ssl/ca.pem",
            "cert": "/home/gord/client-ssl/client-cert.pem",
            "key": "/home/gord/client-ssl/client-key.pem",
        }
    },
)

Zur Bequemlichkeit können die folgenden Schlüssel auch inline in der URL angegeben werden, wo sie automatisch in das „ssl“-Wörterbuch übersetzt werden: „ssl_ca“, „ssl_cert“, „ssl_key“, „ssl_capath“, „ssl_cipher“, „ssl_check_hostname“. Ein Beispiel ist wie folgt:

connection_uri = (
    "mysql+mysqldb://scott:tiger@192.168.0.134/test"
    "?ssl_ca=/home/gord/client-ssl/ca.pem"
    "&ssl_cert=/home/gord/client-ssl/client-cert.pem"
    "&ssl_key=/home/gord/client-ssl/client-key.pem"
)

Siehe auch

SSL-Verbindungen im PyMySQL-Dialekt

Verwendung von MySQLdb mit Google Cloud SQL¶

Google Cloud SQL empfiehlt nun die Verwendung des MySQLdb-Dialekts. Verbinden Sie sich mit einer URL wie der folgenden:

mysql+mysqldb://root@/<dbname>?unix_socket=/cloudsql/<projectid>:<instancename>

Serverseitige Cursor¶

Der mysqldb-Dialekt unterstützt serverseitige Cursor. Siehe Serverseitige Cursor.

PyMySQL¶

Unterstützung für die MySQL / MariaDB-Datenbank über den PyMySQL-Treiber.

DBAPI¶

Dokumentations- und Downloadinformationen (falls zutreffend) für PyMySQL sind verfügbar unter: https://pymysql.readthedocs.io/

Verbindung¶

Verbindungszeichenfolge

mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

Unicode¶

Bitte beachten Sie Unicode für aktuelle Empfehlungen zur Unicode-Handhabung.

SSL-Verbindungen¶

Der PyMySQL DBAPI akzeptiert die gleichen SSL-Argumente wie der von MySQLdb, beschrieben unter SSL-Verbindungen. Siehe diesen Abschnitt für zusätzliche Beispiele.

Wenn der Server ein automatisch generiertes Zertifikat verwendet, das selbstsigniert ist oder nicht mit dem Hostnamen übereinstimmt (aus Sicht des Clients), kann es auch notwendig sein, ssl_check_hostname=false in PyMySQL anzugeben.

connection_uri = (
    "mysql+pymysql://scott:tiger@192.168.0.134/test"
    "?ssl_ca=/home/gord/client-ssl/ca.pem"
    "&ssl_cert=/home/gord/client-ssl/client-cert.pem"
    "&ssl_key=/home/gord/client-ssl/client-key.pem"
    "&ssl_check_hostname=false"
)

MySQL-Python-Kompatibilität¶

Der pymysql DBAPI ist ein reiner Python-Port des MySQL-python (MySQLdb) Treibers und zielt auf 100%ige Kompatibilität ab. Die meisten Verhaltenshinweise für MySQL-python gelten auch für den pymysql-Treiber.

MariaDB-Connector¶

Unterstützung für die MySQL / MariaDB-Datenbank über den MariaDB Connector/Python-Treiber.

DBAPI¶

Dokumentations- und Downloadinformationen (falls zutreffend) für MariaDB Connector/Python sind verfügbar unter: https://pypi.org/project/mariadb/

Verbindung¶

Verbindungszeichenfolge

mariadb+mariadbconnector://<user>:<password>@<host>[:<port>]/<dbname>

Treiberstatus¶

MariaDB Connector/Python ermöglicht es Python-Programmen, auf MariaDB- und MySQL-Datenbanken zuzugreifen, und zwar mit einer API, die mit Python DB API 2.0 (PEP-249) konform ist. Es ist in C geschrieben und verwendet die MariaDB Connector/C-Clientbibliothek für die Client-Server-Kommunikation.

Beachten Sie, dass der Standardtreiber für eine mariadb:// Verbindungs-URI weiterhin mysqldb ist. mariadb+mariadbconnector:// ist erforderlich, um diesen Treiber zu verwenden.

MySQL-Connector¶

Unterstützung für die MySQL / MariaDB-Datenbank über den MySQL Connector/Python-Treiber.

DBAPI¶

Dokumentations- und Downloadinformationen (falls zutreffend) für MySQL Connector/Python sind verfügbar unter: https://pypi.org/project/mysql-connector-python/

Verbindung¶

Verbindungszeichenfolge

mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

Hinweis

Der MySQL Connector/Python DBAPI hatte seit seiner Veröffentlichung viele Probleme, von denen einige möglicherweise ungelöst bleiben, und der mysqlconnector-Dialekt wird **nicht im Rahmen der kontinuierlichen Integration von SQLAlchemy getestet**. Die empfohlenen MySQL-Dialekte sind mysqlclient und PyMySQL.

asyncmy¶

Unterstützung für die MySQL / MariaDB-Datenbank über den asyncmy-Treiber.

DBAPI¶

Dokumentations- und Downloadinformationen (falls zutreffend) für asyncmy sind verfügbar unter: https://github.com/long2ice/asyncmy

Verbindung¶

Verbindungszeichenfolge

mysql+asyncmy://user:password@host:port/dbname[?key=value&key=value...]

Durch die Verwendung einer speziellen Asynchron-Mediationsschicht kann der asyncmy-Dialekt als Backend für das Erweiterungspaket SQLAlchemy asyncio verwendet werden.

Dieser Dialekt sollte normalerweise nur mit der Engine-Erstellungsfunktion create_async_engine() verwendet werden.

from sqlalchemy.ext.asyncio import create_async_engine

engine = create_async_engine(
    "mysql+asyncmy://user:pass@hostname/dbname?charset=utf8mb4"
)

aiomysql¶

Unterstützung für die MySQL / MariaDB-Datenbank über den aiomysql-Treiber.

DBAPI¶

Dokumentations- und Downloadinformationen (falls zutreffend) für aiomysql sind verfügbar unter: https://github.com/aio-libs/aiomysql

Verbindung¶

Verbindungszeichenfolge

mysql+aiomysql://user:password@host:port/dbname[?key=value&key=value...]

Der aiomysql-Dialekt ist der zweite Python-Asynchron-Dialekt von SQLAlchemy.

Durch die Verwendung einer speziellen Asynchron-Mediationsschicht kann der aiomysql-Dialekt als Backend für das Erweiterungspaket SQLAlchemy asyncio verwendet werden.

Dieser Dialekt sollte normalerweise nur mit der Engine-Erstellungsfunktion create_async_engine() verwendet werden.

from sqlalchemy.ext.asyncio import create_async_engine

engine = create_async_engine(
    "mysql+aiomysql://user:pass@hostname/dbname?charset=utf8mb4"
)

cymysql¶

Unterstützung für die MySQL / MariaDB-Datenbank über den CyMySQL-Treiber.

DBAPI¶

Dokumentations- und Downloadinformationen (falls zutreffend) für CyMySQL sind verfügbar unter: https://github.com/nakagami/CyMySQL

Verbindung¶

Verbindungszeichenfolge

mysql+cymysql://<username>:<password>@<host>/<dbname>[?<options>]

Hinweis

Der CyMySQL-Dialekt wird **nicht im Rahmen der kontinuierlichen Integration von SQLAlchemy getestet** und kann ungelöste Probleme aufweisen. Die empfohlenen MySQL-Dialekte sind mysqlclient und PyMySQL.

pyodbc¶

Unterstützung für die MySQL / MariaDB-Datenbank über den PyODBC-Treiber.

DBAPI¶

Dokumentations- und Downloadinformationen (falls zutreffend) für PyODBC sind verfügbar unter: https://pypi.org/project/pyodbc/

Verbindung¶

Verbindungszeichenfolge

mysql+pyodbc://<username>:<password>@<dsnname>

Hinweis

Der PyODBC-Dialekt für MySQL wird **nicht im Rahmen der kontinuierlichen Integration von SQLAlchemy getestet**. Die empfohlenen MySQL-Dialekte sind mysqlclient und PyMySQL. Wenn Sie jedoch den mysql+pyodbc-Dialekt verwenden und volle Unterstützung für utf8mb4-Zeichen (einschließlich ergänzender Zeichen wie Emoji) benötigen, stellen Sie sicher, dass Sie eine aktuelle Version von MySQL Connector/ODBC verwenden und die „ANSI“-Version (nicht „Unicode“) des Treibers in Ihrem DSN oder Ihrer Verbindungszeichenfolge angeben.

Durchleitung der exakten pyodbc-Verbindungszeichenfolge

import urllib

connection_string = (
    "DRIVER=MySQL ODBC 8.0 ANSI Driver;"
    "SERVER=localhost;"
    "PORT=3307;"
    "DATABASE=mydb;"
    "UID=root;"
    "PWD=(whatever);"
    "charset=utf8mb4;"
)
params = urllib.parse.quote_plus(connection_string)
connection_uri = "mysql+pyodbc:///?odbc_connect=%s" % params

SQLAlchemy 2.0 Dokumentation

SQLAlchemy 2.0 Dokumentation

Dialekte

Projektversionen

MySQL und MariaDB¶

DBAPI-Unterstützung¶

Unterstützte Versionen und Funktionen¶

MariaDB-Unterstützung¶

MariaDB-Only-Modus¶

Verbindungszeitüberschreitungen und Trennungen¶

CREATE TABLE Argumente, einschließlich Storage Engines¶

Groß-/Kleinschreibung und Tabellenreflexion¶

Transaktionsisolationslevel¶

AUTO_INCREMENT Verhalten¶

Serverseitige Cursor¶

Unicode¶

Zeichensatz Auswahl¶

Umgang mit Warnungen zu Binärdaten und Unicode¶

ANSI-Quoting-Stil¶

Ändern des sql_mode¶

MySQL / MariaDB SQL-Erweiterungen¶

INSERT/DELETE…RETURNING¶

INSERT…ON DUPLICATE KEY UPDATE (Upsert)¶

rowcount Unterstützung¶

MySQL / MariaDB-spezifische Indexoptionen¶

Indexlänge¶

Indexpräfixe¶

Indextypen¶

Index-Parser¶

MySQL / MariaDB Fremdschlüssel¶

Zu vermeidende Fremdschlüsselargumente¶

Reflektion von Fremdschlüsselbeschränkungen¶

MySQL / MariaDB Eindeutigkeitsbeschränkungen und Reflexion¶

TIMESTAMP / DATETIME-Probleme¶

Rendern von ON UPDATE CURRENT TIMESTAMP für explicit_defaults_for_timestamp von MySQL / MariaDB¶

TIMESTAMP-Spalten und NULL¶

MySQL SQL-Konstrukte¶

MySQL-Datentypen¶

MySQL DML-Konstrukte¶

mysqlclient (Fork von MySQL-Python)¶

DBAPI¶

Verbindung¶

Treiberstatus¶

Unicode¶

SSL-Verbindungen¶

Verwendung von MySQLdb mit Google Cloud SQL¶

Serverseitige Cursor¶

PyMySQL¶

DBAPI¶

Verbindung¶

Unicode¶

SSL-Verbindungen¶

MySQL-Python-Kompatibilität¶

MariaDB-Connector¶

DBAPI¶

Verbindung¶

Treiberstatus¶

MySQL-Connector¶

DBAPI¶

Verbindung¶

asyncmy¶

DBAPI¶

Verbindung¶

aiomysql¶

DBAPI¶

Verbindung¶

cymysql¶

DBAPI¶

Verbindung¶

pyodbc¶

DBAPI¶

Verbindung¶