Core Internals¶

Hier sind einige wichtige interne Konstrukte aufgelistet.

Objektname	Beschreibung
AdaptedConnection	Schnittstelle eines angepassten Verbindungsobjekts zur Unterstützung des DBAPI-Protokolls.
BindTyping	Definiert verschiedene Methoden zur Übergabe von Typinformationen für gebundene Parameter in einer Anweisung an den Datenbanktreiber.
Compiled	Stellt einen kompilierten SQL- oder DDL-Ausdruck dar.
DBAPIConnection	Protokoll, das eine PEP 249-Datenbankverbindung darstellt.
DBAPICursor	Protokoll, das einen PEP 249-Datenbankcursor darstellt.
DBAPIType	Protokoll, das einen PEP 249-Datenbanktyp darstellt.
DDLCompiler
DefaultDialect	Standardimplementierung von Dialect
DefaultExecutionContext
Dialect	Definiert das Verhalten einer bestimmten Datenbank- und DB-API-Kombination.
ExecutionContext	Ein Botenobjekt für ein Dialekt, das einer einzelnen Ausführung entspricht.
ExpandedState	repräsentiert den Zustand, der bei der Erzeugung von „erweiterten“ und „post-compile“-gebundenen Parametern für eine Anweisung verwendet wird.
GenericTypeCompiler
Identified
IdentifierPreparer	Behandelt das Zitieren und Groß-/Kleinschreibung von Bezeichnern basierend auf Optionen.
SQLCompiler	Standardimplementierung von `Compiled`.
StrSQLCompiler	Eine `SQLCompiler`-Unterklasse, die eine kleine Auswahl nicht standardmäßiger SQL-Funktionen zulässt, um sie als Zeichenkettenwert zu rendern.

class sqlalchemy.engine.BindTyping¶

Definiert verschiedene Methoden zur Übergabe von Typinformationen für gebundene Parameter in einer Anweisung an den Datenbanktreiber.

Neu in Version 2.0.

Mitglieder

NONE, RENDER_CASTS, SETINPUTSIZES

Klassensignatur

class sqlalchemy.engine.BindTyping (enum.Enum)

attribute sqlalchemy.engine.BindTyping.NONE = 1¶

Es werden keine Schritte unternommen, um Typinformationen an den Datenbanktreiber zu übergeben.

Dies ist das Standardverhalten für Datenbanken wie SQLite, MySQL / MariaDB, SQL Server.

attribute sqlalchemy.engine.BindTyping.RENDER_CASTS = 3¶

Rendert Casts oder andere Direktiven in der SQL-Zeichenkette.

Diese Methode wird für alle PostgreSQL-Dialekte verwendet, einschließlich asyncpg, pg8000, psycopg, psycopg2. Dialekte, die dies implementieren, können wählen, welche Arten von Datentypen explizit in SQL-Anweisungen umgewandelt werden und welche nicht.

Wenn RENDER_CASTS verwendet wird, ruft der Compiler die Methode SQLCompiler.render_bind_cast() für die gerenderte Zeichenfolgendarstellung jedes BindParameter-Objekts auf, dessen Dialekt-Level-Typ das Attribut TypeEngine.render_bind_cast gesetzt hat.

Die Methode SQLCompiler.render_bind_cast() wird auch verwendet, um Casts für eine Form von „insertmanyvalues“-Abfrage zu rendern, wenn sowohl InsertmanyvaluesSentinelOpts.USE_INSERT_FROM_SELECT als auch InsertmanyvaluesSentinelOpts.RENDER_SELECT_COL_CASTS gesetzt sind, wobei die Casts auf die Zwischenspalten angewendet werden, z. B. „INSERT INTO t (a, b, c) SELECT p0::TYP, p1::TYP, p2::TYP “ “FROM (VALUES (?, ?), (?, ?), …)”.

Neu in Version 2.0.10: - SQLCompiler.render_bind_cast() wird nun in einigen Elementen der „insertmanyvalues“-Implementierung verwendet.

attribute sqlalchemy.engine.BindTyping.SETINPUTSIZES = 2¶

Verwendet die PEP-249-Methode `setinputsizes`.

Dies wird nur für DBAPIs implementiert, die diese Methode unterstützen und für die der SQLAlchemy-Dialekt die entsprechende Infrastruktur für diesen Dialekt eingerichtet hat. Aktuelle Dialekte umfassen python-oracledb, cx_Oracle sowie optionale Unterstützung für SQL Server mit pyodbc.

Bei Verwendung von `setinputsizes` haben Dialekte auch die Möglichkeit, die Methode nur für bestimmte Datentypen über Include-/Exclude-Listen zu verwenden.

Wenn SETINPUTSIZES verwendet wird, wird die Methode Dialect.do_set_input_sizes() für jede ausgeführte Anweisung mit gebundenen Parametern aufgerufen.

class sqlalchemy.engine.Compiled¶

Stellt einen kompilierten SQL- oder DDL-Ausdruck dar.

Mitglieder

__init__(), cache_key, compile_state, construct_params(), dml_compile_state, execution_options, params, sql_compiler, state, statement, string

Die Methode __str__ des Compiled-Objekts sollte den tatsächlichen Text der Anweisung erzeugen. Compiled-Objekte sind spezifisch für ihr zugrunde liegendes Datenbank-Dialekt und können auch spezifisch für die Spalten sein, die in einem bestimmten Satz von gebundenen Parametern referenziert werden. In keinem Fall sollte das Compiled-Objekt von den tatsächlichen Werten dieser gebundenen Parameter abhängen, auch wenn es diese Werte als Standardwerte referenziert.

method sqlalchemy.engine.Compiled.__init__(dialect: Dialect, statement: ClauseElement | None, schema_translate_map: SchemaTranslateMapType | None = None, render_schema_translate: bool = False, compile_kwargs: Mapping[str, Any] = {})¶

Erstellt ein neues Compiled-Objekt.

Parameter:

dialect¶ – Dialect, gegen den kompiliert werden soll.
statement¶ – ClauseElement, der kompiliert werden soll.
schema_translate_map¶ –
Wörterbuch der Schemanamen, die bei der Erstellung des resultierenden SQLs übersetzt werden sollen

Siehe auch

Übersetzung von Schemanamen
compile_kwargs¶ – zusätzliche Schlüsselwortargumente, die beim ersten Aufruf von Compiled.process() übergeben werden.

attribute sqlalchemy.engine.Compiled.cache_key: CacheKey | None = None¶

Der CacheKey, der vor der Erstellung dieses Compiled-Objekts generiert wurde.

Dies wird für Routinen verwendet, die Zugriff auf den ursprünglichen CacheKey-Instanz benötigen, die bei der ersten Cache-Speicherung der Compiled-Instanz generiert wurde, typischerweise um die ursprüngliche Liste der BindParameter-Objekte mit einer pro Anweisung generierten Liste abzugleichen, die bei jedem Aufruf generiert wird.

attribute sqlalchemy.engine.Compiled.compile_state: CompileState | None = None¶

Optional CompileState Objekt, das zusätzliche vom Compiler verwendete Zustandsinformationen verwaltet.

Wichtige ausführbare Objekte wie Insert, Update, Delete, Select generieren diesen Zustand beim Kompilieren, um zusätzliche Informationen über das Objekt zu berechnen. Für das Top-Level-Objekt, das ausgeführt werden soll, kann der Zustand hier gespeichert werden, wo er auch für die Verarbeitung von Ergebnismengen relevant sein kann.

Neu in Version 1.4.

methode sqlalchemy.engine.Compiled.construct_params(params: _CoreSingleExecuteParams | None = None, extracted_parameters: Sequence[BindParameter[Any]] | None = None, escape_names: bool = True) → _MutableCoreSingleExecuteParams | None¶

Gibt die Bindungsparameter für dieses kompilierte Objekt zurück.

Parameter:: params¶ – Ein Wörterbuch von Zeichenketten-/Objektpaaren, deren Werte die in der Anweisung kompilierten Bindungswerte überschreiben.

attribut sqlalchemy.engine.Compiled.dml_compile_state: CompileState | None = None¶

Optionales CompileState, das an derselben Stelle zugewiesen wird wie .isinsert, .isupdate oder .isdelete.

Dies ist normalerweise dasselbe Objekt wie .compile_state, mit der Ausnahme von Fällen wie dem ORMFromStatementCompileState Objekt.

Neu in Version 1.4.40.

attribut sqlalchemy.engine.Compiled.execution_options: _ExecuteOptions = {}¶: Ausführungsoptionen, die von der Anweisung weitergegeben werden. In einigen Fällen können Unterelemente der Anweisung diese modifizieren.

attribut sqlalchemy.engine.Compiled.params¶: Gibt die Bindungsparameter für dieses kompilierte Objekt zurück.

attribut sqlalchemy.engine.Compiled.sql_compiler¶

Gibt einen Compiled zurück, der SQL-Ausdrücke verarbeiten kann.

Wenn dieser Compiler einer ist, würde er wahrscheinlich einfach 'self' zurückgeben.

attribut sqlalchemy.engine.Compiled.state: CompilerState¶: Beschreibung des Zustands des Compilers.

attribut sqlalchemy.engine.Compiled.statement: ClauseElement | None = None¶: Die zu kompilierende Anweisung.

attribut sqlalchemy.engine.Compiled.string: str = ''¶: Die String-Darstellung der statement.

klasse sqlalchemy.engine.interfaces.DBAPIConnection¶

Protokoll, das eine PEP 249-Datenbankverbindung darstellt.

Neu in Version 2.0.

Siehe auch

Verbindungsobjekte - in PEP 249

Mitglieder

autocommit, close(), commit(), cursor(), rollback()

Klassensignatur

class sqlalchemy.engine.interfaces.DBAPIConnection (typing_extensions.Protocol)

attribut sqlalchemy.engine.interfaces.DBAPIConnection.autocommit: bool¶

methode sqlalchemy.engine.interfaces.DBAPIConnection.close() → None¶

methode sqlalchemy.engine.interfaces.DBAPIConnection.commit() → None¶

methode sqlalchemy.engine.interfaces.DBAPIConnection.cursor() → DBAPICursor¶

methode sqlalchemy.engine.interfaces.DBAPIConnection.rollback() → None¶

klasse sqlalchemy.engine.interfaces.DBAPICursor¶

Protokoll, das einen PEP 249-Datenbankcursor darstellt.

Neu in Version 2.0.

Siehe auch

Cursor-Objekte - in PEP 249

Mitglieder

arraysize, callproc(), close(), description, execute(), executemany(), fetchall(), fetchmany(), fetchone(), lastrowid, nextset(), rowcount, setinputsizes(), setoutputsize()

Klassensignatur

class sqlalchemy.engine.interfaces.DBAPICursor (typing_extensions.Protocol)

attribut sqlalchemy.engine.interfaces.DBAPICursor.arraysize: int¶

methode sqlalchemy.engine.interfaces.DBAPICursor.callproc(procname: str, parameters: Sequence[Any] = Ellipsis) → Any¶

methode sqlalchemy.engine.interfaces.DBAPICursor.close() → None¶

attribut sqlalchemy.engine.interfaces.DBAPICursor.description¶: Das Attribut Beschreibung des Cursors.

Siehe auch

cursor.description - in PEP 249

methode sqlalchemy.engine.interfaces.DBAPICursor.execute(operation: Any, parameters: Sequence[Any] | Mapping[str, Any] | None = None) → Any¶

methode sqlalchemy.engine.interfaces.DBAPICursor.executemany(operation: Any, parameters: Sequence[Sequence[Any]] | Sequence[Mapping[str, Any]]) → Any¶

methode sqlalchemy.engine.interfaces.DBAPICursor.fetchall() → Sequence[Any]¶

methode sqlalchemy.engine.interfaces.DBAPICursor.fetchmany(size: int = Ellipsis) → Sequence[Any]¶

methode sqlalchemy.engine.interfaces.DBAPICursor.fetchone() → Any | None¶

attribut sqlalchemy.engine.interfaces.DBAPICursor.lastrowid: int¶

methode sqlalchemy.engine.interfaces.DBAPICursor.nextset() → bool | None¶

attribut sqlalchemy.engine.interfaces.DBAPICursor.rowcount¶

methode sqlalchemy.engine.interfaces.DBAPICursor.setinputsizes(sizes: Sequence[Any]) → None¶

methode sqlalchemy.engine.interfaces.DBAPICursor.setoutputsize(size: Any, column: Any) → None¶

klasse sqlalchemy.engine.interfaces.DBAPIType¶: Protokoll, das einen PEP 249-Datenbanktyp darstellt.

Neu in Version 2.0.

Siehe auch

Typobjekte - in PEP 249

Klassensignatur

class sqlalchemy.engine.interfaces.DBAPIType (typing_extensions.Protocol)

klasse sqlalchemy.sql.compiler.DDLCompiler¶

Mitglieder

__init__(), cache_key, compile_state, construct_params(), define_constraint_remote_table(), dml_compile_state, execution_options, params, sql_compiler, state, statement, string

Klassensignatur

class sqlalchemy.sql.compiler.DDLCompiler (sqlalchemy.sql.compiler.Compiled)

methode sqlalchemy.sql.compiler.DDLCompiler.__init__(dialect: Dialect, statement: ClauseElement | None, schema_translate_map: SchemaTranslateMapType | None = None, render_schema_translate: bool = False, compile_kwargs: Mapping[str, Any] = {})¶

geerbt von der sqlalchemy.sql.compiler.Compiled.__init__ Methode von Compiled

Erstellt ein neues Compiled Objekt.

Parameter:

dialect¶ – Dialect, gegen den kompiliert werden soll.
statement¶ – Zu kompilierendes ClauseElement.
schema_translate_map¶ –
Wörterbuch der Schemanamen, die bei der Erstellung des resultierenden SQLs übersetzt werden sollen

Siehe auch

Übersetzung von Schemanamen
compile_kwargs¶ – Zusätzliche Schlüsselwortargumente, die an den ersten Aufruf von Compiled.process() übergeben werden.

attribut sqlalchemy.sql.compiler.DDLCompiler.cache_key: CacheKey | None = None¶

geerbt von dem Compiled.cache_key Attribut von Compiled

Der CacheKey, der vor der Erstellung dieses Compiled Objekts generiert wurde.

Dies wird für Routinen verwendet, die Zugriff auf die ursprüngliche CacheKey Instanz benötigen, die bei der ersten Caching der Compiled Instanz generiert wurde, typischerweise um die ursprüngliche Liste von BindParameter Objekten mit einer pro Anweisung generierten Liste abzugleichen, die bei jedem Aufruf generiert wird.

attribut sqlalchemy.sql.compiler.DDLCompiler.compile_state: CompileState | None = None¶

geerbt von dem Compiled.compile_state Attribut von Compiled

Optional CompileState Objekt, das zusätzliche vom Compiler verwendete Zustandsinformationen verwaltet.

Wichtige ausführbare Objekte wie Insert, Update, Delete, Select generieren diesen Zustand beim Kompilieren, um zusätzliche Informationen über das Objekt zu berechnen. Für das Top-Level-Objekt, das ausgeführt werden soll, kann der Zustand hier gespeichert werden, wo er auch für die Verarbeitung von Ergebnismengen relevant sein kann.

Neu in Version 1.4.

method sqlalchemy.sql.compiler.DDLCompiler.construct_params(params: _CoreSingleExecuteParams | None = None, extracted_parameters: Sequence[BindParameter[Any]] | None = None, escape_names: bool = True) → _MutableCoreSingleExecuteParams | None¶

Gibt die Bindungsparameter für dieses kompilierte Objekt zurück.

Parameter:: params¶ – ein Wörterbuch aus Zeichenketten-/Objektpaaren, deren Werte die in die Anweisung kompilierten Bindungswerte überschreiben.

method sqlalchemy.sql.compiler.DDLCompiler.define_constraint_remote_table(constraint, table, preparer)¶: Formatiert die Remote-Tabellenklausel einer CREATE CONSTRAINT-Klausel.

attribute sqlalchemy.sql.compiler.DDLCompiler.dml_compile_state: CompileState | None = None¶

geerbt vom Compiled.dml_compile_state Attribut von Compiled

Optionales CompileState, das an derselben Stelle zugewiesen wird wie .isinsert, .isupdate oder .isdelete.

Dies ist normalerweise dasselbe Objekt wie .compile_state, mit der Ausnahme von Fällen wie dem ORMFromStatementCompileState Objekt.

Neu in Version 1.4.40.

attribute sqlalchemy.sql.compiler.DDLCompiler.execution_options: _ExecuteOptions = {}¶: geerbt vom Compiled.execution_options Attribut von Compiled

Ausführungsoptionen, die von der Anweisung weitergegeben werden. In einigen Fällen können Unterelemente der Anweisung diese modifizieren.

attribute sqlalchemy.sql.compiler.DDLCompiler.params¶: geerbt vom Compiled.params Attribut von Compiled

Gibt die Bindungsparameter für dieses kompilierte Objekt zurück.

attribute sqlalchemy.sql.compiler.DDLCompiler.sql_compiler¶

attribute sqlalchemy.sql.compiler.DDLCompiler.state: CompilerState¶: Beschreibung des Zustands des Compilers.

attribute sqlalchemy.sql.compiler.DDLCompiler.statement: ClauseElement | None = None¶: geerbt vom Compiled.statement Attribut von Compiled

Die zu kompilierende Anweisung.

attribute sqlalchemy.sql.compiler.DDLCompiler.string: str = ''¶: geerbt vom Compiled.string Attribut von Compiled

Die String-Darstellung der statement.

class sqlalchemy.engine.default.DefaultDialect¶

Standardimplementierung von Dialect

Mitglieder

bind_typing, colspecs, connect(), construct_arguments, create_connect_args(), create_xid(), cte_follows_insert, dbapi, dbapi_exception_translation_map, ddl_compiler, default_isolation_level, default_metavalue_token, default_schema_name, default_sequence_base, delete_executemany_returning, delete_returning, delete_returning_multifrom, denormalize_name(), div_is_floordiv, do_begin(), do_begin_twophase(), do_close(), do_commit(), do_commit_twophase(), do_execute(), do_execute_no_params(), do_executemany(), do_ping(), do_prepare_twophase(), do_recover_twophase(), do_release_savepoint(), do_rollback(), do_rollback_to_savepoint(), do_rollback_twophase(), do_savepoint(), do_set_input_sizes(), do_terminate(), driver, engine_config_types, engine_created(), exclude_set_input_sizes, execute_sequence_format, execution_ctx_cls, favor_returning_over_lastrowid, full_returning, get_async_dialect_cls(), get_check_constraints(), get_columns(), get_default_isolation_level(), get_dialect_cls(), get_dialect_pool_class(), get_driver_connection(), get_foreign_keys(), get_indexes(), get_isolation_level(), get_isolation_level_values(), get_materialized_view_names(), get_multi_check_constraints(), get_multi_columns(), get_multi_foreign_keys(), get_multi_indexes(), get_multi_pk_constraint(), get_multi_table_comment(), get_multi_table_options(), get_multi_unique_constraints(), get_pk_constraint(), get_schema_names(), get_sequence_names(), get_table_comment(), get_table_names(), get_table_options(), get_temp_table_names(), get_temp_view_names(), get_unique_constraints(), get_view_definition(), get_view_names(), has_index(), has_schema(), has_sequence(), has_table(), has_terminate, identifier_preparer, import_dbapi(), include_set_input_sizes, initialize(), inline_comments, insert_executemany_returning, insert_executemany_returning_sort_by_parameter_order, insert_returning, insertmanyvalues_implicit_sentinel, insertmanyvalues_max_parameters, insertmanyvalues_page_size, is_async, is_disconnect(), label_length, load_provisioning(), loaded_dbapi, max_identifier_length, name, normalize_name(), on_connect(), on_connect_url(), paramstyle, positional, preexecute_autoincrement_sequences, preparer, reflection_options, reset_isolation_level(), returns_native_bytes, sequences_optional, server_side_cursors, server_version_info, set_connection_execution_options(), set_engine_execution_options(), set_isolation_level(), statement_compiler, supports_alter, supports_comments, supports_constraint_comments, supports_default_metavalue, supports_default_values, supports_empty_insert, supports_identity_columns, supports_multivalues_insert, supports_native_boolean, supports_native_decimal, supports_native_enum, supports_native_uuid, supports_sane_multi_rowcount, supports_sane_rowcount, supports_sane_rowcount_returning, supports_sequences, supports_server_side_cursors, supports_simple_order_by_label, supports_statement_cache, tuple_in_values, type_compiler, type_compiler_cls, type_compiler_instance, type_descriptor(), update_executemany_returning, update_returning, update_returning_multifrom, use_insertmanyvalues, use_insertmanyvalues_wo_returning

Klassensignatur

class sqlalchemy.engine.default.DefaultDialect (sqlalchemy.engine.interfaces.Dialect)

attribute sqlalchemy.engine.default.DefaultDialect.bind_typing = 1¶

Definiert ein Mittel zur Übergabe von Typisierungsinformationen an die Datenbank und/oder den Treiber für gebundene Parameter.

Siehe BindTyping für Werte.

Neu in Version 2.0.

attribute sqlalchemy.engine.default.DefaultDialect.colspecs: MutableMapping[Type[TypeEngine[Any]], Type[TypeEngine[Any]]] = {}¶: Ein Wörterbuch von TypeEngine-Klassen aus sqlalchemy.types, abgebildet auf Unterklassen, die spezifisch für die Dialektklasse sind. Dieses Wörterbuch ist nur auf Klassenebene vorhanden und wird nicht von der Dialektinstanz selbst abgerufen.

method sqlalchemy.engine.default.DefaultDialect.connect(*cargs, **cparams)¶

Stellt eine Verbindung mit der DBAPI dieses Dialekts her.

Die Standardimplementierung dieser Methode ist

def connect(self, *cargs, **cparams):
    return self.dbapi.connect(*cargs, **cparams)

Die Parameter *cargs, **cparams werden direkt aus der Methode Dialect.create_connect_args() dieses Dialekts generiert.

Diese Methode kann für Dialekte verwendet werden, die programmatische schrittweise Vorgänge pro Verbindung ausführen müssen, wenn eine neue Verbindung von der DBAPI bezogen wird.

Parameter:

*cargs¶ – positionelle Parameter, die von der Methode Dialect.create_connect_args() zurückgegeben werden
**cparams¶ – Schlüsselwortparameter, die von der Methode Dialect.create_connect_args() zurückgegeben werden.

Gibt zurück:

eine DBAPI-Verbindung, typischerweise aus der Funktion PEP 249 auf Modulebene .connect().

Siehe auch

Dialect.create_connect_args()

Dialect.on_connect()

attribute sqlalchemy.engine.default.DefaultDialect.construct_arguments: List[Tuple[Type[SchemaItem | ClauseElement], Mapping[str, Any]]] | None = None¶

geerbt vom Dialect.construct_arguments Attribut von Dialect

Optionale Argumentenspezifizierer für verschiedene SQLAlchemy-Konstrukte, typischerweise Schemaelemente.

Zur Implementierung als Reihe von Tupeln einrichten, wie in

construct_arguments = [
    (schema.Index, {"using": False, "where": None, "ops": None}),
]

Wenn das obige Konstrukt auf dem PostgreSQL-Dialekt eingerichtet ist, akzeptiert das Index-Konstrukt nun die Schlüsselwortargumente postgresql_using, postgresql_where und postgresql_ops. Jedes andere Argument, das dem Konstruktor von Index übergeben wird und mit postgresql_ beginnt, löst einen ArgumentError aus.

Ein Dialekt, der kein `construct_arguments`-Element enthält, nimmt nicht am Argumentvalidierungssystem teil. Für einen solchen Dialekt wird jeder Argumentname von allen teilnehmenden Konstrukten akzeptiert, innerhalb des Namespace von Argumenten, die mit diesem Dialektnamen präfixiert sind. Die Begründung hierfür ist, dass Drittanbieter-Dialekte, die diese Funktion noch nicht implementiert haben, weiterhin auf die alte Weise funktionieren.

Siehe auch

DialectKWArgs – implementierende Basisklasse, die DefaultDialect.construct_arguments konsumiert

methode sqlalchemy.engine.default.DefaultDialect.create_connect_args(url)¶

Erstellt DB-API-kompatible Verbindungsargumente.

Ausgehend von einem URL-Objekt wird ein Tupel zurückgegeben, das aus `(*args, **kwargs)` besteht, die direkt an die connect-Funktion des DBAPI gesendet werden können. Die Argumente werden an die Dialect.connect()-Methode gesendet, die dann die DBAPI-Ebene connect()-Funktion ausführt.

Die Methode nutzt typischerweise die URL.translate_connect_args()-Methode, um ein Wörterbuch mit Optionen zu generieren.

Die Standardimplementierung ist

def create_connect_args(self, url):
    opts = url.translate_connect_args()
    opts.update(url.query)
    return ([], opts)

Parameter:: url¶ – ein URL-Objekt
Gibt zurück:: ein Tupel aus `(*args, **kwargs)`, das an die Dialect.connect()-Methode übergeben wird.

Siehe auch

URL.translate_connect_args()

methode sqlalchemy.engine.default.DefaultDialect.create_xid()¶

Erstellt eine zufällige Zwei-Phasen-Transaktions-ID.

Diese ID wird an `do_begin_twophase()`, `do_rollback_twophase()`, `do_commit_twophase()` übergeben. Ihr Format ist nicht spezifiziert.

attribut sqlalchemy.engine.default.DefaultDialect.cte_follows_insert: bool = False¶: Ziel-Datenbank, die beim Vorhandensein einer CTE mit einer INSERT-Anweisung die CTE unterhalb des INSERT benötigt

attribut sqlalchemy.engine.default.DefaultDialect.dbapi: ModuleType | None¶

Eine Referenz auf das DBAPI-Modul selbst.

SQLAlchemy-Dialekte importieren DBAPI-Module über die Klassenmethode Dialect.import_dbapi(). Der Grund dafür ist, dass jedes Dialektmodul importiert und zur Generierung von SQL-Anweisungen verwendet werden kann, ohne dass der eigentliche DBAPI-Treiber installiert sein muss. Erst wenn eine Engine mit create_engine() erstellt wird, wird der DBAPI importiert; zu diesem Zeitpunkt weist der Erstellungsprozess das DBAPI-Modul diesem Attribut zu.

Dialekte sollten daher Dialect.import_dbapi() implementieren, die das notwendige Modul importiert und zurückgibt, und dann im Dialektcode auf `self.dbapi` verweisen, um auf die Inhalte des DBAPI-Moduls zuzugreifen.

Geändert in Version The: Das Attribut Dialect.dbapi wird ausschließlich als pro Dialekt-Instanz-Referenz auf das DBAPI-Modul verwendet. Die frühere, nicht vollständig dokumentierte Klassenmethode .Dialect.dbapi() ist veraltet und wurde durch Dialect.import_dbapi() ersetzt.

attribut sqlalchemy.engine.default.DefaultDialect.dbapi_exception_translation_map: Mapping[str, str] = {}¶: geerbt vom Attribut Dialect.dbapi_exception_translation_map der Klasse Dialect

Ein Wörterbuch von Namen, dessen Werte die Namen von PEP-249-Ausnahmen sind ("IntegrityError", "OperationalError" usw.), die alternativen Klassennamen zugeordnet sind, um den Fall zu unterstützen, dass ein DBAPI Ausnahmeklassen hat, die nicht so benannt sind, wie sie referenziert werden (z. B. IntegrityError = MyException). In den allermeisten Fällen ist dieses Wörterbuch leer.

attribut sqlalchemy.engine.default.DefaultDialect.ddl_compiler¶: Alias von DDLCompiler

attribut sqlalchemy.engine.default.DefaultDialect.default_isolation_level: IsolationLevel | None¶: die Isolation, die implizit bei neuen Verbindungen vorhanden ist

attribut sqlalchemy.engine.default.DefaultDialect.default_metavalue_token: str = 'DEFAULT'¶: für die Syntax INSERT… VALUES (DEFAULT) das Token, das in die Klammern gesetzt werden soll.

attribut sqlalchemy.engine.default.DefaultDialect.default_schema_name: str | None = None¶: der Name des Standard-Schemas. Dieser Wert ist nur für unterstützte Dialekte verfügbar und wird typischerweise während der initialen Verbindung zur Datenbank gefüllt.

attribut sqlalchemy.engine.default.DefaultDialect.default_sequence_base: int = 1¶: der Standardwert, der als "START WITH"-Teil einer CREATE SEQUENCE DDL-Anweisung gerendert wird.

attribut sqlalchemy.engine.default.DefaultDialect.delete_executemany_returning: bool = False¶: Dialekt unterstützt DELETE..RETURNING mit executemany.

attribut sqlalchemy.engine.default.DefaultDialect.delete_returning: bool = False¶: ob der Dialekt RETURNING mit DELETE unterstützt

Neu in Version 2.0.

attribut sqlalchemy.engine.default.DefaultDialect.delete_returning_multifrom: bool = False¶: ob der Dialekt RETURNING mit DELETE..FROM unterstützt

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.denormalize_name(name)¶

konvertiert den gegebenen Namen in eine fall-unempfindliche Kennung für das Backend, wenn es sich um einen vollständig kleingeschriebenen Namen handelt.

Diese Methode wird nur verwendet, wenn der Dialekt `requires_name_normalize=True` definiert.

attribut sqlalchemy.engine.default.DefaultDialect.div_is_floordiv: bool = True¶: Die Ziel-Datenbank behandelt den / Divisionsoperator als "Ganzzahldivision"

methode sqlalchemy.engine.default.DefaultDialect.do_begin(dbapi_connection)¶

Stellt eine Implementierung von `connection.begin()` bereit, gegeben eine DB-API-Verbindung.

Die DBAPI hat keine dedizierte "begin"-Methode und Transaktionen sind implizit zu erwarten. Dieser Hook wird für jene DBAPIs bereitgestellt, die zusätzliche Unterstützung in diesem Bereich benötigen könnten.

Parameter:: dbapi_connection¶ – eine DBAPI-Verbindung, typischerweise proxied in einer ConnectionFairy.

methode sqlalchemy.engine.default.DefaultDialect.do_begin_twophase(connection: Connection, xid: Any) → None¶

geerbt von der Methode Dialect.do_begin_twophase() der Klasse Dialect

Beginnt eine Zwei-Phasen-Transaktion auf der gegebenen Verbindung.

Parameter:

connection¶ – eine Connection.
xid¶ – xid

methode sqlalchemy.engine.default.DefaultDialect.do_close(dbapi_connection)¶

Stellt eine Implementierung von `connection.close()` bereit, gegeben eine DBAPI-Verbindung.

Dieser Hook wird vom Pool aufgerufen, wenn eine Verbindung vom Pool getrennt wurde oder über die normale Kapazität des Pools hinaus zurückgegeben wird.

methode sqlalchemy.engine.default.DefaultDialect.do_commit(dbapi_connection)¶

Stellt eine Implementierung von `connection.commit()` bereit, gegeben eine DB-API-Verbindung.

Parameter:: dbapi_connection¶ – eine DBAPI-Verbindung, typischerweise proxied in einer ConnectionFairy.

methode sqlalchemy.engine.default.DefaultDialect.do_commit_twophase(connection: Connection, xid: Any, is_prepared: bool = True, recover: bool = False) → None¶

geerbt von der Methode Dialect.do_commit_twophase() der Klasse Dialect

Commit einer Zwei-Phasen-Transaktion auf der gegebenen Verbindung.

Parameter:

connection¶ – eine Connection.
xid¶ – xid
is_prepared¶ – ob TwoPhaseTransaction.prepare() aufgerufen wurde.
recover¶ – ob das recover-Flag übergeben wurde.

methode sqlalchemy.engine.default.DefaultDialect.do_execute(cursor, statement, parameters, context=None)¶: Stellt eine Implementierung von `cursor.execute(statement, parameters)` bereit.

methode sqlalchemy.engine.default.DefaultDialect.do_execute_no_params(cursor, statement, context=None)¶

Stellt eine Implementierung von `cursor.execute(statement)` bereit.

Die Parametersammlung sollte nicht gesendet werden.

methode sqlalchemy.engine.default.DefaultDialect.do_executemany(cursor, statement, parameters, context=None)¶: Stellt eine Implementierung von `cursor.executemany(statement, parameters)` bereit.

methode sqlalchemy.engine.default.DefaultDialect.do_ping(dbapi_connection: DBAPIConnection) → bool¶: Pingt die DBAPI-Verbindung und gibt `True` zurück, wenn die Verbindung nutzbar ist.

methode sqlalchemy.engine.default.DefaultDialect.do_prepare_twophase(connection: Connection, xid: Any) → None¶

geerbt von der Methode Dialect.do_prepare_twophase() der Klasse Dialect

Bereitet eine Zwei-Phasen-Transaktion auf der gegebenen Verbindung vor.

Parameter:

connection¶ – eine Connection.
xid¶ – xid

methode sqlalchemy.engine.default.DefaultDialect.do_recover_twophase(connection: Connection) → List[Any]¶

geerbt von der Methode Dialect.do_recover_twophase() der Klasse Dialect

Stellt eine Liste von unbestätigten vorbereiteten Zwei-Phasen-Transaktionsidentifikatoren auf der gegebenen Verbindung wieder her.

Parameter:: connection¶ – eine Connection.

methode sqlalchemy.engine.default.DefaultDialect.do_release_savepoint(connection, name)¶

Gibt den benannten Savepoint auf einer Verbindung frei.

Parameter:

connection¶ – eine Connection.
name¶ – Name des Savepoints.

methode sqlalchemy.engine.default.DefaultDialect.do_rollback(dbapi_connection)¶

Stellt eine Implementierung von `connection.rollback()` bereit, gegeben eine DB-API-Verbindung.

Parameter:: dbapi_connection¶ – eine DBAPI-Verbindung, typischerweise proxied in einer ConnectionFairy.

methode sqlalchemy.engine.default.DefaultDialect.do_rollback_to_savepoint(connection, name)¶

Rollback einer Verbindung zu dem benannten Savepoint.

Parameter:

connection¶ – eine Connection.
name¶ – Name des Savepoints.

Methode sqlalchemy.engine.default.DefaultDialect.do_rollback_twophase(connection: Connection, xid: Any, is_prepared: bool = True, recover: bool = False) → None¶

geerbt von der Dialect.do_rollback_twophase() Methode von Dialect

Macht eine Zwei-Phasen-Transaktion auf der gegebenen Verbindung rückgängig.

Parameter:

connection¶ – eine Connection.
xid¶ – xid
is_prepared¶ – ob TwoPhaseTransaction.prepare() aufgerufen wurde oder nicht.
recover¶ – ob das Flag `recover` übergeben wurde.

Methode sqlalchemy.engine.default.DefaultDialect.do_savepoint(connection, name)¶

Erstellt einen Savepoint mit dem gegebenen Namen.

Parameter:

connection¶ – eine Connection.
name¶ – Name des Savepoints.

Methode sqlalchemy.engine.default.DefaultDialect.do_set_input_sizes(cursor: DBAPICursor, list_of_tuples: _GenericSetInputSizesType, context: ExecutionContext) → Any¶

geerbt von der Dialect.do_set_input_sizes() Methode von Dialect

ruft die Methode cursor.setinputsizes() mit den entsprechenden Argumenten auf

Dieser Hook wird aufgerufen, wenn das Attribut Dialect.bind_typing auf den Wert BindTyping.SETINPUTSIZES gesetzt ist. Parameterdaten werden in einer Liste von Tupeln (paramname, dbtype, sqltype) übergeben, wobei paramname der Schlüssel des Parameters in der Anweisung ist, dbtype der DBAPI-Datentyp und sqltype der SQLAlchemy-Typ ist. Die Reihenfolge der Tupel entspricht der korrekten Parameterreihenfolge.

Neu in Version 1.4.

Geändert in Version 2.0: - Der Modus `setinputsizes` wird jetzt aktiviert, indem Dialect.bind_typing auf BindTyping.SETINPUTSIZES gesetzt wird. Dialekte, die einen Parameter use_setinputsizes akzeptieren, sollten diesen Wert entsprechend setzen.

Methode sqlalchemy.engine.default.DefaultDialect.do_terminate(dbapi_connection)¶

Bietet eine Implementierung von connection.close(), die versucht, so wenig wie möglich zu blockieren, unter Angabe einer DBAPI-Verbindung.

In den allermeisten Fällen ruft dies nur `.close()` auf. Für einige asyncio-Dialekte können jedoch andere API-Funktionen verwendet werden.

Dieser Hook wird vom Pool aufgerufen, wenn eine Verbindung wiederverwendet oder ungültig gemacht wird.

Neu in Version 1.4.41.

Attribut sqlalchemy.engine.default.DefaultDialect.driver: str¶: identifizierender Name für das DBAPI des Dialekts

Attribut sqlalchemy.engine.default.DefaultDialect.engine_config_types: Mapping[str, Any] = {'echo': <function bool_or_str.<locals>.bool_or_value>, 'echo_pool': <function bool_or_str.<locals>.bool_or_value>, 'future': <function asbool>, 'max_overflow': <function asint>, 'pool_recycle': <function asint>, 'pool_size': <function asint>, 'pool_timeout': <function asint>}¶: eine Zuordnung von String-Schlüsseln, die in einer Engine-Konfiguration vorhanden sein können, verknüpft mit Typumwandlungsfunktionen.

Klassenmethode sqlalchemy.engine.default.DefaultDialect.engine_created(engine: Engine) → None¶

geerbt von der Dialect.engine_created() Methode von Dialect

Ein Hilfs-Hook, der aufgerufen wird, bevor die endgültige Engine zurückgegeben wird.

Wenn der Dialekt eine andere Klasse von der get_dialect_cls() Methode zurückgegeben hat, wird der Hook auf beide Klassen aufgerufen, zuerst auf die von der get_dialect_cls() Methode zurückgegebene Dialektklasse und dann auf die Klasse, auf der die Methode aufgerufen wurde.

Der Hook sollte von Dialekten und/oder Wrappern verwendet werden, um spezielle Ereignisse auf die Engine oder ihre Komponenten anzuwenden. Insbesondere ermöglicht er einer Dialekt-Wrapper-Klasse, Dialekt-bezogene Ereignisse anzuwenden.

Attribut sqlalchemy.engine.default.DefaultDialect.exclude_set_input_sizes: Set[Any] | None = None¶

Set von DBAPI-Typ-Objekten, die bei automatischen cursor.setinputsizes()-Aufrufen ausgeschlossen werden sollen.

Dies wird nur verwendet, wenn bind_typing auf BindTyping.SET_INPUT_SIZES gesetzt ist.

Attribut sqlalchemy.engine.default.DefaultDialect.execute_sequence_format¶: Alias von tuple

Attribut sqlalchemy.engine.default.DefaultDialect.execution_ctx_cls¶: Alias von DefaultExecutionContext

Attribut sqlalchemy.engine.default.DefaultDialect.favor_returning_over_lastrowid: bool = False¶

für Backends, die sowohl eine `lastrowid` als auch eine `RETURNING`-Einfügestrategie unterstützen, wird `RETURNING` für einfache Einfügungen mit einzelnen Ganzzahl-Primärschlüsseln bevorzugt.

cursor.lastrowid ist bei den meisten Backends tendenziell performanter.

Attribut sqlalchemy.engine.default.DefaultDialect.full_returning¶: Veraltet seit Version 2.0: `full_returning` ist veraltet, bitte verwenden Sie `insert_returning`, `update_returning`, `delete_returning`

Klassenmethode sqlalchemy.engine.default.DefaultDialect.get_async_dialect_cls(url: URL) → Type[Dialect]¶

geerbt von der Dialect.get_async_dialect_cls() Methode von Dialect

Gibt anhand einer URL den Dialect zurück, der von einer asynchronen Engine verwendet wird.

Standardmäßig ist dies ein Alias für Dialect.get_dialect_cls() und gibt einfach die Klasse zurück. Sie kann verwendet werden, wenn ein Dialekt sowohl eine synchrone als auch eine asynchrone Version unter demselben Namen bereitstellt, wie z. B. der psycopg-Treiber.

Neu in Version 2.

Siehe auch

Dialect.get_dialect_cls()

Methode sqlalchemy.engine.default.DefaultDialect.get_check_constraints(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedCheckConstraint]¶

geerbt von der Dialect.get_check_constraints() Methode von Dialect

Gibt Informationen über Check-Constraints in table_name zurück.

Gibt anhand eines Strings table_name und eines optionalen Strings schema Informationen zu Check-Constraints als Liste von Dictionaries zurück, die dem ReflectedCheckConstraint Dictionary entsprechen.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_check_constraints() verwenden.

Methode sqlalchemy.engine.default.DefaultDialect.get_columns(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedColumn]¶

geerbt von der Dialect.get_columns() Methode von Dialect

Gibt Informationen über Spalten in table_name zurück.

Gibt anhand einer Connection, eines Strings table_name und eines optionalen Strings schema Spalteninformationen als Liste von Dictionaries zurück, die dem ReflectedColumn Dictionary entsprechen.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_columns() verwenden.

Methode sqlalchemy.engine.default.DefaultDialect.get_default_isolation_level(dbapi_conn)¶

Gibt anhand einer DBAPI-Verbindung deren Isolationslevel zurück, oder einen Standard-Isolationslevel, wenn keiner abgerufen werden kann.

Kann von Unterklassen überschrieben werden, um einen "Fallback"-Isolationslevel für Datenbanken bereitzustellen, die den tatsächlichen Isolationslevel nicht zuverlässig abrufen können.

Ruft standardmäßig die Methode Interfaces.get_isolation_level() auf und leitet alle ausgelösten Ausnahmen weiter.

Neu in Version 1.3.22.

Klassenmethode sqlalchemy.engine.default.DefaultDialect.get_dialect_cls(url: URL) → Type[Dialect]¶

geerbt von der Dialect.get_dialect_cls() Methode von Dialect

Gibt anhand einer URL den zu verwendenden Dialect zurück.

Dies ist ein Hook, der es einem externen Plugin ermöglicht, Funktionalität um einen vorhandenen Dialekt herum bereitzustellen, indem das Plugin von der URL basierend auf einem Entrypoint geladen wird und das Plugin dann den tatsächlich zu verwendenden Dialekt zurückgibt.

Standardmäßig wird einfach die Klasse zurückgegeben.

Methode sqlalchemy.engine.default.DefaultDialect.get_dialect_pool_class(url: URL) → Type[Pool]¶: gibt eine Pool-Klasse zurück, die für eine gegebene URL verwendet werden soll

Methode sqlalchemy.engine.default.DefaultDialect.get_driver_connection(connection)¶

Gibt das vom externen Treiberpaket zurückgegebene Verbindungsobjekt zurück.

Für normale Dialekte, die einen DBAPI-konformen Treiber verwenden, gibt dieser Aufruf einfach die als Argument übergebene connection zurück. Für Dialekte, die stattdessen einen nicht-DBAPI-konformen Treiber anpassen, wie z. B. bei der Anpassung eines Asyncio-Treibers, gibt dieser Aufruf das verbindungähnliche Objekt zurück, das vom Treiber zurückgegeben wird.

Neu in Version 1.4.24.

Methode sqlalchemy.engine.default.DefaultDialect.get_foreign_keys(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedForeignKeyConstraint]¶

geerbt von der Dialect.get_foreign_keys() Methode von Dialect

Gibt Informationen über Fremdschlüssel in table_name zurück.

Gibt anhand einer Connection, eines Strings table_name und eines optionalen Strings schema Informationen zu Fremdschlüsseln als Liste von Dictionaries zurück, die dem ReflectedForeignKeyConstraint Dictionary entsprechen.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_foreign_keys() verwenden.

Methode sqlalchemy.engine.default.DefaultDialect.get_indexes(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedIndex]¶

geerbt von der Dialect.get_indexes() Methode von Dialect

Gibt Informationen über Indizes in table_name zurück.

Gibt anhand einer Connection, eines Strings table_name und eines optionalen Strings schema Indexinformationen als Liste von Dictionaries zurück, die dem ReflectedIndex Dictionary entsprechen.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_indexes() verwenden.

methode sqlalchemy.engine.default.DefaultDialect.get_isolation_level(dbapi_connection: DBAPIConnection) → Literal['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED', 'READ UNCOMMITTED', 'AUTOCOMMIT']¶

geerbt von der Dialect.get_isolation_level() Methode von Dialect

Gibt den Isolationsgrad einer DBAPI-Verbindung zurück.

Bei der Arbeit mit einem Connection-Objekt kann die entsprechende DBAPI-Verbindung über den Connection.connection-Accessor abgerufen werden.

Beachten Sie, dass dies eine Dialekt-Methode ist, die als Teil der Implementierung der Isolationsgradfunktionen von Connection und Engine verwendet wird; diese APIs sollten für die meisten typischen Anwendungsfälle bevorzugt werden.

Siehe auch

Connection.get_isolation_level() - aktuellen Level anzeigen

Connection.default_isolation_level - Standardlevel anzeigen

Connection.execution_options.isolation_level - Isolationsgrad pro Connection festlegen

create_engine.isolation_level - Isolationsgrad pro Engine festlegen

methode sqlalchemy.engine.default.DefaultDialect.get_isolation_level_values(dbapi_conn: DBAPIConnection) → List[Literal['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED', 'READ UNCOMMITTED', 'AUTOCOMMIT']]¶

geerbt von der Dialect.get_isolation_level_values() Methode von Dialect

Gibt eine Sequenz von Zeichenketten-Isolationsgradnamen zurück, die von dieser Dialekt unterstützt werden.

Die verfügbaren Namen sollten die folgenden Konventionen verwenden:

verwende GROSSBUCHSTABEN. Isolationsgradmethoden akzeptieren Kleinbuchstaben, aber diese werden in GROSSBUCHSTABEN normalisiert, bevor sie an die Dialekt weitergegeben werden.
Wörter werden durch Leerzeichen, nicht durch Unterstriche, getrennt, z. B. REPEATABLE READ. Isolationsgradnamen werden vor der Weitergabe an die Dialekt in Unterstriche in Leerzeichen umgewandelt.
Die Namen für die vier Standard-Isolationsnamen sollten, soweit sie vom Backend unterstützt werden, READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE lauten.
Wenn die Dialekt eine AUTOCOMMIT-Option unterstützt, sollte diese mit dem Isolationsgradnamen AUTOCOMMIT angegeben werden.
Andere Isolationsmodi können ebenfalls vorhanden sein, sofern sie in GROSSBUCHSTABEN benannt sind und Leerzeichen anstelle von Unterstrichen verwenden.

Diese Funktion wird verwendet, damit die Standarddialekt prüfen kann, ob ein gegebener Isolationsgradparameter gültig ist, andernfalls wird ein ArgumentError ausgelöst.

Eine DBAPI-Verbindung wird an die Methode übergeben, falls die Dialekt die Verbindung selbst abfragen muss, um diese Liste zu ermitteln. Es wird jedoch erwartet, dass die meisten Backends eine fest kodierte Liste von Werten zurückgeben. Wenn die Dialekt "AUTOCOMMIT" unterstützt, sollte dieser Wert ebenfalls in der zurückgegebenen Sequenz enthalten sein.

Die Methode löst standardmäßig NotImplementedError aus. Wenn eine Dialekt diese Methode nicht implementiert, führt die Standarddialekt keine Überprüfung eines gegebenen Isolationsgradwerts durch, bevor er an die Methode Dialect.set_isolation_level() weitergegeben wird. Dies dient der Abwärtskompatibilität mit Drittanbieter-Dialekten, die diese Methode möglicherweise noch nicht implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.get_materialized_view_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

geerbt von der Dialect.get_materialized_view_names() Methode von Dialect

Gibt eine Liste aller Materialized View-Namen zurück, die in der Datenbank verfügbar sind.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_materialized_view_names() verwenden.

Parameter:

schema¶ –

Schema-Name, der abgefragt werden soll, falls nicht das Standardschema.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.get_multi_check_constraints(connection, **kw)¶

Gibt Informationen über CHECK-Constraints in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_check_constraints() verwenden.

Hinweis

Die DefaultDialect stellt eine Standardimplementierung bereit, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() zurückgegeben wird, abhängig von der angegebenen kind. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.get_multi_columns(connection, **kw)¶

Gibt Informationen über Spalten in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_columns() verwenden.

Hinweis

Die DefaultDialect stellt eine Standardimplementierung bereit, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() zurückgegeben wird, abhängig von der angegebenen kind. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.get_multi_foreign_keys(connection, **kw)¶

Gibt Informationen über Fremdschlüssel in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_foreign_keys() verwenden.

Hinweis

Die DefaultDialect stellt eine Standardimplementierung bereit, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() zurückgegeben wird, abhängig von der angegebenen kind. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.get_multi_indexes(connection, **kw)¶

Gibt Informationen über Indizes in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_indexes() verwenden.

Hinweis

Die DefaultDialect stellt eine Standardimplementierung bereit, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() zurückgegeben wird, abhängig von der angegebenen kind. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.get_multi_pk_constraint(connection, **kw)¶

Gibt Informationen über Primärschlüssel-Constraints in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_pk_constraint() verwenden.

Hinweis

Die DefaultDialect stellt eine Standardimplementierung bereit, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() zurückgegeben wird, abhängig von der angegebenen kind. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.get_multi_table_comment(connection, **kw)¶

Gibt Informationen über den Tabellenkommentar in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_table_comment() verwenden.

Hinweis

Die DefaultDialect stellt eine Standardimplementierung bereit, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() zurückgegeben wird, abhängig von der angegebenen kind. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.get_multi_table_options(connection, **kw)¶

Gibt ein Wörterbuch mit Optionen zurück, die bei der Erstellung der Tabellen im angegebenen Schema festgelegt wurden.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_table_options() verwenden.

Hinweis

Die DefaultDialect stellt eine Standardimplementierung bereit, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() zurückgegeben wird, abhängig von der angegebenen kind. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.get_multi_unique_constraints(connection, **kw)¶

Gibt Informationen über UNIQUE-Constraints in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_unique_constraints() verwenden.

Hinweis

Die DefaultDialect stellt eine Standardimplementierung bereit, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() zurückgegeben wird, abhängig von der angegebenen kind. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.get_pk_constraint(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → ReflectedPrimaryKeyConstraint¶

geerbt von der Dialect.get_pk_constraint() Methode von Dialect

Gibt Informationen über den Primärschlüssel-Constraint für table_name zurück.

Gibt anhand einer Connection, einem Zeichenketten-table_name und einem optionalen Zeichenketten-schema Informationen über den Primärschlüssel als Wörterbuch zurück, das dem ReflectedPrimaryKeyConstraint-Wörterbuch entspricht.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_pk_constraint() verwenden.

methode sqlalchemy.engine.default.DefaultDialect.get_schema_names(connection: Connection, **kw: Any) → List[str]¶

geerbt von der Dialect.get_schema_names() Methode von Dialect

Gibt eine Liste aller Schema-Namen zurück, die in der Datenbank verfügbar sind.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_schema_names() verwenden.

methode sqlalchemy.engine.default.DefaultDialect.get_sequence_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

geerbt von der Dialect.get_sequence_names() Methode von Dialect

Gibt eine Liste aller Sequenz-Namen zurück, die in der Datenbank verfügbar sind.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_sequence_names() verwenden.

Parameter:: schema¶ – Schema-Name, der abgefragt werden soll, falls nicht das Standardschema.

Neu in Version 1.4.

methode sqlalchemy.engine.default.DefaultDialect.get_table_comment(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → ReflectedTableComment¶

geerbt von der Dialect.get_table_comment() Methode von Dialect

Gibt den „Kommentar“ für die durch table_name identifizierte Tabelle zurück.

Gibt anhand eines Zeichenketten-table_name und eines optionalen Zeichenketten-schema Informationen über den Tabellenkommentar als Wörterbuch zurück, das dem ReflectedTableComment-Wörterbuch entspricht.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_table_comment() verwenden.

Auslösen:: NotImplementedError für Dialekte, die Kommentare nicht unterstützen.

Neu seit Version 1.2.

methode sqlalchemy.engine.default.DefaultDialect.get_table_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

geerbt von der Dialect.get_table_names() Methode von Dialect

Gibt eine Liste von Tabellennamen für schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_table_names() verwenden.

methode sqlalchemy.engine.default.DefaultDialect.get_table_options(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → Dict[str, Any]¶

geerbt von der Dialect.get_table_options() Methode von Dialect

Gibt ein Wörterbuch mit Optionen zurück, die bei der Erstellung von table_name festgelegt wurden.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_table_options() verwenden.

methode sqlalchemy.engine.default.DefaultDialect.get_temp_table_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

geerbt von der Dialect.get_temp_table_names() Methode von Dialect

Gibt eine Liste von temporären Tabellennamen in der angegebenen Verbindung zurück, falls vom zugrunde liegenden Backend unterstützt.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_temp_table_names() verwenden.

methode sqlalchemy.engine.default.DefaultDialect.get_temp_view_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

geerbt von der Dialect.get_temp_view_names() Methode von Dialect

Gibt eine Liste von temporären View-Namen in der angegebenen Verbindung zurück, falls vom zugrunde liegenden Backend unterstützt.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_temp_view_names() verwenden.

method sqlalchemy.engine.default.DefaultDialect.get_unique_constraints(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedUniqueConstraint]¶

vererbt von der Dialect.get_unique_constraints() Methode von Dialect

Gibt Informationen über eindeutige Einschränkungen in table_name zurück.

Gibt, gegeben einen String table_name und einen optionalen String schema, Informationen über eindeutige Einschränkungen als eine Liste von Dictionaries zurück, die dem ReflectedUniqueConstraint Dictionary entsprechen.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_unique_constraints() verwenden.

method sqlalchemy.engine.default.DefaultDialect.get_view_definition(connection: Connection, view_name: str, schema: str | None = None, **kw: Any) → str¶

vererbt von der Dialect.get_view_definition() Methode von Dialect

Gibt die Definition einer normalen oder materialisierten Ansicht zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_view_definition() verwenden.

Gibt, gegeben ein Connection, einen String view_name und einen optionalen String schema, die Ansichtsdefinition zurück.

method sqlalchemy.engine.default.DefaultDialect.get_view_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

vererbt von der Dialect.get_view_names() Methode von Dialect

Gibt eine Liste aller nicht-materialisierten Ansichtsnamen zurück, die in der Datenbank verfügbar sind.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_view_names() verwenden.

Parameter:: schema¶ – Schema-Name, der abgefragt werden soll, falls nicht das Standardschema.

method sqlalchemy.engine.default.DefaultDialect.has_index(connection, table_name, index_name, schema=None, **kw)¶

Überprüft die Existenz eines bestimmten Indexnamens in der Datenbank.

Gibt, gegeben ein Connection-Objekt, einen String table_name und einen String Indexnamen, True zurück, wenn ein Index des gegebenen Namens für die gegebene Tabelle existiert, andernfalls False.

Der DefaultDialect implementiert dies auf Basis der Methoden Dialect.has_table() und Dialect.get_indexes(), jedoch können Dialekte eine performantere Version implementieren.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.has_index() verwenden.

Neu in Version 1.4.

method sqlalchemy.engine.default.DefaultDialect.has_schema(connection: Connection, schema_name: str, **kw: Any) → bool¶

Überprüft die Existenz eines bestimmten Schemanamens in der Datenbank.

Gibt, gegeben ein Connection-Objekt, einen String schema_name, True zurück, wenn ein Schema des gegebenen Namens existiert, andernfalls False.

Der DefaultDialect implementiert dies, indem er die Anwesenheit von schema_name unter den Schemata prüft, die von Dialect.get_schema_names() zurückgegeben werden, jedoch können Dialekte eine performantere Version implementieren.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.has_schema() verwenden.

Neu in Version 2.0.

method sqlalchemy.engine.default.DefaultDialect.has_sequence(connection: Connection, sequence_name: str, schema: str | None = None, **kw: Any) → bool¶

vererbt von der Dialect.has_sequence() Methode von Dialect

Überprüft die Existenz einer bestimmten Sequenz in der Datenbank.

Gibt, gegeben ein Connection-Objekt und einen String sequence_name, True zurück, wenn die gegebene Sequenz in der Datenbank existiert, andernfalls False.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.has_sequence() verwenden.

method sqlalchemy.engine.default.DefaultDialect.has_table(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → bool¶

vererbt von der Dialect.has_table() Methode von Dialect

Für interne Dialektverwendung, überprüft die Existenz einer bestimmten Tabelle oder Ansicht in der Datenbank.

Gibt, gegeben ein Connection-Objekt, einen String table_name und einen optionalen Schemanamen, True zurück, wenn die gegebene Tabelle in der Datenbank existiert, andernfalls False.

Diese Methode dient als zugrunde liegende Implementierung der öffentlichen Methode Inspector.has_table() und wird auch intern verwendet, um das Verhalten "checkfirst" für Methoden wie Table.create() und MetaData.create_all() zu implementieren.

Hinweis

Diese Methode wird intern von SQLAlchemy verwendet und wird veröffentlicht, damit Drittanbieter-Dialekte eine Implementierung bereitstellen können. Sie ist **nicht** die öffentliche API zum Überprüfen der Tabellenpräsenz. Bitte verwenden Sie die Methode Inspector.has_table().

Geändert in Version 2.0::: Dialect.has_table() unterstützt jetzt formell die Überprüfung auf zusätzliche tabellenähnliche Objekte

alle Arten von Ansichten (normal oder materialisiert)
temporäre Tabellen jeglicher Art

Zuvor waren diese beiden Prüfungen nicht formell spezifiziert und verschiedene Dialekte verhielten sich unterschiedlich. Die Dialekt-Testsuite enthält jetzt Tests für all diese Objekttypen, und Dialekte, in dem Maße, wie die zugrunde liegende Datenbank Ansichten oder temporäre Tabellen unterstützt, sollten versuchen, diese Objekte zu lokalisieren, um die volle Konformität zu gewährleisten.

attribute sqlalchemy.engine.default.DefaultDialect.has_terminate: bool = False¶: Ob dieser Dialekt eine separate "terminate"-Implementierung hat, die nicht blockiert oder auf ein Awaiten wartet.

attribute sqlalchemy.engine.default.DefaultDialect.identifier_preparer: IdentifierPreparer¶: Dieses Element verweist auf eine Instanz von IdentifierPreparer, sobald ein DefaultDialect konstruiert wurde.

classmethod sqlalchemy.engine.default.DefaultDialect.import_dbapi() → module¶

vererbt von der Dialect.import_dbapi() Methode von Dialect

Importiert das DBAPI-Modul, das von diesem Dialekt verwendet wird.

Das hier zurückgegebene Python-Modulobjekt wird als Instanzvariable einem konstruierten Dialekt unter dem Namen .dbapi zugewiesen.

Geändert in Version 2.0: Die Klassenmethode Dialect.import_dbapi() wurde von der vorherigen Methode .Dialect.dbapi() umbenannt, die zur Instanziierungszeit des Dialekts durch das DBAPI-Modul selbst ersetzt wurde, wodurch derselbe Name auf zwei verschiedene Arten verwendet wurde. Wenn eine .Dialect.dbapi()-Klassenmethode auf einem Drittanbieter-Dialekt vorhanden ist, wird diese verwendet und eine Deprecation-Warnung ausgegeben.

attribute sqlalchemy.engine.default.DefaultDialect.include_set_input_sizes: Set[Any] | None = None¶

Set von DBAPI-Typobjekten, die in automatische cursor.setinputsizes()-Aufrufe einbezogen werden sollen.

Dies wird nur verwendet, wenn bind_typing auf BindTyping.SET_INPUT_SIZES gesetzt ist.

method sqlalchemy.engine.default.DefaultDialect.initialize(connection)¶

Wird während der strategisierten Erstellung des Dialekts mit einer Verbindung aufgerufen.

Ermöglicht es Dialekten, Optionen basierend auf Serverversionsinformationen oder anderen Eigenschaften zu konfigurieren.

Die hier übergebene Verbindung ist ein SQLAlchemy Connection-Objekt mit vollen Fähigkeiten.

Die initialize()-Methode des Basisdialekts sollte über super() aufgerufen werden.

Hinweis

Ab SQLAlchemy 1.4 wird diese Methode **vor** allen Dialect.on_connect()-Hooks aufgerufen.

attribute sqlalchemy.engine.default.DefaultDialect.inline_comments: bool = False¶: Zeigt an, dass der Dialekt Kommentar-DDL unterstützt, die inline mit der Definition einer Tabelle oder Spalte erfolgen. Wenn False, impliziert dies, dass ALTER verwendet werden muss, um Tabellen- und Spaltenkommentare festzulegen.

attribute sqlalchemy.engine.default.DefaultDialect.insert_executemany_returning: bool¶: Dialekt / Treiber / Datenbank unterstützt irgendeine Form der INSERT...RETURNING-Unterstützung, wenn dialect.do_executemany() verwendet wird.

attribute sqlalchemy.engine.default.DefaultDialect.insert_executemany_returning_sort_by_parameter_order: bool¶: Dialekt / Treiber / Datenbank unterstützt irgendeine Form der INSERT...RETURNING-Unterstützung, wenn dialect.do_executemany() zusammen mit dem Parameter Insert.returning.sort_by_parameter_order auf True gesetzt ist.

attribute sqlalchemy.engine.default.DefaultDialect.insert_returning: bool = False¶: Ob der Dialekt RETURNING mit INSERT unterstützt.

Neu in Version 2.0.

attribute sqlalchemy.engine.default.DefaultDialect.insertmanyvalues_implicit_sentinel: InsertmanyvaluesSentinelOpts = symbol('NOT_SUPPORTED')¶: Optionen, die anzeigen, dass die Datenbank eine Form von Bulk-INSERT unterstützt, bei der der automatisch inkrementierte ganzzahlige Primärschlüssel als Ordnungszahl für eingefügte Zeilen zuverlässig verwendet werden kann.

Neu in Version 2.0.10.

Siehe auch

Korrelation von RETURNING-Zeilen zu Parametersätzen

attribute sqlalchemy.engine.default.DefaultDialect.insertmanyvalues_max_parameters: int = 32700¶: Alternative zu insertmanyvalues_page_size, wird die Seitengröße zusätzlich basierend auf der Gesamtzahl der Parameter in der Anweisung begrenzen.

attribute sqlalchemy.engine.default.DefaultDialect.insertmanyvalues_page_size: int = 1000¶

Anzahl der Zeilen, die für ExecuteStyle.INSERTMANYVALUES-Ausführungen in eine einzelne INSERT..VALUES()-Anweisung gerendert werden sollen.

Der Standarddialekt setzt diesen Wert standardmäßig auf 1000.

Neu in Version 2.0.

Siehe auch

Connection.execution_options.insertmanyvalues_page_size - Ausführungsoption verfügbar auf Connection, Anweisungen

attribute sqlalchemy.engine.default.DefaultDialect.is_async: bool = False¶: Ob dieser Dialekt für die Verwendung mit asyncio bestimmt ist.

method sqlalchemy.engine.default.DefaultDialect.is_disconnect(e, connection, cursor)¶: Gibt True zurück, wenn der gegebene DB-API-Fehler eine ungültige Verbindung anzeigt.

attribute sqlalchemy.engine.default.DefaultDialect.label_length: int | None¶: optionale benutzerdefinierte Maximallänge für SQL-Labels.

classmethod sqlalchemy.engine.default.DefaultDialect.load_provisioning()¶

Richtet das provision.py-Modul für diesen Dialekt ein.

Für Dialekte, die ein provision.py-Modul enthalten, das Provisionierungs-Follower einrichtet, sollte diese Methode diesen Prozess einleiten.

Eine typische Implementierung wäre

@classmethod
def load_provisioning(cls):
    __import__("mydialect.provision")

Die Standardmethode geht davon aus, dass sich ein Modul namens provision.py im Besitzpaket des aktuellen Dialekts befindet, basierend auf dem Attribut __module__

@classmethod
def load_provisioning(cls):
    package = ".".join(cls.__module__.split(".")[0:-1])
    try:
        __import__(package + ".provision")
    except ImportError:
        pass

Neu in Version 1.3.14.

attribute sqlalchemy.engine.default.DefaultDialect.loaded_dbapi¶

attribute sqlalchemy.engine.default.DefaultDialect.max_identifier_length: int = 9999¶: Die maximale Länge von Bezeichnernamen.

attribute sqlalchemy.engine.default.DefaultDialect.name: str = 'default'¶: identifizierender Name für den Dialekt aus einer DBAPI-neutralen Sichtweise (d.h. 'sqlite').

method sqlalchemy.engine.default.DefaultDialect.normalize_name(name)¶

Konvertiert den gegebenen Namen in Kleinbuchstaben, wenn er als case-insensitiv erkannt wird.

Diese Methode wird nur verwendet, wenn der Dialekt `requires_name_normalize=True` definiert.

method sqlalchemy.engine.default.DefaultDialect.on_connect()¶

Gibt eine aufrufbare Funktion zurück, die eine neu erstellte DBAPI-Verbindung einrichtet.

Die aufrufbare Funktion sollte ein einzelnes Argument "conn" akzeptieren, das die DBAPI-Verbindung selbst ist. Die innere aufrufbare Funktion hat keinen Rückgabewert.

Z. B.

class MyDialect(default.DefaultDialect):
    # ...

    def on_connect(self):
        def do_on_connect(connection):
            connection.execute("SET SPECIAL FLAGS etc")

        return do_on_connect

Dies wird verwendet, um Dialekt-weite pro-Verbindungsoptionen wie Isolationsmodi, Unicode-Modi usw. festzulegen.

Die "do_on_connect"-Aufrufbarkeit wird durch die Verwendung des PoolEvents.connect()-Event-Hooks aufgerufen, dann wird die DBAPI-Verbindung entpackt und an die Aufrufbarkeit übergeben.

Geändert in Version 1.4: Der Hook on_connect wird nicht mehr zweimal für die erste Verbindung eines Dialekts aufgerufen. Der Hook on_connect wird jedoch immer noch vor der Methode Dialect.initialize() aufgerufen.

Geändert in Version 1.4.3: Der Hook on_connect wird von einer neuen Methode on_connect_url aufgerufen, die die URL übergibt, die zur Erstellung der Connect-Argumente verwendet wurde. Dialekte können on_connect_url anstelle von on_connect implementieren, wenn sie das URL-Objekt benötigen, das für die Verbindung verwendet wurde, um zusätzlichen Kontext zu erhalten.

Wenn None zurückgegeben wird, wird kein Listener generiert.

Gibt zurück:: Eine aufrufbare Funktion, die eine einzelne DBAPI-Verbindung als Argument akzeptiert, oder None.

Siehe auch

Dialect.connect() - ermöglicht die Steuerung der DBAPI-connect()-Sequenz selbst.

Dialect.on_connect_url() - ersetzt Dialect.on_connect(), um auch das URL-Objekt im Kontext zu erhalten.

methode sqlalchemy.engine.default.DefaultDialect.on_connect_url(url: URL) → Callable[[Any], Any] | None¶

geerbt von der Dialect.on_connect_url() Methode von Dialect

Gibt eine aufrufbare Funktion zurück, die eine neu erstellte DBAPI-Verbindung einrichtet.

Diese Methode ist ein neuer Hook, der die Dialect.on_connect()-Methode ersetzt, wenn sie von einem Dialekt implementiert wird. Wenn sie nicht von einem Dialekt implementiert wird, ruft sie die Dialect.on_connect()-Methode direkt auf, um die Kompatibilität mit bestehenden Dialekten aufrechtzuerhalten. Für Dialect.on_connect() wird keine Veraltung erwartet.

Die aufrufbare Funktion sollte ein einzelnes Argument "conn" akzeptieren, das die DBAPI-Verbindung selbst ist. Die innere aufrufbare Funktion hat keinen Rückgabewert.

Z. B.

class MyDialect(default.DefaultDialect):
    # ...

    def on_connect_url(self, url):
        def do_on_connect(connection):
            connection.execute("SET SPECIAL FLAGS etc")

        return do_on_connect

Dies wird verwendet, um Dialekt-weite pro-Verbindungsoptionen wie Isolationsmodi, Unicode-Modi usw. festzulegen.

Diese Methode unterscheidet sich von Dialect.on_connect() dadurch, dass ihr das URL-Objekt übergeben wird, das für die Verbindungsargumente relevant ist. Normalerweise ist der einzige Weg, dieses zu erhalten, über den Dialect.on_connect()-Hook, indem man auf die Engine selbst zugreift. Dieses URL-Objekt kann jedoch durch Plugins ersetzt worden sein.

Hinweis

Die Standardimplementierung von Dialect.on_connect_url() ruft die Dialect.on_connect()-Methode auf. Daher wird, wenn ein Dialekt diese Methode implementiert, die Dialect.on_connect()-Methode **nicht aufgerufen**, es sei denn, der überschreibende Dialekt ruft sie direkt von hier aus auf.

Neu in Version 1.4.3: hinzugefügt Dialect.on_connect_url(), die normalerweise Dialect.on_connect() aufruft.

Parameter:: url¶ – ein URL-Objekt, das die URL darstellt, die an die Methode Dialect.create_connect_args() übergeben wurde.
Gibt zurück:: Eine aufrufbare Funktion, die eine einzelne DBAPI-Verbindung als Argument akzeptiert, oder None.

Siehe auch

Dialect.on_connect()

methode sqlalchemy.engine.default.DefaultDialect.paramstyle: str¶: Der zu verwendende Paramstyle (einige DB-APIs unterstützen mehrere Paramstyles).

methode sqlalchemy.engine.default.DefaultDialect.positional: bool¶: True, wenn der Paramstyle für diesen Dialekt positionell ist.

methode sqlalchemy.engine.default.DefaultDialect.preexecute_autoincrement_sequences: bool = False¶

True, wenn „implizite“ Primärschlüsselfunktionen separat ausgeführt werden müssen, um ihren Wert zu erhalten, wenn RETURNING nicht verwendet wird.

Dies ist derzeit auf PostgreSQL ausgerichtet, wenn der Parameter implicit_returning=False auf einem Table-Objekt verwendet wird.

methode sqlalchemy.engine.default.DefaultDialect.preparer¶: Alias für IdentifierPreparer

methode sqlalchemy.engine.default.DefaultDialect.reflection_options: Sequence[str] = ()¶

geerbt von der Dialect.reflection_options Attribut von Dialect

Sequenz von Zeichenkettennamen, die Schlüsselwortargumente angeben, die auf einem Table-Objekt festgelegt werden können und als „Reflexionsoptionen“ übergeben werden, wenn Table.autoload_with verwendet wird.

Aktuelles Beispiel ist „oracle_resolve_synonyms“ in den Oracle-Datenbankdialekten.

methode sqlalchemy.engine.default.DefaultDialect.reset_isolation_level(dbapi_conn)¶

Stellt eine DBAPI-Verbindung zurück auf ihre Standard-Isolationsstufe.

Beachten Sie, dass dies eine Dialekt-Methode ist, die als Teil der Implementierung der Isolationsgradfunktionen von Connection und Engine verwendet wird; diese APIs sollten für die meisten typischen Anwendungsfälle bevorzugt werden.

Siehe auch

Connection.get_isolation_level() - aktuellen Level anzeigen

Connection.default_isolation_level - Standardlevel anzeigen

Connection.execution_options.isolation_level - Isolationsgrad pro Connection festlegen

create_engine.isolation_level - Isolationsgrad pro Engine festlegen

methode sqlalchemy.engine.default.DefaultDialect.returns_native_bytes: bool = False¶: Zeigt an, ob Python bytes()-Objekte nativ vom Treiber für SQL-Datentypen vom Typ „binär“ zurückgegeben werden.

Neu in Version 2.0.11.

methode sqlalchemy.engine.default.DefaultDialect.sequences_optional: bool = False¶: Wenn True, zeigt an, ob der Parameter Sequence.optional des Sequence-Konstrukts signalisieren soll, kein CREATE SEQUENCE zu generieren. Gilt nur für Dialekte, die Sequenzen unterstützen. Wird derzeit nur verwendet, um PostgreSQL SERIAL auf einer Spalte zu erlauben, die Sequence() für die Verwendung auf anderen Backends angibt.

methode sqlalchemy.engine.default.DefaultDialect.server_side_cursors: bool = False¶: veraltet; zeigt an, ob der Dialekt standardmäßig Server-Side-Cursor verwenden soll.

methode sqlalchemy.engine.default.DefaultDialect.server_version_info: Tuple[Any, ...] | None = None¶

Ein Tupel, das eine Versionsnummer für das verwendete DB-Backend enthält.

Dieser Wert ist nur für unterstützte Dialekte verfügbar und wird normalerweise während der anfänglichen Verbindung zur Datenbank gefüllt.

methode sqlalchemy.engine.default.DefaultDialect.set_connection_execution_options(connection: Connection, opts: Mapping[str, Any]) → None¶

Legt Ausführungsoptionen für eine gegebene Verbindung fest.

Dies wird von DefaultDialect implementiert, um die Ausführungsoption Connection.execution_options.isolation_level zu implementieren. Dialekte können verschiedene Ausführungsoptionen abfangen, die möglicherweise den Zustand einer bestimmten DBAPI-Verbindung ändern müssen.

Neu in Version 1.4.

methode sqlalchemy.engine.default.DefaultDialect.set_engine_execution_options(engine: Engine, opts: Mapping[str, Any]) → None¶

Legt Ausführungsoptionen für eine gegebene Engine fest.

Dies wird von DefaultDialect implementiert, um Ereignis-Hooks für neue Connection-Instanzen einzurichten, die von der gegebenen Engine erstellt werden und die dann die Methode Dialect.set_connection_execution_options() für diese Verbindung aufrufen.

methode sqlalchemy.engine.default.DefaultDialect.set_isolation_level(dbapi_connection: DBAPIConnection, level: Literal['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED', 'READ UNCOMMITTED', 'AUTOCOMMIT']) → None¶

geerbt von der Dialect.set_isolation_level() Methode von Dialect

Legt die Isolationsstufe einer DBAPI-Verbindung fest.

Beachten Sie, dass dies eine Dialekt-Methode ist, die als Teil der Implementierung der Isolationsgradfunktionen von Connection und Engine verwendet wird; diese APIs sollten für die meisten typischen Anwendungsfälle bevorzugt werden.

Wenn der Dialekt auch die Methode Dialect.get_isolation_level_values() implementiert, dann ist das gegebene Level garantiert einer der Zeichenkettennamen aus dieser Sequenz, und die Methode muss keinen Lookup-Fehler antizipieren.

Siehe auch

Connection.get_isolation_level() - aktuellen Level anzeigen

Connection.default_isolation_level - Standardlevel anzeigen

Connection.execution_options.isolation_level - Isolationsgrad pro Connection festlegen

create_engine.isolation_level - Isolationsgrad pro Engine festlegen

methode sqlalchemy.engine.default.DefaultDialect.statement_compiler¶: Alias für SQLCompiler

methode sqlalchemy.engine.default.DefaultDialect.supports_alter: bool = True¶: True, wenn die Datenbank ALTER TABLE unterstützt - wird nur zur Generierung von Fremdschlüsselbeschränkungen unter bestimmten Umständen verwendet.

methode sqlalchemy.engine.default.DefaultDialect.supports_comments: bool = False¶: Zeigt an, dass der Dialekt Kommentar-DDL für Tabellen und Spalten unterstützt.

methode sqlalchemy.engine.default.DefaultDialect.supports_constraint_comments: bool = False¶: Zeigt an, ob der Dialekt Kommentar-DDL für Beschränkungen unterstützt.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.supports_default_metavalue: bool = False¶: Dialekt unterstützt die Syntax INSERT… VALUES (DEFAULT).

methode sqlalchemy.engine.default.DefaultDialect.supports_default_values: bool = False¶: Dialekt unterstützt die Syntax INSERT… DEFAULT VALUES.

methode sqlalchemy.engine.default.DefaultDialect.supports_empty_insert: bool = True¶: Dialekt unterstützt INSERT () VALUES ().

methode sqlalchemy.engine.default.DefaultDialect.supports_identity_columns: bool = False¶: Datenbank-Ziel unterstützt IDENTITY.

methode sqlalchemy.engine.default.DefaultDialect.supports_multivalues_insert: bool = False¶: Datenbank-Ziel unterstützt INSERT…VALUES mit mehreren Wertesätzen, d.h. INSERT INTO table (cols) VALUES (…), (…), (…), …

methode sqlalchemy.engine.default.DefaultDialect.supports_native_boolean: bool = False¶: Zeigt an, ob der Dialekt eine native boolesche Konstruktion unterstützt. Dies verhindert, dass Boolean eine CHECK-Beschränkung generiert, wenn dieser Typ verwendet wird.

methode sqlalchemy.engine.default.DefaultDialect.supports_native_decimal: bool = False¶: Zeigt an, ob Dezimalobjekte für numerische Datentypen mit Präzision behandelt und zurückgegeben werden oder ob Fließkommazahlen zurückgegeben werden.

methode sqlalchemy.engine.default.DefaultDialect.supports_native_enum: bool = False¶: Zeigt an, ob der Dialekt eine native ENUM-Konstruktion unterstützt. Dies verhindert, dass Enum eine CHECK-Beschränkung generiert, wenn dieser Typ im „nativen“ Modus verwendet wird.

methode sqlalchemy.engine.default.DefaultDialect.supports_native_uuid: bool = False¶: Zeigt an, ob Python UUID()-Objekte nativ vom Treiber für SQL-Datentypen vom Typ UUID behandelt werden.

Neu in Version 2.0.

methode sqlalchemy.engine.default.DefaultDialect.supports_sane_multi_rowcount: bool = True¶: Zeigt an, ob der Dialekt die rowcount für UPDATE und DELETE-Anweisungen ordnungsgemäß implementiert, wenn sie über executemany ausgeführt werden.

methode sqlalchemy.engine.default.DefaultDialect.supports_sane_rowcount: bool = True¶: Zeigt an, ob der Dialekt die rowcount für UPDATE und DELETE-Anweisungen ordnungsgemäß implementiert.

methode sqlalchemy.engine.default.DefaultDialect.supports_sane_rowcount_returning¶

True, wenn dieser Dialekt auch bei Verwendung von RETURNING eine ordnungsgemäße rowcount unterstützt.

Für Dialekte, die RETURNING nicht unterstützen, ist dies gleichbedeutend mit supports_sane_rowcount.

methode sqlalchemy.engine.default.DefaultDialect.supports_sequences: bool = False¶: Zeigt an, ob der Dialekt CREATE SEQUENCE oder ähnliches unterstützt.

methode sqlalchemy.engine.default.DefaultDialect.supports_server_side_cursors: bool = False¶: Zeigt an, ob der Dialekt Server-Side-Cursor unterstützt.

methode sqlalchemy.engine.default.DefaultDialect.supports_simple_order_by_label: bool = True¶: Datenbank-Ziel unterstützt ORDER BY <labelname>, wobei <labelname> sich auf ein Label in der Spaltenklausel von SELECT bezieht.

Attribut sqlalchemy.engine.default.DefaultDialect.supports_statement_cache: bool = True¶

Gibt an, ob dieser Dialekt Caching unterstützt.

Alle Dialekte, die mit Statement-Caching kompatibel sind, sollten dieses Flag direkt auf jeder Dialektklasse und Unterklasse, die es unterstützt, auf True setzen. SQLAlchemy testet, ob dieses Flag lokal auf jeder Dialektunterklasse vorhanden ist, bevor es Statement-Caching verwendet. Dies dient der Sicherheit für ältere oder neue Dialekte, die noch nicht vollständig auf Konformität mit SQL-Statement-Caching getestet wurden.

Neu in Version 1.4.5.

Siehe auch

Caching für Drittanbieter-Dialekte

Attribut sqlalchemy.engine.default.DefaultDialect.tuple_in_values: bool = False¶: Die Zieldatenbank unterstützt Tupel IN, d.h. (x, y) IN ((q, p), (r, z))

Attribut sqlalchemy.engine.default.DefaultDialect.type_compiler: Any¶

veraltet; dies ist eine TypeCompiler-Klasse auf Klassenebene, eine TypeCompiler-Instanz auf Instanzenebene.

Siehe stattdessen type_compiler_instance.

Attribut sqlalchemy.engine.default.DefaultDialect.type_compiler_cls¶: Alias von GenericTypeCompiler

Attribut sqlalchemy.engine.default.DefaultDialect.type_compiler_instance: TypeCompiler¶: Instanz einer Compiled-Klasse, die zum Kompilieren von SQL-Typobjekten verwendet wird

Neu in Version 2.0.

Methode sqlalchemy.engine.default.DefaultDialect.type_descriptor(typeobj)¶

Stellt ein datenbankspezifisches TypeEngine-Objekt bereit, gegeben das generische Objekt aus dem Typenmodul.

Diese Methode sucht nach einem Wörterbuch namens colspecs als Klassen- oder Instanzvariable und leitet an adapt_type() weiter.

Attribut sqlalchemy.engine.default.DefaultDialect.update_executemany_returning: bool = False¶: Der Dialekt unterstützt UPDATE..RETURNING mit executemany.

Attribut sqlalchemy.engine.default.DefaultDialect.update_returning: bool = False¶: wenn der Dialekt RETURNING mit UPDATE unterstützt

Neu in Version 2.0.

Attribut sqlalchemy.engine.default.DefaultDialect.update_returning_multifrom: bool = False¶: wenn der Dialekt RETURNING mit UPDATE..FROM unterstützt

Neu in Version 2.0.

Attribut sqlalchemy.engine.default.DefaultDialect.use_insertmanyvalues: bool = False¶

Wenn True, gibt an, dass die "insertmanyvalues"-Funktionalität verwendet werden sollte, um das Verhalten von insert_executemany_returning zu ermöglichen, wenn möglich.

In der Praxis bedeutet das Setzen auf True,

dass, wenn supports_multivalues_insert, insert_returning und use_insertmanyvalues alle True sind, der SQL-Compiler ein INSERT erzeugt, das vom DefaultDialect als ExecuteStyle.INSERTMANYVALUES-Ausführung interpretiert wird. Dies ermöglicht das INSERT von vielen Zeilen mit RETURNING durch Umschreiben einer Einzeilen-INSERT-Anweisung, um mehrere VALUES-Klauseln zu haben, und die Ausführung der Anweisung mehrmals für eine Reihe von Batches, wenn eine große Anzahl von Zeilen gegeben ist.

Der Parameter ist für den Standard-Dialekt False und wird für die internen SQLAlchemy-Dialekte SQLite, MySQL/MariaDB, PostgreSQL, SQL Server auf True gesetzt. Er bleibt für Oracle Database auf False, da diese native "executemany mit RETURNING"-Unterstützung bietet und auch supports_multivalues_insert nicht unterstützt. Für MySQL/MariaDB melden die MySQL-Dialekte, die RETURNING nicht unterstützen, insert_executemany_returning nicht als True.

Neu in Version 2.0.

Siehe auch

„Insert Many Values“-Verhalten für INSERT-Anweisungen

Attribut sqlalchemy.engine.default.DefaultDialect.use_insertmanyvalues_wo_returning: bool = False¶: Wenn True und use_insertmanyvalues ebenfalls True ist, werden auch INSERT-Anweisungen ohne RETURNING "insertmanyvalues" verwenden.

Neu in Version 2.0.

Siehe auch

„Insert Many Values“-Verhalten für INSERT-Anweisungen

Klasse sqlalchemy.engine.Dialect¶

Definiert das Verhalten einer bestimmten Datenbank- und DB-API-Kombination.

Jeder Aspekt der Metadatendefinition, der Generierung von SQL-Abfragen, der Ausführung, der Handhabung von Ergebnismengen oder alles andere, was zwischen Datenbanken variiert, wird unter der allgemeinen Kategorie des Dialekts definiert. Der Dialekt fungiert als Factory für andere datenbankspezifische Implementierungen von Objekten, einschließlich ExecutionContext, Compiled, DefaultGenerator und TypeEngine.

Hinweis

Drittanbieter-Dialekte sollten nicht direkt Dialect unterklassifizieren. Stattdessen sollten sie DefaultDialect oder eine abgeleitete Klasse unterklassifizieren.

Mitglieder

bind_typing, colspecs, connect(), construct_arguments, create_connect_args(), create_xid(), cte_follows_insert, dbapi, dbapi_exception_translation_map, ddl_compiler, default_isolation_level, default_metavalue_token, default_schema_name, default_sequence_base, delete_executemany_returning, delete_returning, delete_returning_multifrom, denormalize_name(), div_is_floordiv, do_begin(), do_begin_twophase(), do_close(), do_commit(), do_commit_twophase(), do_execute(), do_execute_no_params(), do_executemany(), do_ping(), do_prepare_twophase(), do_recover_twophase(), do_release_savepoint(), do_rollback(), do_rollback_to_savepoint(), do_rollback_twophase(), do_savepoint(), do_set_input_sizes(), do_terminate(), driver, engine_config_types, engine_created(), exclude_set_input_sizes, execute_sequence_format, execution_ctx_cls, favor_returning_over_lastrowid, get_async_dialect_cls(), get_check_constraints(), get_columns(), get_default_isolation_level(), get_dialect_cls(), get_dialect_pool_class(), get_driver_connection(), get_foreign_keys(), get_indexes(), get_isolation_level(), get_isolation_level_values(), get_materialized_view_names(), get_multi_check_constraints(), get_multi_columns(), get_multi_foreign_keys(), get_multi_indexes(), get_multi_pk_constraint(), get_multi_table_comment(), get_multi_table_options(), get_multi_unique_constraints(), get_pk_constraint(), get_schema_names(), get_sequence_names(), get_table_comment(), get_table_names(), get_table_options(), get_temp_table_names(), get_temp_view_names(), get_unique_constraints(), get_view_definition(), get_view_names(), has_index(), has_schema(), has_sequence(), has_table(), has_terminate, identifier_preparer, import_dbapi(), include_set_input_sizes, initialize(), inline_comments, insert_executemany_returning, insert_executemany_returning_sort_by_parameter_order, insert_returning, insertmanyvalues_implicit_sentinel, insertmanyvalues_max_parameters, insertmanyvalues_page_size, is_async, is_disconnect(), label_length, load_provisioning(), loaded_dbapi, max_identifier_length, name, normalize_name(), on_connect(), on_connect_url(), paramstyle, positional, preexecute_autoincrement_sequences, preparer, reflection_options, reset_isolation_level(), returns_native_bytes, sequences_optional, server_side_cursors, server_version_info, set_connection_execution_options(), set_engine_execution_options(), set_isolation_level(), statement_compiler, supports_alter, supports_comments, supports_constraint_comments, supports_default_metavalue, supports_default_values, supports_empty_insert, supports_identity_columns, supports_multivalues_insert, supports_native_boolean, supports_native_decimal, supports_native_enum, supports_native_uuid, supports_sane_multi_rowcount, supports_sane_rowcount, supports_sequences, supports_server_side_cursors, supports_simple_order_by_label, supports_statement_cache, tuple_in_values, type_compiler, type_compiler_cls, type_compiler_instance, type_descriptor(), update_executemany_returning, update_returning, update_returning_multifrom, use_insertmanyvalues, use_insertmanyvalues_wo_returning

Klassensignatur

Klasse sqlalchemy.engine.Dialect (sqlalchemy.event.registry.EventTarget)

Attribut sqlalchemy.engine.Dialect.bind_typing = 1¶

Definiert ein Mittel zur Übergabe von Typisierungsinformationen an die Datenbank und/oder den Treiber für gebundene Parameter.

Siehe BindTyping für Werte.

Neu in Version 2.0.

Attribut sqlalchemy.engine.Dialect.colspecs: MutableMapping[Type[TypeEngine[Any]], Type[TypeEngine[Any]]]¶: Ein Wörterbuch von TypeEngine-Klassen aus sqlalchemy.types, abgebildet auf Unterklassen, die spezifisch für die Dialektklasse sind. Dieses Wörterbuch ist nur auf Klassenebene vorhanden und wird nicht von der Dialektinstanz selbst abgerufen.

Methode sqlalchemy.engine.Dialect.connect(*cargs: Any, **cparams: Any) → DBAPIConnection¶

Stellt eine Verbindung mit der DBAPI dieses Dialekts her.

Die Standardimplementierung dieser Methode ist

def connect(self, *cargs, **cparams):
    return self.dbapi.connect(*cargs, **cparams)

Die Parameter *cargs, **cparams werden direkt aus der Methode Dialect.create_connect_args() dieses Dialekts generiert.

Diese Methode kann für Dialekte verwendet werden, die programmatische schrittweise Vorgänge pro Verbindung ausführen müssen, wenn eine neue Verbindung von der DBAPI bezogen wird.

Parameter:

*cargs¶ – Positionsargumente, die von der Methode Dialect.create_connect_args() zurückgegeben werden
**cparams¶ – Schlüsselwortargumente, die von der Methode Dialect.create_connect_args() zurückgegeben werden.

Gibt zurück:

Eine DBAPI-Verbindung, typischerweise von der Funktion PEP 249 auf Modullebene .connect().

Siehe auch

Dialect.create_connect_args()

Dialect.on_connect()

Attribut sqlalchemy.engine.Dialect.construct_arguments: List[Tuple[Type[SchemaItem | ClauseElement], Mapping[str, Any]]] | None = None¶

Optionale Argumentenspezifizierer für verschiedene SQLAlchemy-Konstrukte, typischerweise Schemaelemente.

Zur Implementierung als Reihe von Tupeln einrichten, wie in

construct_arguments = [
    (schema.Index, {"using": False, "where": None, "ops": None}),
]

Wenn das obige Konstrukt auf dem PostgreSQL-Dialekt eingerichtet ist, akzeptiert das Index-Konstrukt nun die Schlüsselwortargumente postgresql_using, postgresql_where und postgresql_ops. Jedes andere Argument, das dem Konstruktor von Index übergeben wird und mit postgresql_ beginnt, löst einen ArgumentError aus.

Ein Dialekt, der kein `construct_arguments`-Element enthält, nimmt nicht am Argumentvalidierungssystem teil. Für einen solchen Dialekt wird jeder Argumentname von allen teilnehmenden Konstrukten akzeptiert, innerhalb des Namespace von Argumenten, die mit diesem Dialektnamen präfixiert sind. Die Begründung hierfür ist, dass Drittanbieter-Dialekte, die diese Funktion noch nicht implementiert haben, weiterhin auf die alte Weise funktionieren.

Siehe auch

DialectKWArgs – implementierende Basisklasse, die DefaultDialect.construct_arguments konsumiert

Methode sqlalchemy.engine.Dialect.create_connect_args(url: URL) → ConnectArgsType¶

Erstellt DB-API-kompatible Verbindungsargumente.

Ausgehend von einem URL-Objekt wird ein Tupel zurückgegeben, das aus `(*args, **kwargs)` besteht, die direkt an die connect-Funktion des DBAPI gesendet werden können. Die Argumente werden an die Dialect.connect()-Methode gesendet, die dann die DBAPI-Ebene connect()-Funktion ausführt.

Die Methode nutzt typischerweise die URL.translate_connect_args()-Methode, um ein Wörterbuch mit Optionen zu generieren.

Die Standardimplementierung ist

def create_connect_args(self, url):
    opts = url.translate_connect_args()
    opts.update(url.query)
    return ([], opts)

Parameter:: url¶ – ein URL-Objekt
Gibt zurück:: ein Tupel aus `(*args, **kwargs)`, das an die Dialect.connect()-Methode übergeben wird.

Siehe auch

URL.translate_connect_args()

Methode sqlalchemy.engine.Dialect.create_xid() → Any¶

Erstellt eine Zwei-Phasen-Transaktions-ID.

Diese ID wird an `do_begin_twophase()`, `do_rollback_twophase()`, `do_commit_twophase()` übergeben. Ihr Format ist nicht spezifiziert.

Attribut sqlalchemy.engine.Dialect.cte_follows_insert: bool¶: Ziel-Datenbank, die beim Vorhandensein einer CTE mit einer INSERT-Anweisung die CTE unterhalb des INSERT benötigt

Attribut sqlalchemy.engine.Dialect.dbapi: ModuleType | None¶

Eine Referenz auf das DBAPI-Modul selbst.

SQLAlchemy-Dialekte importieren DBAPI-Module über die Klassenmethode Dialect.import_dbapi(). Der Grund dafür ist, dass jedes Dialektmodul importiert und zur Generierung von SQL-Anweisungen verwendet werden kann, ohne dass der eigentliche DBAPI-Treiber installiert sein muss. Erst wenn eine Engine mit create_engine() erstellt wird, wird der DBAPI importiert; zu diesem Zeitpunkt weist der Erstellungsprozess das DBAPI-Modul diesem Attribut zu.

Dialekte sollten daher Dialect.import_dbapi() implementieren, die das notwendige Modul importiert und zurückgibt, und dann im Dialektcode auf `self.dbapi` verweisen, um auf die Inhalte des DBAPI-Moduls zuzugreifen.

Geändert in Version The: Das Attribut Dialect.dbapi wird ausschließlich als pro Dialekt-Instanz-Referenz auf das DBAPI-Modul verwendet. Die frühere, nicht vollständig dokumentierte Klassenmethode .Dialect.dbapi() ist veraltet und wurde durch Dialect.import_dbapi() ersetzt.

Attribut sqlalchemy.engine.Dialect.dbapi_exception_translation_map: Mapping[str, str] = {}¶: Ein Wörterbuch von Namen, dessen Werte die Namen von PEP-249-Ausnahmen sind ("IntegrityError", "OperationalError" usw.), die alternativen Klassennamen zugeordnet sind, um den Fall zu unterstützen, dass ein DBAPI Ausnahmeklassen hat, die nicht so benannt sind, wie sie referenziert werden (z. B. IntegrityError = MyException). In den allermeisten Fällen ist dieses Wörterbuch leer.

Attribut sqlalchemy.engine.Dialect.ddl_compiler: Type[DDLCompiler]¶: Eine Compiled-Klasse, die zum Kompilieren von DDL-Anweisungen verwendet wird

Attribut sqlalchemy.engine.Dialect.default_isolation_level: IsolationLevel | None¶: die Isolation, die implizit bei neuen Verbindungen vorhanden ist

Attribut sqlalchemy.engine.Dialect.default_metavalue_token: str = 'DEFAULT'¶

für die Syntax INSERT… VALUES (DEFAULT) das Token, das in die Klammern gesetzt werden soll.

Beispiel: Für SQLite ist dies das Schlüsselwort „NULL“.

Attribut sqlalchemy.engine.Dialect.default_schema_name: str | None¶: der Name des Standard-Schemas. Dieser Wert ist nur für unterstützte Dialekte verfügbar und wird typischerweise während der initialen Verbindung zur Datenbank gefüllt.

Attribut sqlalchemy.engine.Dialect.default_sequence_base: int¶: der Standardwert, der als "START WITH"-Teil einer CREATE SEQUENCE DDL-Anweisung gerendert wird.

Attribut sqlalchemy.engine.Dialect.delete_executemany_returning: bool¶: Dialekt unterstützt DELETE..RETURNING mit executemany.

Attribut sqlalchemy.engine.Dialect.delete_returning: bool¶: ob der Dialekt RETURNING mit DELETE unterstützt

Neu in Version 2.0.

Attribut sqlalchemy.engine.Dialect.delete_returning_multifrom: bool¶: ob der Dialekt RETURNING mit DELETE..FROM unterstützt

Neu in Version 2.0.

Methode sqlalchemy.engine.Dialect.denormalize_name(name: str) → str¶

konvertiert den gegebenen Namen in eine fall-unempfindliche Kennung für das Backend, wenn es sich um einen vollständig kleingeschriebenen Namen handelt.

Diese Methode wird nur verwendet, wenn der Dialekt `requires_name_normalize=True` definiert.

Attribut sqlalchemy.engine.Dialect.div_is_floordiv: bool¶: Die Ziel-Datenbank behandelt den / Divisionsoperator als "Ganzzahldivision"

Methode sqlalchemy.engine.Dialect.do_begin(dbapi_connection: PoolProxiedConnection) → None¶

Stellt eine Implementierung von `connection.begin()` bereit, gegeben eine DB-API-Verbindung.

Die DBAPI hat keine dedizierte "begin"-Methode und Transaktionen sind implizit zu erwarten. Dieser Hook wird für jene DBAPIs bereitgestellt, die zusätzliche Unterstützung in diesem Bereich benötigen könnten.

Parameter:: dbapi_connection¶ – eine DBAPI-Verbindung, typischerweise proxied innerhalb einer ConnectionFairy.

Methode sqlalchemy.engine.Dialect.do_begin_twophase(connection: Connection, xid: Any) → None¶

Beginnt eine Zwei-Phasen-Transaktion auf der gegebenen Verbindung.

Parameter:

connection¶ – eine Connection.
xid¶ – xid

Methode sqlalchemy.engine.Dialect.do_close(dbapi_connection: DBAPIConnection) → None¶

Stellt eine Implementierung von `connection.close()` bereit, gegeben eine DBAPI-Verbindung.

Dieser Hook wird vom Pool aufgerufen, wenn eine Verbindung vom Pool getrennt wurde oder über die normale Kapazität des Pools hinaus zurückgegeben wird.

Methode sqlalchemy.engine.Dialect.do_commit(dbapi_connection: PoolProxiedConnection) → None¶

Stellt eine Implementierung von `connection.commit()` bereit, gegeben eine DB-API-Verbindung.

Parameter:: dbapi_connection¶ – eine DBAPI-Verbindung, typischerweise proxied innerhalb einer ConnectionFairy.

Methode sqlalchemy.engine.Dialect.do_commit_twophase(connection: Connection, xid: Any, is_prepared: bool = True, recover: bool = False) → None¶

Commit einer Zwei-Phasen-Transaktion auf der gegebenen Verbindung.

Parameter:

connection¶ – eine Connection.
xid¶ – xid
is_prepared¶ – ob TwoPhaseTransaction.prepare() aufgerufen wurde.
recover¶ – wenn das Wiederherstellungsflag übergeben wurde.

Methode sqlalchemy.engine.Dialect.do_execute(cursor: DBAPICursor, statement: str, parameters: Sequence[Any] | Mapping[str, Any] | None, context: ExecutionContext | None = None) → None¶: Stellt eine Implementierung von `cursor.execute(statement, parameters)` bereit.

Methode sqlalchemy.engine.Dialect.do_execute_no_params(cursor: DBAPICursor, statement: str, context: ExecutionContext | None = None) → None¶

Stellt eine Implementierung von `cursor.execute(statement)` bereit.

Die Parametersammlung sollte nicht gesendet werden.

Methode sqlalchemy.engine.Dialect.do_executemany(cursor: DBAPICursor, statement: str, parameters: Sequence[Sequence[Any]] | Sequence[Mapping[str, Any]], context: ExecutionContext | None = None) → None¶: Stellt eine Implementierung von `cursor.executemany(statement, parameters)` bereit.

Methode sqlalchemy.engine.Dialect.do_ping(dbapi_connection: DBAPIConnection) → bool¶: Pingt die DBAPI-Verbindung und gibt `True` zurück, wenn die Verbindung nutzbar ist.

Methode sqlalchemy.engine.Dialect.do_prepare_twophase(connection: Connection, xid: Any) → None¶

Bereitet eine Zwei-Phasen-Transaktion auf der gegebenen Verbindung vor.

Parameter:

connection¶ – eine Connection.
xid¶ – xid

Methode sqlalchemy.engine.Dialect.do_recover_twophase(connection: Connection) → List[Any]¶

Stellt eine Liste von unbestätigten vorbereiteten Zwei-Phasen-Transaktionsidentifikatoren auf der gegebenen Verbindung wieder her.

Parameter:: connection¶ – eine Connection.

Methode sqlalchemy.engine.Dialect.do_release_savepoint(connection: Connection, name: str) → None¶

Gibt den benannten Savepoint auf einer Verbindung frei.

Parameter:

connection¶ – eine Connection.
name¶ – Savepoint-Name.

Methode sqlalchemy.engine.Dialect.do_rollback(dbapi_connection: PoolProxiedConnection) → None¶

Stellt eine Implementierung von `connection.rollback()` bereit, gegeben eine DB-API-Verbindung.

Parameter:: dbapi_connection¶ – eine DBAPI-Verbindung, typischerweise proxied innerhalb einer ConnectionFairy.

Methode sqlalchemy.engine.Dialect.do_rollback_to_savepoint(connection: Connection, name: str) → None¶

Rollback einer Verbindung zu dem benannten Savepoint.

Parameter:

connection¶ – eine Connection.
name¶ – Savepoint-Name.

Methode sqlalchemy.engine.Dialect.do_rollback_twophase(connection: Connection, xid: Any, is_prepared: bool = True, recover: bool = False) → None¶

Macht eine Zwei-Phasen-Transaktion auf der gegebenen Verbindung rückgängig.

Parameter:

connection¶ – eine Connection.
xid¶ – xid
is_prepared¶ – ob TwoPhaseTransaction.prepare() aufgerufen wurde.
recover¶ – wenn das Wiederherstellungsflag übergeben wurde.

Methode sqlalchemy.engine.Dialect.do_savepoint(connection: Connection, name: str) → None¶

Erstellt einen Savepoint mit dem gegebenen Namen.

Parameter:

connection¶ – eine Connection.
name¶ – Savepoint-Name.

Methode sqlalchemy.engine.Dialect.do_set_input_sizes(cursor: DBAPICursor, list_of_tuples: _GenericSetInputSizesType, context: ExecutionContext) → Any¶

ruft die Methode cursor.setinputsizes() mit den entsprechenden Argumenten auf

Dieser Hook wird aufgerufen, wenn das Attribut Dialect.bind_typing auf den Wert BindTyping.SETINPUTSIZES gesetzt ist. Parameterdaten werden in einer Liste von Tupeln (paramname, dbtype, sqltype) übergeben, wobei paramname der Schlüssel des Parameters in der Anweisung ist, dbtype der DBAPI-Datentyp und sqltype der SQLAlchemy-Typ ist. Die Reihenfolge der Tupel entspricht der korrekten Parameterreihenfolge.

Neu in Version 1.4.

Geändert in Version 2.0: - Der Modus `setinputsizes` wird jetzt aktiviert, indem Dialect.bind_typing auf BindTyping.SETINPUTSIZES gesetzt wird. Dialekte, die einen Parameter use_setinputsizes akzeptieren, sollten diesen Wert entsprechend setzen.

Methode sqlalchemy.engine.Dialect.do_terminate(dbapi_connection: DBAPIConnection) → None¶

Bietet eine Implementierung von connection.close(), die versucht, so wenig wie möglich zu blockieren, unter Angabe einer DBAPI-Verbindung.

In den allermeisten Fällen ruft dies nur `.close()` auf. Für einige asyncio-Dialekte können jedoch andere API-Funktionen verwendet werden.

Dieser Hook wird vom Pool aufgerufen, wenn eine Verbindung wiederverwendet oder ungültig gemacht wird.

Neu in Version 1.4.41.

Attribut sqlalchemy.engine.Dialect.driver: str¶: identifizierender Name für das DBAPI des Dialekts

Attribut sqlalchemy.engine.Dialect.engine_config_types: Mapping[str, Any]¶: eine Zuordnung von String-Schlüsseln, die in einer Engine-Konfiguration vorhanden sein können, verknüpft mit Typumwandlungsfunktionen.

Klassenmethode sqlalchemy.engine.Dialect.engine_created(engine: Engine) → None¶

Ein Hilfs-Hook, der aufgerufen wird, bevor die endgültige Engine zurückgegeben wird.

Wenn das Dialekt eine andere Klasse als die Methode get_dialect_cls() zurückgibt, wird der Hook auf beiden Klassen aufgerufen, zuerst auf der von der Methode get_dialect_cls() zurückgegebenen Dialektklasse und dann auf der Klasse, auf der die Methode aufgerufen wurde.

Der Hook sollte von Dialekten und/oder Wrappern verwendet werden, um spezielle Ereignisse auf die Engine oder ihre Komponenten anzuwenden. Insbesondere ermöglicht er einer Dialekt-Wrapper-Klasse, Dialekt-bezogene Ereignisse anzuwenden.

attribut sqlalchemy.engine.Dialect.exclude_set_input_sizes: Set[Any] | None¶

Set von DBAPI-Typ-Objekten, die bei automatischen cursor.setinputsizes()-Aufrufen ausgeschlossen werden sollen.

Dies wird nur verwendet, wenn bind_typing auf BindTyping.SET_INPUT_SIZES gesetzt ist.

attribut sqlalchemy.engine.Dialect.execute_sequence_format: Type[Tuple[Any, ...]] | Type[Tuple[List[Any]]]¶: entweder der Typ 'tuple' oder 'list', abhängig davon, was cursor.execute() für das zweite Argument akzeptiert (diese variieren).

attribut sqlalchemy.engine.Dialect.execution_ctx_cls: Type[ExecutionContext]¶: eine ExecutionContext-Klasse zur Behandlung der Statement-Ausführung

attribut sqlalchemy.engine.Dialect.favor_returning_over_lastrowid: bool¶

für Backends, die sowohl eine `lastrowid` als auch eine `RETURNING`-Einfügestrategie unterstützen, wird `RETURNING` für einfache Einfügungen mit einzelnen Ganzzahl-Primärschlüsseln bevorzugt.

cursor.lastrowid ist bei den meisten Backends tendenziell performanter.

classmethod sqlalchemy.engine.Dialect.get_async_dialect_cls(url: URL) → Type[Dialect]¶

Gibt anhand einer URL den Dialect zurück, der von einer asynchronen Engine verwendet wird.

Standardmäßig ist dies ein Alias für Dialect.get_dialect_cls() und gibt einfach die Klasse zurück. Sie kann verwendet werden, wenn ein Dialekt sowohl eine synchrone als auch eine asynchrone Version unter demselben Namen bereitstellt, wie z. B. der psycopg-Treiber.

Neu in Version 2.

Siehe auch

Dialect.get_dialect_cls()

methode sqlalchemy.engine.Dialect.get_check_constraints(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedCheckConstraint]¶

Gibt Informationen über Check-Constraints in table_name zurück.

Gibt anhand eines Strings table_name und eines optionalen Strings schema Informationen zu Check-Constraints als Liste von Dictionaries zurück, die dem ReflectedCheckConstraint Dictionary entsprechen.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_check_constraints() verwenden.

methode sqlalchemy.engine.Dialect.get_columns(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedColumn]¶

Gibt Informationen über Spalten in table_name zurück.

Gibt anhand einer Connection, eines Strings table_name und eines optionalen Strings schema Spalteninformationen als Liste von Dictionaries zurück, die dem ReflectedColumn Dictionary entsprechen.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_columns() verwenden.

methode sqlalchemy.engine.Dialect.get_default_isolation_level(dbapi_conn: DBAPIConnection) → Literal['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED', 'READ UNCOMMITTED', 'AUTOCOMMIT']¶

Gibt anhand einer DBAPI-Verbindung deren Isolationslevel zurück, oder einen Standard-Isolationslevel, wenn keiner abgerufen werden kann.

Diese Methode darf nur NotImplementedError auslösen und **keine andere Ausnahme auslösen**, da sie beim ersten Verbindungsaufbau implizit verwendet wird.

Die Methode **muss einen Wert zurückgeben** für ein Dialekt, das Isolationslevel-Einstellungen unterstützt, da dieses Level als Standard wiederhergestellt wird, wenn eine isolationsspezifische Änderung pro Verbindung vorgenommen wird.

Die Methode verwendet standardmäßig die Methode Dialect.get_isolation_level(), es sei denn, sie wird von einem Dialekt überschrieben.

Neu in Version 1.3.22.

classmethod sqlalchemy.engine.Dialect.get_dialect_cls(url: URL) → Type[Dialect]¶

Gibt anhand einer URL den zu verwendenden Dialect zurück.

Dies ist ein Hook, der es einem externen Plugin ermöglicht, Funktionalität um einen vorhandenen Dialekt herum bereitzustellen, indem das Plugin von der URL basierend auf einem Entrypoint geladen wird und das Plugin dann den tatsächlich zu verwendenden Dialekt zurückgibt.

Standardmäßig wird einfach die Klasse zurückgegeben.

methode sqlalchemy.engine.Dialect.get_dialect_pool_class(url: URL) → Type[Pool]¶: gibt eine Pool-Klasse zurück, die für eine gegebene URL verwendet werden soll

methode sqlalchemy.engine.Dialect.get_driver_connection(connection: DBAPIConnection) → Any¶

Gibt das vom externen Treiberpaket zurückgegebene Verbindungsobjekt zurück.

Für normale Dialekte, die einen DBAPI-konformen Treiber verwenden, gibt dieser Aufruf einfach die als Argument übergebene connection zurück. Für Dialekte, die stattdessen einen nicht-DBAPI-konformen Treiber anpassen, wie z. B. bei der Anpassung eines Asyncio-Treibers, gibt dieser Aufruf das verbindungähnliche Objekt zurück, das vom Treiber zurückgegeben wird.

Neu in Version 1.4.24.

methode sqlalchemy.engine.Dialect.get_foreign_keys(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedForeignKeyConstraint]¶

Gibt Informationen über Fremdschlüssel in table_name zurück.

Gibt anhand einer Connection, eines Strings table_name und eines optionalen Strings schema Informationen zu Fremdschlüsseln als Liste von Dictionaries zurück, die dem ReflectedForeignKeyConstraint Dictionary entsprechen.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_foreign_keys() verwenden.

methode sqlalchemy.engine.Dialect.get_indexes(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedIndex]¶

Gibt Informationen über Indizes in table_name zurück.

Gibt anhand einer Connection, eines Strings table_name und eines optionalen Strings schema Indexinformationen als Liste von Dictionaries zurück, die dem ReflectedIndex Dictionary entsprechen.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_indexes() verwenden.

methode sqlalchemy.engine.Dialect.get_isolation_level(dbapi_connection: DBAPIConnection) → Literal['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED', 'READ UNCOMMITTED', 'AUTOCOMMIT']¶

Gibt den Isolationsgrad einer DBAPI-Verbindung zurück.

Bei der Arbeit mit einem Connection-Objekt kann die entsprechende DBAPI-Verbindung über den Connection.connection-Accessor abgerufen werden.

Beachten Sie, dass dies eine Dialekt-Methode ist, die als Teil der Implementierung der Isolationsgradfunktionen von Connection und Engine verwendet wird; diese APIs sollten für die meisten typischen Anwendungsfälle bevorzugt werden.

Siehe auch

Connection.get_isolation_level() - aktuellen Level anzeigen

Connection.default_isolation_level - Standardlevel anzeigen

Connection.execution_options.isolation_level - Isolationsgrad pro Connection festlegen

create_engine.isolation_level - Isolationsgrad pro Engine festlegen

methode sqlalchemy.engine.Dialect.get_isolation_level_values(dbapi_conn: DBAPIConnection) → List[Literal['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED', 'READ UNCOMMITTED', 'AUTOCOMMIT']]¶

Gibt eine Sequenz von Zeichenketten-Isolationsgradnamen zurück, die von dieser Dialekt unterstützt werden.

Die verfügbaren Namen sollten die folgenden Konventionen verwenden:

verwende GROSSBUCHSTABEN. Isolationsgradmethoden akzeptieren Kleinbuchstaben, aber diese werden in GROSSBUCHSTABEN normalisiert, bevor sie an die Dialekt weitergegeben werden.
Wörter werden durch Leerzeichen, nicht durch Unterstriche, getrennt, z. B. REPEATABLE READ. Isolationsgradnamen werden vor der Weitergabe an die Dialekt in Unterstriche in Leerzeichen umgewandelt.
Die Namen für die vier Standard-Isolationsnamen sollten, soweit sie vom Backend unterstützt werden, READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE lauten.
Wenn die Dialekt eine AUTOCOMMIT-Option unterstützt, sollte diese mit dem Isolationsgradnamen AUTOCOMMIT angegeben werden.
Andere Isolationsmodi können ebenfalls vorhanden sein, sofern sie in GROSSBUCHSTABEN benannt sind und Leerzeichen anstelle von Unterstrichen verwenden.

Diese Funktion wird verwendet, damit die Standarddialekt prüfen kann, ob ein gegebener Isolationsgradparameter gültig ist, andernfalls wird ein ArgumentError ausgelöst.

Eine DBAPI-Verbindung wird an die Methode übergeben, falls die Dialekt die Verbindung selbst abfragen muss, um diese Liste zu ermitteln. Es wird jedoch erwartet, dass die meisten Backends eine fest kodierte Liste von Werten zurückgeben. Wenn die Dialekt "AUTOCOMMIT" unterstützt, sollte dieser Wert ebenfalls in der zurückgegebenen Sequenz enthalten sein.

Die Methode löst standardmäßig NotImplementedError aus. Wenn eine Dialekt diese Methode nicht implementiert, führt die Standarddialekt keine Überprüfung eines gegebenen Isolationsgradwerts durch, bevor er an die Methode Dialect.set_isolation_level() weitergegeben wird. Dies dient der Abwärtskompatibilität mit Drittanbieter-Dialekten, die diese Methode möglicherweise noch nicht implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.get_materialized_view_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

Gibt eine Liste aller Materialized View-Namen zurück, die in der Datenbank verfügbar sind.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_materialized_view_names() verwenden.

Parameter:

schema¶ –

Schema-Name, der abgefragt werden soll, falls nicht das Standardschema.

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.get_multi_check_constraints(connection: Connection, *, schema: str | None = None, filter_names: Collection[str] | None = None, **kw: Any) → Iterable[Tuple[TableKey, List[ReflectedCheckConstraint]]]¶

Gibt Informationen über CHECK-Constraints in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_check_constraints() verwenden.

Hinweis

Die DefaultDialect bietet eine Standardimplementierung, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() entsprechend dem angegebenen kind zurückgibt. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.get_multi_columns(connection: Connection, *, schema: str | None = None, filter_names: Collection[str] | None = None, **kw: Any) → Iterable[Tuple[TableKey, List[ReflectedColumn]]]¶

Gibt Informationen über Spalten in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_columns() verwenden.

Hinweis

Die DefaultDialect bietet eine Standardimplementierung, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() entsprechend dem angegebenen kind zurückgibt. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.get_multi_foreign_keys(connection: Connection, *, schema: str | None = None, filter_names: Collection[str] | None = None, **kw: Any) → Iterable[Tuple[TableKey, List[ReflectedForeignKeyConstraint]]]¶

Gibt Informationen über Fremdschlüssel in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_foreign_keys() verwenden.

Hinweis

Die DefaultDialect bietet eine Standardimplementierung, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() entsprechend dem angegebenen kind zurückgibt. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.get_multi_indexes(connection: Connection, *, schema: str | None = None, filter_names: Collection[str] | None = None, **kw: Any) → Iterable[Tuple[TableKey, List[ReflectedIndex]]]¶

Gibt Informationen über Indizes in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_indexes() verwenden.

Hinweis

Die DefaultDialect bietet eine Standardimplementierung, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() entsprechend dem angegebenen kind zurückgibt. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.get_multi_pk_constraint(connection: Connection, *, schema: str | None = None, filter_names: Collection[str] | None = None, **kw: Any) → Iterable[Tuple[TableKey, ReflectedPrimaryKeyConstraint]]¶

Gibt Informationen über Primärschlüssel-Constraints in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_pk_constraint() verwenden.

Hinweis

Die DefaultDialect bietet eine Standardimplementierung, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() entsprechend dem angegebenen kind zurückgibt. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.get_multi_table_comment(connection: Connection, *, schema: str | None = None, filter_names: Collection[str] | None = None, **kw: Any) → Iterable[Tuple[TableKey, ReflectedTableComment]]¶

Gibt Informationen über den Tabellenkommentar in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_table_comment() verwenden.

Hinweis

Die DefaultDialect bietet eine Standardimplementierung, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() entsprechend dem angegebenen kind zurückgibt. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.get_multi_table_options(connection: Connection, *, schema: str | None = None, filter_names: Collection[str] | None = None, **kw: Any) → Iterable[Tuple[TableKey, Dict[str, Any]]]¶

Gibt ein Wörterbuch mit Optionen zurück, die bei der Erstellung der Tabellen im angegebenen Schema festgelegt wurden.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_table_options() verwenden.

Hinweis

Die DefaultDialect bietet eine Standardimplementierung, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() entsprechend dem angegebenen kind zurückgibt. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.get_multi_unique_constraints(connection: Connection, *, schema: str | None = None, filter_names: Collection[str] | None = None, **kw: Any) → Iterable[Tuple[TableKey, List[ReflectedUniqueConstraint]]]¶

Gibt Informationen über UNIQUE-Constraints in allen Tabellen des angegebenen schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_multi_unique_constraints() verwenden.

Hinweis

Die DefaultDialect bietet eine Standardimplementierung, die die Methode für einzelne Tabellen für jedes Objekt aufruft, das von Dialect.get_table_names(), Dialect.get_view_names() oder Dialect.get_materialized_view_names() entsprechend dem angegebenen kind zurückgibt. Dialekte, die eine schnellere Implementierung unterstützen möchten, sollten diese Methode implementieren.

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.get_pk_constraint(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → ReflectedPrimaryKeyConstraint¶

Gibt Informationen über den Primärschlüssel-Constraint für table_name zurück.

Gibt anhand einer Connection, einem Zeichenketten-table_name und einem optionalen Zeichenketten-schema Informationen über den Primärschlüssel als Wörterbuch zurück, das dem ReflectedPrimaryKeyConstraint-Wörterbuch entspricht.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_pk_constraint() verwenden.

methode sqlalchemy.engine.Dialect.get_schema_names(connection: Connection, **kw: Any) → List[str]¶

Gibt eine Liste aller Schema-Namen zurück, die in der Datenbank verfügbar sind.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_schema_names() verwenden.

methode sqlalchemy.engine.Dialect.get_sequence_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

Gibt eine Liste aller Sequenz-Namen zurück, die in der Datenbank verfügbar sind.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_sequence_names() verwenden.

Parameter:: schema¶ – Schema-Name, der abgefragt werden soll, falls nicht das Standardschema.

Neu in Version 1.4.

methode sqlalchemy.engine.Dialect.get_table_comment(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → ReflectedTableComment¶

Gibt den „Kommentar“ für die durch table_name identifizierte Tabelle zurück.

Gibt anhand eines Zeichenketten-table_name und eines optionalen Zeichenketten-schema Informationen über den Tabellenkommentar als Wörterbuch zurück, das dem ReflectedTableComment-Wörterbuch entspricht.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_table_comment() verwenden.

Auslösen:: NotImplementedError für Dialekte, die Kommentare nicht unterstützen.

Neu seit Version 1.2.

methode sqlalchemy.engine.Dialect.get_table_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

Gibt eine Liste von Tabellennamen für schema zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_table_names() verwenden.

methode sqlalchemy.engine.Dialect.get_table_options(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → Dict[str, Any]¶

Gibt ein Wörterbuch mit Optionen zurück, die bei der Erstellung von table_name festgelegt wurden.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_table_options() verwenden.

methode sqlalchemy.engine.Dialect.get_temp_table_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

Gibt eine Liste von temporären Tabellennamen in der angegebenen Verbindung zurück, falls vom zugrunde liegenden Backend unterstützt.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_temp_table_names() verwenden.

methode sqlalchemy.engine.Dialect.get_temp_view_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

Gibt eine Liste von temporären View-Namen in der angegebenen Verbindung zurück, falls vom zugrunde liegenden Backend unterstützt.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_temp_view_names() verwenden.

methode sqlalchemy.engine.Dialect.get_unique_constraints(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedUniqueConstraint]¶

Gibt Informationen über eindeutige Einschränkungen in table_name zurück.

Gibt, gegeben einen String table_name und einen optionalen String schema, Informationen über eindeutige Einschränkungen als eine Liste von Dictionaries zurück, die dem ReflectedUniqueConstraint Dictionary entsprechen.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_unique_constraints() verwenden.

methode sqlalchemy.engine.Dialect.get_view_definition(connection: Connection, view_name: str, schema: str | None = None, **kw: Any) → str¶

Gibt die Definition einer normalen oder materialisierten Ansicht zurück.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_view_definition() verwenden.

Gibt, gegeben ein Connection, einen String view_name und einen optionalen String schema, die Ansichtsdefinition zurück.

methode sqlalchemy.engine.Dialect.get_view_names(connection: Connection, schema: str | None = None, **kw: Any) → List[str]¶

Gibt eine Liste aller nicht-materialisierten Ansichtsnamen zurück, die in der Datenbank verfügbar sind.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.get_view_names() verwenden.

Parameter:: schema¶ – Schema-Name, der abgefragt werden soll, falls nicht das Standardschema.

methode sqlalchemy.engine.Dialect.has_index(connection: Connection, table_name: str, index_name: str, schema: str | None = None, **kw: Any) → bool¶

Überprüft die Existenz eines bestimmten Indexnamens in der Datenbank.

Gibt, gegeben ein Connection-Objekt, einen String table_name und einen String Indexnamen, True zurück, wenn ein Index des gegebenen Namens für die gegebene Tabelle existiert, andernfalls False.

Der DefaultDialect implementiert dies auf Basis der Methoden Dialect.has_table() und Dialect.get_indexes(), jedoch können Dialekte eine performantere Version implementieren.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.has_index() verwenden.

Neu in Version 1.4.

methode sqlalchemy.engine.Dialect.has_schema(connection: Connection, schema_name: str, **kw: Any) → bool¶

Überprüft die Existenz eines bestimmten Schemanamens in der Datenbank.

Gibt, gegeben ein Connection-Objekt, einen String schema_name, True zurück, wenn ein Schema des gegebenen Namens existiert, andernfalls False.

Der DefaultDialect implementiert dies, indem er die Anwesenheit von schema_name unter den Schemata prüft, die von Dialect.get_schema_names() zurückgegeben werden, jedoch können Dialekte eine performantere Version implementieren.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.has_schema() verwenden.

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.has_sequence(connection: Connection, sequence_name: str, schema: str | None = None, **kw: Any) → bool¶

Überprüft die Existenz einer bestimmten Sequenz in der Datenbank.

Gibt, gegeben ein Connection-Objekt und einen String sequence_name, True zurück, wenn die gegebene Sequenz in der Datenbank existiert, andernfalls False.

Dies ist eine interne Dialektmethode. Anwendungen sollten Inspector.has_sequence() verwenden.

methode sqlalchemy.engine.Dialect.has_table(connection: Connection, table_name: str, schema: str | None = None, **kw: Any) → bool¶

Für interne Dialektverwendung, überprüft die Existenz einer bestimmten Tabelle oder Ansicht in der Datenbank.

Gibt, gegeben ein Connection-Objekt, einen String table_name und einen optionalen Schemanamen, True zurück, wenn die gegebene Tabelle in der Datenbank existiert, andernfalls False.

Diese Methode dient als zugrunde liegende Implementierung der öffentlichen Methode Inspector.has_table() und wird auch intern verwendet, um das Verhalten "checkfirst" für Methoden wie Table.create() und MetaData.create_all() zu implementieren.

Hinweis

Diese Methode wird intern von SQLAlchemy verwendet und wird veröffentlicht, damit Drittanbieter-Dialekte eine Implementierung bereitstellen können. Sie ist **nicht** die öffentliche API zum Überprüfen der Tabellenpräsenz. Bitte verwenden Sie die Methode Inspector.has_table().

Geändert in Version 2.0::: Dialect.has_table() unterstützt jetzt formell die Überprüfung auf zusätzliche tabellenähnliche Objekte

alle Arten von Ansichten (normal oder materialisiert)
temporäre Tabellen jeglicher Art

Zuvor waren diese beiden Prüfungen nicht formell spezifiziert und verschiedene Dialekte verhielten sich unterschiedlich. Die Dialekt-Testsuite enthält jetzt Tests für all diese Objekttypen, und Dialekte, in dem Maße, wie die zugrunde liegende Datenbank Ansichten oder temporäre Tabellen unterstützt, sollten versuchen, diese Objekte zu lokalisieren, um die volle Konformität zu gewährleisten.

attribut sqlalchemy.engine.Dialect.has_terminate: bool¶: Ob dieser Dialekt eine separate "terminate"-Implementierung hat, die nicht blockiert oder auf ein Awaiten wartet.

attribut sqlalchemy.engine.Dialect.identifier_preparer: IdentifierPreparer¶: Dieses Element verweist auf eine Instanz von IdentifierPreparer, sobald ein DefaultDialect konstruiert wurde.

classmethod sqlalchemy.engine.Dialect.import_dbapi() → module¶

Importiert das DBAPI-Modul, das von diesem Dialekt verwendet wird.

Das hier zurückgegebene Python-Modulobjekt wird als Instanzvariable einem konstruierten Dialekt unter dem Namen .dbapi zugewiesen.

Geändert in Version 2.0: Die Klassenmethode Dialect.import_dbapi() wurde von der vorherigen Methode .Dialect.dbapi() umbenannt, die zur Instanziierungszeit des Dialekts durch das DBAPI-Modul selbst ersetzt wurde, wodurch derselbe Name auf zwei verschiedene Arten verwendet wurde. Wenn eine .Dialect.dbapi()-Klassenmethode auf einem Drittanbieter-Dialekt vorhanden ist, wird diese verwendet und eine Deprecation-Warnung ausgegeben.

attribut sqlalchemy.engine.Dialect.include_set_input_sizes: Set[Any] | None¶

Set von DBAPI-Typobjekten, die in automatische cursor.setinputsizes()-Aufrufe einbezogen werden sollen.

Dies wird nur verwendet, wenn bind_typing auf BindTyping.SET_INPUT_SIZES gesetzt ist.

methode sqlalchemy.engine.Dialect.initialize(connection: Connection) → None¶

Wird während der strategisierten Erstellung des Dialekts mit einer Verbindung aufgerufen.

Ermöglicht es Dialekten, Optionen basierend auf Serverversionsinformationen oder anderen Eigenschaften zu konfigurieren.

Die hier übergebene Verbindung ist ein SQLAlchemy Connection-Objekt mit vollen Fähigkeiten.

Die initialize()-Methode des Basisdialekts sollte über super() aufgerufen werden.

Hinweis

Ab SQLAlchemy 1.4 wird diese Methode **vor** allen Dialect.on_connect()-Hooks aufgerufen.

attribut sqlalchemy.engine.Dialect.inline_comments: bool¶: Zeigt an, dass der Dialekt Kommentar-DDL unterstützt, die inline mit der Definition einer Tabelle oder Spalte erfolgen. Wenn False, impliziert dies, dass ALTER verwendet werden muss, um Tabellen- und Spaltenkommentare festzulegen.

attribut sqlalchemy.engine.Dialect.insert_executemany_returning: bool¶: Dialekt / Treiber / Datenbank unterstützt irgendeine Form der INSERT...RETURNING-Unterstützung, wenn dialect.do_executemany() verwendet wird.

attribut sqlalchemy.engine.Dialect.insert_executemany_returning_sort_by_parameter_order: bool¶: Dialekt / Treiber / Datenbank unterstützt irgendeine Form der INSERT...RETURNING-Unterstützung, wenn dialect.do_executemany() zusammen mit dem Parameter Insert.returning.sort_by_parameter_order auf True gesetzt ist.

attribut sqlalchemy.engine.Dialect.insert_returning: bool¶: Ob der Dialekt RETURNING mit INSERT unterstützt.

Neu in Version 2.0.

attribut sqlalchemy.engine.Dialect.insertmanyvalues_implicit_sentinel: InsertmanyvaluesSentinelOpts¶: Optionen, die anzeigen, dass die Datenbank eine Form von Bulk-INSERT unterstützt, bei der der automatisch inkrementierte ganzzahlige Primärschlüssel als Ordnungszahl für eingefügte Zeilen zuverlässig verwendet werden kann.

Neu in Version 2.0.10.

Siehe auch

Korrelation von RETURNING-Zeilen zu Parametersätzen

attribut sqlalchemy.engine.Dialect.insertmanyvalues_max_parameters: int¶: Alternative zu insertmanyvalues_page_size, wird die Seitengröße zusätzlich basierend auf der Gesamtzahl der Parameter in der Anweisung begrenzen.

attribut sqlalchemy.engine.Dialect.insertmanyvalues_page_size: int¶

Anzahl der Zeilen, die für ExecuteStyle.INSERTMANYVALUES-Ausführungen in eine einzelne INSERT..VALUES()-Anweisung gerendert werden sollen.

Der Standarddialekt setzt diesen Wert standardmäßig auf 1000.

Neu in Version 2.0.

Siehe auch

Connection.execution_options.insertmanyvalues_page_size - Ausführungsoption verfügbar auf Connection, Anweisungen

attribut sqlalchemy.engine.Dialect.is_async: bool¶: Ob dieser Dialekt für die Verwendung mit asyncio bestimmt ist.

methode sqlalchemy.engine.Dialect.is_disconnect(e: Exception, connection: PoolProxiedConnection | DBAPIConnection | None, cursor: DBAPICursor | None) → bool¶: Gibt True zurück, wenn der gegebene DB-API-Fehler eine ungültige Verbindung anzeigt.

attribut sqlalchemy.engine.Dialect.label_length: int | None¶: optionale benutzerdefinierte Maximallänge für SQL-Labels.

classmethod sqlalchemy.engine.Dialect.load_provisioning() → None¶

Richtet das provision.py-Modul für diesen Dialekt ein.

Für Dialekte, die ein provision.py-Modul enthalten, das Provisionierungs-Follower einrichtet, sollte diese Methode diesen Prozess einleiten.

Eine typische Implementierung wäre

@classmethod
def load_provisioning(cls):
    __import__("mydialect.provision")

Die Standardmethode geht davon aus, dass sich ein Modul namens provision.py im Besitzpaket des aktuellen Dialekts befindet, basierend auf dem Attribut __module__

@classmethod
def load_provisioning(cls):
    package = ".".join(cls.__module__.split(".")[0:-1])
    try:
        __import__(package + ".provision")
    except ImportError:
        pass

Neu in Version 1.3.14.

attribut sqlalchemy.engine.Dialect.loaded_dbapi¶: dieselbe wie .dbapi, aber nie None; löst einen Fehler aus, wenn keine DBAPI eingerichtet wurde.

Neu in Version 2.0.

attribut sqlalchemy.engine.Dialect.max_identifier_length: int¶: Die maximale Länge von Bezeichnernamen.

attribut sqlalchemy.engine.Dialect.name: str¶: identifizierender Name für den Dialekt aus einer DBAPI-neutralen Sichtweise (d.h. 'sqlite').

methode sqlalchemy.engine.Dialect.normalize_name(name: str) → str¶

Konvertiert den gegebenen Namen in Kleinbuchstaben, wenn er als case-insensitiv erkannt wird.

Diese Methode wird nur verwendet, wenn der Dialekt `requires_name_normalize=True` definiert.

methode sqlalchemy.engine.Dialect.on_connect() → Callable[[Any], Any] | None¶

Gibt eine aufrufbare Funktion zurück, die eine neu erstellte DBAPI-Verbindung einrichtet.

Die aufrufbare Funktion sollte ein einzelnes Argument "conn" akzeptieren, das die DBAPI-Verbindung selbst ist. Die innere aufrufbare Funktion hat keinen Rückgabewert.

Z. B.

class MyDialect(default.DefaultDialect):
    # ...

    def on_connect(self):
        def do_on_connect(connection):
            connection.execute("SET SPECIAL FLAGS etc")

        return do_on_connect

Dies wird verwendet, um Dialekt-weite pro-Verbindungsoptionen wie Isolationsmodi, Unicode-Modi usw. festzulegen.

Die "do_on_connect"-Aufrufbarkeit wird durch die Verwendung des PoolEvents.connect()-Event-Hooks aufgerufen, dann wird die DBAPI-Verbindung entpackt und an die Aufrufbarkeit übergeben.

Geändert in Version 1.4: Der Hook on_connect wird nicht mehr zweimal für die erste Verbindung eines Dialekts aufgerufen. Der Hook on_connect wird jedoch immer noch vor der Methode Dialect.initialize() aufgerufen.

Geändert in Version 1.4.3: Der Hook on_connect wird von einer neuen Methode on_connect_url aufgerufen, die die URL übergibt, die zur Erstellung der Connect-Argumente verwendet wurde. Dialekte können on_connect_url anstelle von on_connect implementieren, wenn sie das URL-Objekt benötigen, das für die Verbindung verwendet wurde, um zusätzlichen Kontext zu erhalten.

Wenn None zurückgegeben wird, wird kein Listener generiert.

Gibt zurück:: Eine aufrufbare Funktion, die eine einzelne DBAPI-Verbindung als Argument akzeptiert, oder None.

Siehe auch

Dialect.connect() - ermöglicht die Steuerung der DBAPI-connect()-Sequenz selbst.

Dialect.on_connect_url() - ersetzt Dialect.on_connect(), um auch das URL-Objekt im Kontext zu erhalten.

methode sqlalchemy.engine.Dialect.on_connect_url(url: URL) → Callable[[Any], Any] | None¶

Gibt eine aufrufbare Funktion zurück, die eine neu erstellte DBAPI-Verbindung einrichtet.

Diese Methode ist ein neuer Hook, der die Dialect.on_connect()-Methode ersetzt, wenn sie von einem Dialekt implementiert wird. Wenn sie nicht von einem Dialekt implementiert wird, ruft sie die Dialect.on_connect()-Methode direkt auf, um die Kompatibilität mit bestehenden Dialekten aufrechtzuerhalten. Für Dialect.on_connect() wird keine Veraltung erwartet.

Die aufrufbare Funktion sollte ein einzelnes Argument "conn" akzeptieren, das die DBAPI-Verbindung selbst ist. Die innere aufrufbare Funktion hat keinen Rückgabewert.

Z. B.

class MyDialect(default.DefaultDialect):
    # ...

    def on_connect_url(self, url):
        def do_on_connect(connection):
            connection.execute("SET SPECIAL FLAGS etc")

        return do_on_connect

Dies wird verwendet, um Dialekt-weite pro-Verbindungsoptionen wie Isolationsmodi, Unicode-Modi usw. festzulegen.

Diese Methode unterscheidet sich von Dialect.on_connect() dadurch, dass ihr das URL-Objekt übergeben wird, das für die Verbindungsargumente relevant ist. Normalerweise ist der einzige Weg, dieses zu erhalten, über den Dialect.on_connect()-Hook, indem man auf die Engine selbst zugreift. Dieses URL-Objekt kann jedoch durch Plugins ersetzt worden sein.

Hinweis

Die Standardimplementierung von Dialect.on_connect_url() ruft die Dialect.on_connect()-Methode auf. Daher wird, wenn ein Dialekt diese Methode implementiert, die Dialect.on_connect()-Methode **nicht aufgerufen**, es sei denn, der überschreibende Dialekt ruft sie direkt von hier aus auf.

Neu in Version 1.4.3: hinzugefügt Dialect.on_connect_url(), die normalerweise Dialect.on_connect() aufruft.

Parameter:: url¶ – ein URL-Objekt, das die an die Dialect.create_connect_args()-Methode übergebene URL darstellt.
Gibt zurück:: Eine aufrufbare Funktion, die eine einzelne DBAPI-Verbindung als Argument akzeptiert, oder None.

Siehe auch

Dialect.on_connect()

attribut sqlalchemy.engine.Dialect.paramstyle: str¶: Der zu verwendende Paramstyle (einige DB-APIs unterstützen mehrere Paramstyles).

attribut sqlalchemy.engine.Dialect.positional: bool¶: True, wenn der Paramstyle für diesen Dialekt positionell ist.

attribut sqlalchemy.engine.Dialect.preexecute_autoincrement_sequences: bool¶

True, wenn „implizite“ Primärschlüsselfunktionen separat ausgeführt werden müssen, um ihren Wert zu erhalten, wenn RETURNING nicht verwendet wird.

Dies ist derzeit auf PostgreSQL ausgerichtet, wenn der Parameter implicit_returning=False auf einem Table-Objekt verwendet wird.

attribut sqlalchemy.engine.Dialect.preparer: Type[IdentifierPreparer]¶: eine IdentifierPreparer-Klasse zum Quoting von Identifikatoren.

attribut sqlalchemy.engine.Dialect.reflection_options: Sequence[str] = ()¶

Sequenz von Zeichenkettennamen, die Schlüsselwortargumente angeben, die auf einem Table-Objekt festgelegt werden können und als „Reflexionsoptionen“ übergeben werden, wenn Table.autoload_with verwendet wird.

Aktuelles Beispiel ist „oracle_resolve_synonyms“ in den Oracle-Datenbankdialekten.

methode sqlalchemy.engine.Dialect.reset_isolation_level(dbapi_connection: DBAPIConnection) → None¶

Stellt eine DBAPI-Verbindung zurück auf ihre Standard-Isolationsstufe.

Beachten Sie, dass dies eine Dialekt-Methode ist, die als Teil der Implementierung der Isolationsgradfunktionen von Connection und Engine verwendet wird; diese APIs sollten für die meisten typischen Anwendungsfälle bevorzugt werden.

Siehe auch

Connection.get_isolation_level() - aktuellen Level anzeigen

Connection.default_isolation_level - Standardlevel anzeigen

Connection.execution_options.isolation_level - Isolationsgrad pro Connection festlegen

create_engine.isolation_level - Isolationsgrad pro Engine festlegen

attribut sqlalchemy.engine.Dialect.returns_native_bytes: bool¶: Zeigt an, ob Python bytes()-Objekte nativ vom Treiber für SQL-Datentypen vom Typ „binär“ zurückgegeben werden.

Neu in Version 2.0.11.

attribut sqlalchemy.engine.Dialect.sequences_optional: bool¶: Wenn True, zeigt an, ob der Parameter Sequence.optional des Sequence-Konstrukts signalisieren soll, kein CREATE SEQUENCE zu generieren. Gilt nur für Dialekte, die Sequenzen unterstützen. Wird derzeit nur verwendet, um PostgreSQL SERIAL auf einer Spalte zu erlauben, die Sequence() für die Verwendung auf anderen Backends angibt.

attribut sqlalchemy.engine.Dialect.server_side_cursors: bool¶: veraltet; zeigt an, ob der Dialekt standardmäßig Server-Side-Cursor verwenden soll.

attribut sqlalchemy.engine.Dialect.server_version_info: Tuple[Any, ...] | None¶

Ein Tupel, das eine Versionsnummer für das verwendete DB-Backend enthält.

Dieser Wert ist nur für unterstützte Dialekte verfügbar und wird normalerweise während der anfänglichen Verbindung zur Datenbank gefüllt.

methode sqlalchemy.engine.Dialect.set_connection_execution_options(connection: Connection, opts: CoreExecuteOptionsParameter) → None¶

Legt Ausführungsoptionen für eine gegebene Verbindung fest.

Dies wird von DefaultDialect implementiert, um die Ausführungsoption Connection.execution_options.isolation_level zu implementieren. Dialekte können verschiedene Ausführungsoptionen abfangen, die möglicherweise den Zustand einer bestimmten DBAPI-Verbindung ändern müssen.

Neu in Version 1.4.

methode sqlalchemy.engine.Dialect.set_engine_execution_options(engine: Engine, opts: CoreExecuteOptionsParameter) → None¶

Legt Ausführungsoptionen für eine gegebene Engine fest.

Dies wird von DefaultDialect implementiert, um Ereignis-Hooks für neue Connection-Instanzen einzurichten, die von der gegebenen Engine erstellt werden und die dann die Methode Dialect.set_connection_execution_options() für diese Verbindung aufrufen.

methode sqlalchemy.engine.Dialect.set_isolation_level(dbapi_connection: DBAPIConnection, level: Literal['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED', 'READ UNCOMMITTED', 'AUTOCOMMIT']) → None¶

Legt die Isolationsstufe einer DBAPI-Verbindung fest.

Beachten Sie, dass dies eine Dialekt-Methode ist, die als Teil der Implementierung der Isolationsgradfunktionen von Connection und Engine verwendet wird; diese APIs sollten für die meisten typischen Anwendungsfälle bevorzugt werden.

Wenn der Dialekt auch die Methode Dialect.get_isolation_level_values() implementiert, dann ist das gegebene Level garantiert einer der Zeichenkettennamen aus dieser Sequenz, und die Methode muss keinen Lookup-Fehler antizipieren.

Siehe auch

Connection.get_isolation_level() - aktuellen Level anzeigen

Connection.default_isolation_level - Standardlevel anzeigen

Connection.execution_options.isolation_level - Isolationsgrad pro Connection festlegen

create_engine.isolation_level - Isolationsgrad pro Engine festlegen

attribut sqlalchemy.engine.Dialect.statement_compiler: Type[SQLCompiler]¶: eine Compiled-Klasse zum Kompilieren von SQL-Anweisungen

attribut sqlalchemy.engine.Dialect.supports_alter: bool¶: True, wenn die Datenbank ALTER TABLE unterstützt - wird nur zur Generierung von Fremdschlüsselbeschränkungen unter bestimmten Umständen verwendet.

attribut sqlalchemy.engine.Dialect.supports_comments: bool¶: Zeigt an, dass der Dialekt Kommentar-DDL für Tabellen und Spalten unterstützt.

attribut sqlalchemy.engine.Dialect.supports_constraint_comments: bool¶: Zeigt an, ob der Dialekt Kommentar-DDL für Beschränkungen unterstützt.

Neu in Version 2.0.

attribut sqlalchemy.engine.Dialect.supports_default_metavalue: bool¶

Dialekt unterstützt die INSERT…(col) VALUES (DEFAULT)-Syntax.

Die meisten Datenbanken unterstützen dies auf irgendeine Weise, z. B. unterstützt SQLite es mit VALUES (NULL). MS SQL Server unterstützt die Syntax ebenfalls, aber es ist der einzige enthaltene Dialekt, bei dem dies deaktiviert ist, da MSSQL das Feld für die IDENTITY-Spalte nicht unterstützt, wo wir die Funktion normalerweise nutzen möchten.

attribut sqlalchemy.engine.Dialect.supports_default_values: bool¶: Dialekt unterstützt die Syntax INSERT… DEFAULT VALUES.

attribut sqlalchemy.engine.Dialect.supports_empty_insert: bool¶

Dialekt unterstützt INSERT () VALUES (), d.h. ein einfacher INSERT ohne Spalten.

Dies wird normalerweise nicht unterstützt; ein „leerer“ INSERT wird typischerweise mit „INSERT..DEFAULT VALUES“ oder „INSERT … (col) VALUES (DEFAULT)“ durchgeführt.

attribut sqlalchemy.engine.Dialect.supports_identity_columns: bool¶: Datenbank-Ziel unterstützt IDENTITY.

attribut sqlalchemy.engine.Dialect.supports_multivalues_insert: bool¶: Datenbank-Ziel unterstützt INSERT…VALUES mit mehreren Wertesätzen, d.h. INSERT INTO table (cols) VALUES (…), (…), (…), …

attribut sqlalchemy.engine.Dialect.supports_native_boolean: bool¶: Zeigt an, ob der Dialekt eine native boolesche Konstruktion unterstützt. Dies verhindert, dass Boolean eine CHECK-Beschränkung generiert, wenn dieser Typ verwendet wird.

attribut sqlalchemy.engine.Dialect.supports_native_decimal: bool¶: Zeigt an, ob Dezimalobjekte für numerische Datentypen mit Präzision behandelt und zurückgegeben werden oder ob Fließkommazahlen zurückgegeben werden.

attribut sqlalchemy.engine.Dialect.supports_native_enum: bool¶: Zeigt an, ob der Dialekt eine native ENUM-Konstruktion unterstützt. Dies verhindert, dass Enum eine CHECK-Beschränkung generiert, wenn dieser Typ im „nativen“ Modus verwendet wird.

attribut sqlalchemy.engine.Dialect.supports_native_uuid: bool¶: Zeigt an, ob Python UUID()-Objekte nativ vom Treiber für SQL-Datentypen vom Typ UUID behandelt werden.

Neu in Version 2.0.

attribut sqlalchemy.engine.Dialect.supports_sane_multi_rowcount: bool¶: Zeigt an, ob der Dialekt die rowcount für UPDATE und DELETE-Anweisungen ordnungsgemäß implementiert, wenn sie über executemany ausgeführt werden.

attribut sqlalchemy.engine.Dialect.supports_sane_rowcount: bool¶: Zeigt an, ob der Dialekt die rowcount für UPDATE und DELETE-Anweisungen ordnungsgemäß implementiert.

attribut sqlalchemy.engine.Dialect.supports_sequences: bool¶: Zeigt an, ob der Dialekt CREATE SEQUENCE oder ähnliches unterstützt.

attribut sqlalchemy.engine.Dialect.supports_server_side_cursors: bool¶: Zeigt an, ob der Dialekt Server-Side-Cursor unterstützt.

attribut sqlalchemy.engine.Dialect.supports_simple_order_by_label: bool¶: Datenbank-Ziel unterstützt ORDER BY <labelname>, wobei <labelname> sich auf ein Label in der Spaltenklausel von SELECT bezieht.

attribut sqlalchemy.engine.Dialect.supports_statement_cache: bool = True¶

Gibt an, ob dieser Dialekt Caching unterstützt.

Alle Dialekte, die mit Statement-Caching kompatibel sind, sollten dieses Flag direkt auf jeder Dialektklasse und Unterklasse, die es unterstützt, auf True setzen. SQLAlchemy testet, ob dieses Flag lokal auf jeder Dialektunterklasse vorhanden ist, bevor es Statement-Caching verwendet. Dies dient der Sicherheit für ältere oder neue Dialekte, die noch nicht vollständig auf Konformität mit SQL-Statement-Caching getestet wurden.

Neu in Version 1.4.5.

Siehe auch

Caching für Drittanbieter-Dialekte

attribut sqlalchemy.engine.Dialect.tuple_in_values: bool¶: Die Zieldatenbank unterstützt Tupel IN, d.h. (x, y) IN ((q, p), (r, z))

attribut sqlalchemy.engine.Dialect.type_compiler: Any¶

veraltet; dies ist eine TypeCompiler-Klasse auf Klassenebene, eine TypeCompiler-Instanz auf Instanzenebene.

Siehe stattdessen type_compiler_instance.

attribut sqlalchemy.engine.Dialect.type_compiler_cls: ClassVar[Type[TypeCompiler]]¶: eine Compiled-Klasse zum Kompilieren von SQL-Typobjekten

Neu in Version 2.0.

attribut sqlalchemy.engine.Dialect.type_compiler_instance: TypeCompiler¶: Instanz einer Compiled-Klasse, die zum Kompilieren von SQL-Typobjekten verwendet wird

Neu in Version 2.0.

methode sqlalchemy.engine.Dialect.type_descriptor(typeobj: TypeEngine[_T]) → TypeEngine[_T]¶

Konvertiert einen generischen Typ in einen dialektspezifischen Typ.

Dialektklassen verwenden normalerweise die Funktion adapt_type() im Modul types, um dies zu erreichen.

Das zurückgegebene Ergebnis wird *pro Dialektklasse* zwischengespeichert und kann daher keinen dialektinstanzspezifischen Zustand enthalten.

attribut sqlalchemy.engine.Dialect.update_executemany_returning: bool¶: Der Dialekt unterstützt UPDATE..RETURNING mit executemany.

attribut sqlalchemy.engine.Dialect.update_returning: bool¶: wenn der Dialekt RETURNING mit UPDATE unterstützt

Neu in Version 2.0.

attribut sqlalchemy.engine.Dialect.update_returning_multifrom: bool¶: wenn der Dialekt RETURNING mit UPDATE..FROM unterstützt

Neu in Version 2.0.

attribut sqlalchemy.engine.Dialect.use_insertmanyvalues: bool¶

Wenn True, gibt an, dass die "insertmanyvalues"-Funktionalität verwendet werden sollte, um das Verhalten von insert_executemany_returning zu ermöglichen, wenn möglich.

In der Praxis bedeutet das Setzen auf True,

dass, wenn supports_multivalues_insert, insert_returning und use_insertmanyvalues alle True sind, der SQL-Compiler ein INSERT erzeugt, das vom DefaultDialect als ExecuteStyle.INSERTMANYVALUES-Ausführung interpretiert wird. Dies ermöglicht das INSERT von vielen Zeilen mit RETURNING durch Umschreiben einer Einzeilen-INSERT-Anweisung, um mehrere VALUES-Klauseln zu haben, und die Ausführung der Anweisung mehrmals für eine Reihe von Batches, wenn eine große Anzahl von Zeilen gegeben ist.

Der Parameter ist für den Standard-Dialekt False und wird für die internen SQLAlchemy-Dialekte SQLite, MySQL/MariaDB, PostgreSQL, SQL Server auf True gesetzt. Er bleibt für Oracle Database auf False, da diese native "executemany mit RETURNING"-Unterstützung bietet und auch supports_multivalues_insert nicht unterstützt. Für MySQL/MariaDB melden die MySQL-Dialekte, die RETURNING nicht unterstützen, insert_executemany_returning nicht als True.

Neu in Version 2.0.

Siehe auch

„Insert Many Values“-Verhalten für INSERT-Anweisungen

attribut sqlalchemy.engine.Dialect.use_insertmanyvalues_wo_returning: bool¶: Wenn True und use_insertmanyvalues ebenfalls True ist, werden auch INSERT-Anweisungen ohne RETURNING "insertmanyvalues" verwenden.

Neu in Version 2.0.

Siehe auch

„Insert Many Values“-Verhalten für INSERT-Anweisungen

klasse sqlalchemy.engine.default.DefaultExecutionContext¶

Klassensignatur

klasse sqlalchemy.engine.default.DefaultExecutionContext (sqlalchemy.engine.interfaces.ExecutionContext)

attribut sqlalchemy.engine.default.DefaultExecutionContext.compiled: Compiled | None = None¶: Wenn an den Konstruktor übergeben, das ausgeführte SQLAlchemy-Objekt von sqlalchemy.engine.base.Compiled.

attribut sqlalchemy.engine.default.DefaultExecutionContext.connection: Connection¶: Verbindungsobjekt, das von Standardwertgeneratoren frei zur Ausführung von SQL verwendet werden kann. Diese Verbindung sollte auf dieselben zugrunde liegenden Verbindungs-/Transaktionsressourcen wie root_connection verweisen.

methode sqlalchemy.engine.default.DefaultExecutionContext.create_cursor()¶

Gibt einen neuen Cursor zurück, der aus der Verbindung dieses ExecutionContext generiert wurde.

Einige Dialekte möchten möglicherweise das Verhalten von connection.cursor() ändern, z. B. PostgreSQL, das einen serverseitigen PG-Cursor zurückgeben kann.

attribut sqlalchemy.engine.default.DefaultExecutionContext.current_parameters: _CoreSingleExecuteParams | None = None¶

Ein Wörterbuch der Parameter, die auf die aktuelle Zeile angewendet werden.

Dieses Attribut ist nur im Kontext einer benutzerdefinierten Standardgenerierungsfunktion verfügbar (wie unter Kontextabhängige Standardfunktionen beschrieben). Es besteht aus einem Wörterbuch, das Einträge für jedes Spalten-/Wertpaar enthält, das Teil der INSERT- oder UPDATE-Anweisung sein soll. Die Schlüssel des Wörterbuchs sind die Schlüsselwerte jeder Column, was normalerweise mit dem Namen gleichbedeutend ist.

Beachten Sie, dass das Attribut DefaultExecutionContext.current_parameters die Funktion „Multi-Values“ der Methode Insert.values() nicht berücksichtigt. Bevorzugt werden sollte die Methode DefaultExecutionContext.get_current_parameters().

Siehe auch

DefaultExecutionContext.get_current_parameters()

Kontextsensitive Standardfunktionen

Attribut sqlalchemy.engine.default.DefaultExecutionContext.cursor: DBAPICursor¶: DB-API-Cursor, der aus der Verbindung bezogen wurde

Attribut sqlalchemy.engine.default.DefaultExecutionContext.dialect: Dialect¶: Dialekt, der diesen ExecutionContext erstellt hat.

Attribut sqlalchemy.engine.default.DefaultExecutionContext.engine: Engine¶: Engine, mit der die Verbindung assoziiert ist

Attribut sqlalchemy.engine.default.DefaultExecutionContext.execute_style: ExecuteStyle = 0¶: Der Stil der DBAPI-Cursor-Methode, die zum Ausführen einer Anweisung verwendet wird.

Neu in Version 2.0.

Attribut sqlalchemy.engine.default.DefaultExecutionContext.executemany: bool¶

True, wenn der Kontext eine Liste mit mehr als einem Parametersatz hat.

Historisch gesehen verknüpft dieses Attribut, ob cursor.execute() oder cursor.executemany() verwendet wird. Es kann nun auch bedeuten, dass „insertmanyvalues“ verwendet werden kann, was eine oder mehrere Aufrufe von cursor.execute() anzeigt.

Attribut sqlalchemy.engine.default.DefaultExecutionContext.execution_options: _ExecuteOptions = {}¶: Ausführungsoptionen, die mit der aktuellen Anweisungsausführung verbunden sind

Methode sqlalchemy.engine.default.DefaultExecutionContext.fetchall_for_returning(cursor)¶

Für ein RETURNING-Ergebnis wird cursor.fetchall() vom DBAPI-Cursor geliefert.

Dies ist ein dialektspezifischer Hook für Dialekte, die spezielle Überlegungen beim Aufruf von Zeilen haben, die für eine „RETURNING“-Anweisung geliefert werden. Die Standardimplementierung ist cursor.fetchall().

Dieser Hook wird derzeit nur von der insertmanyvalues-Funktion verwendet. Dialekte, die use_insertmanyvalues=True nicht setzen, müssen diesen Hook nicht berücksichtigen.

Neu in Version 2.0.10.

Methode sqlalchemy.engine.default.DefaultExecutionContext.get_current_parameters(isolate_multiinsert_groups=True)¶

Gibt ein Wörterbuch mit Parametern zurück, die auf die aktuelle Zeile angewendet werden.

Diese Methode kann nur im Kontext einer benutzerdefinierten Standardgenerierungsfunktion verwendet werden, z. B. wie unter Kontextabhängige Standardfunktionen beschrieben. Wenn sie aufgerufen wird, wird ein Wörterbuch zurückgegeben, das Einträge für jedes Spalten-/Wertpaar enthält, das Teil der INSERT- oder UPDATE-Anweisung ist. Die Schlüssel des Wörterbuchs sind die Schlüsselwerte jeder Column, was normalerweise gleichbedeutend mit dem Namen ist.

Parameter:: isolate_multiinsert_groups=True¶ – gibt an, dass mehrwertige INSERT-Konstrukte, die mit Insert.values() erstellt wurden, durch Rückgabe nur des Teilmengen der Parameter behandelt werden sollen, die lokal für den aktuellen Spaltendefault-Aufruf sind. Wenn False, werden die Rohparameter der Anweisung zurückgegeben, einschließlich der Namenskonvention, die im Falle von mehrwertigen INSERTs verwendet wird.

Neu in Version 1.2: hinzugefügt DefaultExecutionContext.get_current_parameters(), das mehr Funktionalität als das vorhandene Attribut DefaultExecutionContext.current_parameters bietet.

Siehe auch

DefaultExecutionContext.current_parameters

Kontextsensitive Standardfunktionen

Methode sqlalchemy.engine.default.DefaultExecutionContext.get_lastrowid()¶

Gibt nach einem INSERT self.cursor.lastrowid oder ein Äquivalent zurück.

Dies kann das Aufrufen spezieller Cursor-Funktionen, das Ausgeben eines neuen SELECT auf dem Cursor (oder einem neuen) oder das Zurückgeben eines gespeicherten Werts, der innerhalb von post_exec() berechnet wurde, umfassen.

Diese Funktion wird nur für Dialekte aufgerufen, die eine „implizite“ Primärschlüsselgenerierung unterstützen, preexecute_autoincrement_sequences auf False gesetzt lassen und wenn kein expliziter ID-Wert an die Anweisung gebunden war.

Die Funktion wird einmal für eine INSERT-Anweisung aufgerufen, die den zuletzt eingefügten Primärschlüssel für diese Dialekte zurückgeben müsste, die das Konzept von lastrowid verwenden. In diesen Fällen wird sie direkt nach ExecutionContext.post_exec() aufgerufen.

Methode sqlalchemy.engine.default.DefaultExecutionContext.get_out_parameter_values(names)¶

Gibt eine Sequenz von OUT-Parameterwerten aus einem Cursor zurück.

Für Dialekte, die OUT-Parameter unterstützen, wird diese Methode aufgerufen, wenn ein SQLCompiler-Objekt vorhanden ist, dessen Flag SQLCompiler.has_out_parameters gesetzt ist. Dieses Flag wird wiederum auf True gesetzt, wenn die Anweisung selbst BindParameter-Objekte mit dem Flag .isoutparam hat, die von der Methode SQLCompiler.visit_bindparam() verbraucht werden. Wenn der Dialekt-Compiler BindParameter-Objekte mit gesetztem .isoutparam erzeugt, die nicht von SQLCompiler.visit_bindparam() behandelt werden, sollte er dieses Flag explizit setzen.

Die Liste der Namen, die für jedes gebundene Parameter gerendert wurden, wird an die Methode übergeben. Die Methode sollte dann eine Sequenz von Werten zurückgeben, die den Parameterobjekten entsprechen. Im Gegensatz zu früheren SQLAlchemy-Versionen können die Werte die **Rohwerte** des DBAPI sein; der Ausführungskontext wendet den entsprechenden Typ-Handler basierend auf dem an, was in self.compiled.binds vorhanden ist, und aktualisiert die Werte. Das verarbeitete Wörterbuch wird dann über die Sammlung .out_parameters des Ergebnisobjekts verfügbar gemacht. Beachten Sie, dass SQLAlchemy 1.4 mehrere Arten von Ergebnisobjekten im Rahmen des 2.0-Übergangs hat.

Neu in Version 1.4: - hinzugefügt ExecutionContext.get_out_parameter_values(), das automatisch vom DefaultExecutionContext aufgerufen wird, wenn BindParameter-Objekte mit gesetztem Flag .isoutparam vorhanden sind. Dies ersetzt die Praxis, Out-Parameter innerhalb der nun entfernten Methode get_result_proxy() zu setzen.

Methode sqlalchemy.engine.default.DefaultExecutionContext.get_result_processor(type_, colname, coltype)¶

Gibt einen „Ergebnisprozessor“ für einen gegebenen Typ zurück, wie er in cursor.description vorhanden ist.

Dies hat eine Standardimplementierung, die Dialekte für kontextsensitive Ergebnisdatentypbehandlung überschreiben können.

Methode sqlalchemy.engine.default.DefaultExecutionContext.handle_dbapi_exception(e)¶: Empfängt eine DBAPI-Ausnahme, die während der Ausführung, des Abrufs von Ergebnissen usw. aufgetreten ist.

Attribut sqlalchemy.engine.default.DefaultExecutionContext.invoked_statement: Executable | None = None¶

Das Executable-Statement-Objekt, das ursprünglich übergeben wurde.

Dies sollte strukturell äquivalent zu compiled.statement sein, aber nicht unbedingt dasselbe Objekt, da im Falle eines Caching-Szenarios die kompilierte Form aus dem Cache extrahiert wurde.

Attribut sqlalchemy.engine.default.DefaultExecutionContext.isinsert: bool = False¶: True, wenn die Anweisung ein INSERT ist.

Attribut sqlalchemy.engine.default.DefaultExecutionContext.isupdate: bool = False¶: True, wenn die Anweisung ein UPDATE ist.

Methode sqlalchemy.engine.default.DefaultExecutionContext.lastrow_has_defaults()¶: Gibt True zurück, wenn die letzte Zeile eines INSERT oder UPDATE Inline- oder datenbankseitige Standardwerte enthielt.

Attribut sqlalchemy.engine.default.DefaultExecutionContext.no_parameters: bool¶: True, wenn der Ausführungsstil keine Parameter verwendet

Attribut sqlalchemy.engine.default.DefaultExecutionContext.parameters: _DBAPIMultiExecuteParams¶

Bindeparameter, die an die Methoden execute() oder exec_driver_sql() übergeben wurden.

Diese werden immer als Liste von Parametereinträgen gespeichert. Eine Liste mit einem Element entspricht einem Aufruf von cursor.execute() und eine Liste mit mehreren Elementen entspricht cursor.executemany(), außer im Fall von ExecuteStyle.INSERTMANYVALUES, die cursor.execute() ein- oder mehrmals verwendet.

Methode sqlalchemy.engine.default.DefaultExecutionContext.post_exec()¶

Wird nach der Ausführung einer kompilierten Anweisung aufgerufen.

Wenn eine kompilierte Anweisung an diesen ExecutionContext übergeben wurde, sollten die Datenmember last_insert_ids, last_inserted_params usw. nach Abschluss dieser Methode verfügbar sein.

Attribut sqlalchemy.engine.default.DefaultExecutionContext.postfetch_cols: util.generic_fn_descriptor[Sequence[Column[Any]] | None]¶: Eine Liste von Spaltenobjekten, für die ein serverseitiger Standardwert oder ein Inline-SQL-Ausdruckswert ausgelöst wurde. Gilt für Einfügungen und Aktualisierungen.

Methode sqlalchemy.engine.default.DefaultExecutionContext.pre_exec()¶

Wird vor der Ausführung einer kompilierten Anweisung aufgerufen.

Wenn eine kompilierte Anweisung an diesen ExecutionContext übergeben wurde, müssen die Datenmember statement und parameters nach Abschluss dieser Anweisung initialisiert sein.

Attribut sqlalchemy.engine.default.DefaultExecutionContext.prefetch_cols: util.generic_fn_descriptor[Sequence[Column[Any]] | None]¶: Eine Liste von Spaltenobjekten, für die ein klientseitiger Standardwert ausgelöst wurde. Gilt für Einfügungen und Aktualisierungen.

Attribut sqlalchemy.engine.default.DefaultExecutionContext.root_connection: Connection¶: Verbindungsobjekt, das die Quelle dieses ExecutionContext ist.

Klasse sqlalchemy.engine.ExecutionContext¶

Ein Botenobjekt für ein Dialekt, das einer einzelnen Ausführung entspricht.

Attribut sqlalchemy.engine.ExecutionContext.compiled: Compiled | None¶: Wenn an den Konstruktor übergeben, das ausgeführte SQLAlchemy-Objekt von sqlalchemy.engine.base.Compiled.

Attribut sqlalchemy.engine.ExecutionContext.connection: Connection¶: Verbindungsobjekt, das von Standardwertgeneratoren frei zur Ausführung von SQL verwendet werden kann. Diese Verbindung sollte auf dieselben zugrunde liegenden Verbindungs-/Transaktionsressourcen wie root_connection verweisen.

Methode sqlalchemy.engine.ExecutionContext.create_cursor() → DBAPICursor¶

Gibt einen neuen Cursor zurück, der aus der Verbindung dieses ExecutionContext generiert wurde.

Einige Dialekte möchten möglicherweise das Verhalten von connection.cursor() ändern, z. B. PostgreSQL, das einen serverseitigen PG-Cursor zurückgeben kann.

Attribut sqlalchemy.engine.ExecutionContext.cursor: DBAPICursor¶: DB-API-Cursor, der aus der Verbindung bezogen wurde

Attribut sqlalchemy.engine.ExecutionContext.dialect: Dialect¶: Dialekt, der diesen ExecutionContext erstellt hat.

Attribut sqlalchemy.engine.ExecutionContext.engine: Engine¶: Engine, mit der die Verbindung assoziiert ist

Attribut sqlalchemy.engine.ExecutionContext.execute_style: ExecuteStyle¶: Der Stil der DBAPI-Cursor-Methode, die zum Ausführen einer Anweisung verwendet wird.

Neu in Version 2.0.

Attribut sqlalchemy.engine.ExecutionContext.executemany: bool¶

True, wenn der Kontext eine Liste mit mehr als einem Parametersatz hat.

Historisch gesehen verknüpft dieses Attribut, ob cursor.execute() oder cursor.executemany() verwendet wird. Es kann nun auch bedeuten, dass „insertmanyvalues“ verwendet werden kann, was eine oder mehrere Aufrufe von cursor.execute() anzeigt.

Attribut sqlalchemy.engine.ExecutionContext.execution_options: _ExecuteOptions¶: Ausführungsoptionen, die mit der aktuellen Anweisungsausführung verbunden sind

Methode sqlalchemy.engine.ExecutionContext.fetchall_for_returning(cursor: DBAPICursor) → Sequence[Any]¶

Für ein RETURNING-Ergebnis wird cursor.fetchall() vom DBAPI-Cursor geliefert.

Dies ist ein dialektspezifischer Hook für Dialekte, die spezielle Überlegungen beim Aufruf von Zeilen haben, die für eine „RETURNING“-Anweisung geliefert werden. Die Standardimplementierung ist cursor.fetchall().

Dieser Hook wird derzeit nur von der insertmanyvalues-Funktion verwendet. Dialekte, die use_insertmanyvalues=True nicht setzen, müssen diesen Hook nicht berücksichtigen.

Neu in Version 2.0.10.

Methode sqlalchemy.engine.ExecutionContext.fire_sequence(seq: Sequence_SchemaItem, type_: Integer) → int¶: Gibt eine Sequence auf, ruft sie auf und gibt den nächsten Ganzzahlwert zurück

Methode sqlalchemy.engine.ExecutionContext.get_out_parameter_values(out_param_names: Sequence[str]) → Sequence[Any]¶

Gibt eine Sequenz von OUT-Parameterwerten aus einem Cursor zurück.

Für Dialekte, die OUT-Parameter unterstützen, wird diese Methode aufgerufen, wenn ein SQLCompiler-Objekt vorhanden ist, dessen Flag SQLCompiler.has_out_parameters gesetzt ist. Dieses Flag wird wiederum auf True gesetzt, wenn die Anweisung selbst BindParameter-Objekte mit dem Flag .isoutparam hat, die von der Methode SQLCompiler.visit_bindparam() verbraucht werden. Wenn der Dialekt-Compiler BindParameter-Objekte mit gesetztem .isoutparam erzeugt, die nicht von SQLCompiler.visit_bindparam() behandelt werden, sollte er dieses Flag explizit setzen.

Die Liste der Namen, die für jedes gebundene Parameter gerendert wurden, wird an die Methode übergeben. Die Methode sollte dann eine Sequenz von Werten zurückgeben, die den Parameterobjekten entsprechen. Im Gegensatz zu früheren SQLAlchemy-Versionen können die Werte die **Rohwerte** des DBAPI sein; der Ausführungskontext wendet den entsprechenden Typ-Handler basierend auf dem an, was in self.compiled.binds vorhanden ist, und aktualisiert die Werte. Das verarbeitete Wörterbuch wird dann über die Sammlung .out_parameters des Ergebnisobjekts verfügbar gemacht. Beachten Sie, dass SQLAlchemy 1.4 mehrere Arten von Ergebnisobjekten im Rahmen des 2.0-Übergangs hat.

Neu in Version 1.4: - hinzugefügt ExecutionContext.get_out_parameter_values(), das automatisch vom DefaultExecutionContext aufgerufen wird, wenn BindParameter-Objekte mit gesetztem Flag .isoutparam vorhanden sind. Dies ersetzt die Praxis, Out-Parameter innerhalb der nun entfernten Methode get_result_proxy() zu setzen.

Methode sqlalchemy.engine.ExecutionContext.get_rowcount() → int | None¶

Gibt den DBAPI-Wert cursor.rowcount zurück, oder in einigen Fällen einen interpretierten Wert.

Siehe CursorResult.rowcount für Details hierzu.

Methode sqlalchemy.engine.ExecutionContext.handle_dbapi_exception(e: BaseException) → None¶: Empfängt eine DBAPI-Ausnahme, die während der Ausführung, des Abrufs von Ergebnissen usw. aufgetreten ist.

Attribut sqlalchemy.engine.ExecutionContext.invoked_statement: Executable | None¶

Das Executable-Statement-Objekt, das ursprünglich übergeben wurde.

Dies sollte strukturell äquivalent zu compiled.statement sein, aber nicht unbedingt dasselbe Objekt, da im Falle eines Caching-Szenarios die kompilierte Form aus dem Cache extrahiert wurde.

Attribut sqlalchemy.engine.ExecutionContext.isinsert: bool¶: True, wenn die Anweisung ein INSERT ist.

Attribut sqlalchemy.engine.ExecutionContext.isupdate: bool¶: True, wenn die Anweisung ein UPDATE ist.

Methode sqlalchemy.engine.ExecutionContext.lastrow_has_defaults() → bool¶: Gibt True zurück, wenn die letzte Zeile eines INSERT oder UPDATE Inline- oder datenbankseitige Standardwerte enthielt.

Attribut sqlalchemy.engine.ExecutionContext.no_parameters: bool¶: True, wenn der Ausführungsstil keine Parameter verwendet

Attribut sqlalchemy.engine.ExecutionContext.parameters: _AnyMultiExecuteParams¶

Bindeparameter, die an die Methoden execute() oder exec_driver_sql() übergeben wurden.

Diese werden immer als Liste von Parametereinträgen gespeichert. Eine Liste mit einem Element entspricht einem Aufruf von cursor.execute() und eine Liste mit mehreren Elementen entspricht cursor.executemany(), außer im Fall von ExecuteStyle.INSERTMANYVALUES, die cursor.execute() ein- oder mehrmals verwendet.

Methode sqlalchemy.engine.ExecutionContext.post_exec() → None¶

Wird nach der Ausführung einer kompilierten Anweisung aufgerufen.

Wenn eine kompilierte Anweisung an diesen ExecutionContext übergeben wurde, sollten die Datenmember last_insert_ids, last_inserted_params usw. nach Abschluss dieser Methode verfügbar sein.

Attribut sqlalchemy.engine.ExecutionContext.postfetch_cols: util.generic_fn_descriptor[Sequence[Column[Any]] | None]¶: Eine Liste von Spaltenobjekten, für die ein serverseitiger Standardwert oder ein Inline-SQL-Ausdruckswert ausgelöst wurde. Gilt für Einfügungen und Aktualisierungen.

Methode sqlalchemy.engine.ExecutionContext.pre_exec() → None¶

Wird vor der Ausführung einer kompilierten Anweisung aufgerufen.

Wenn eine kompilierte Anweisung an diesen ExecutionContext übergeben wurde, müssen die Datenmember statement und parameters nach Abschluss dieser Anweisung initialisiert sein.

Attribut sqlalchemy.engine.ExecutionContext.prefetch_cols: util.generic_fn_descriptor[Sequence[Column[Any]] | None]¶: Eine Liste von Spaltenobjekten, für die ein klientseitiger Standardwert ausgelöst wurde. Gilt für Einfügungen und Aktualisierungen.

Attribut sqlalchemy.engine.ExecutionContext.root_connection: Connection¶: Verbindungsobjekt, das die Quelle dieses ExecutionContext ist.

Attribut sqlalchemy.engine.ExecutionContext.statement: str¶: String-Version der auszuführenden Anweisung. Wird entweder dem Konstruktor übergeben oder muss zum Zeitpunkt des Abschlusses von pre_exec() aus dem sql.Compiled-Objekt erstellt werden.

Klasse sqlalchemy.sql.compiler.ExpandedState¶

repräsentiert den Zustand, der bei der Erzeugung von „erweiterten“ und „post-compile“-gebundenen Parametern für eine Anweisung verwendet wird.

„Expanded“ Parameter sind Parameter, die zur Laufzeit der Anweisung generiert werden, um einer Anzahl übergebener Parameter zu entsprechen. Das prominenteste Beispiel sind die einzelnen Elemente innerhalb eines IN-Ausdrucks.

„Post-Compile“-Parameter sind Parameter, bei denen der SQL-Literalwert zur Ausführungszeit in die SQL-Anweisung gerendert wird, anstatt als separate Parameter an den Treiber übergeben zu werden.

Um eine ExpandedState-Instanz zu erstellen, verwenden Sie die Methode SQLCompiler.construct_expanded_state() für jede SQLCompiler-Instanz.

Mitglieder

additional_parameters, parameter_expansion, parameters, positional_parameters, positiontup, processors, statement

Klassensignatur

class sqlalchemy.sql.compiler.ExpandedState (builtins.tuple)

Attribut sqlalchemy.sql.compiler.ExpandedState.additional_parameters¶: Synonym für ExpandedState.parameters.

Attribut sqlalchemy.sql.compiler.ExpandedState.parameter_expansion: Mapping[str, List[str]]¶: Mapping, das die Zwischenverbindung vom ursprünglichen Parameternamen zur Liste der „erweiterten“ Parameternamen darstellt, für Parameter, die erweitert wurden.

Attribut sqlalchemy.sql.compiler.ExpandedState.parameters: _CoreSingleExecuteParams¶

Parameter-Dictionary mit vollständig erweiterten Parametern.

Für eine Anweisung, die benannte Parameter verwendet, wird dieses Wörterbuch genau den Namen in der Anweisung entsprechen. Für eine Anweisung, die positionsbezogene Parameter verwendet, gibt ExpandedState.positional_parameters ein Tupel mit dem positionsbezogenen Parameter-Set zurück.

Attribut sqlalchemy.sql.compiler.ExpandedState.positional_parameters¶: Tupel von positionsbezogenen Parametern für Anweisungen, die mit einem positionsbezogenen Parametertyp kompiliert wurden.

Attribut sqlalchemy.sql.compiler.ExpandedState.positiontup: Sequence[str] | None¶: Sequenz von String-Namen, die die Reihenfolge der positionsbezogenen Parameter angeben

Attribut sqlalchemy.sql.compiler.ExpandedState.processors: Mapping[str, _BindProcessorType[Any]]¶: Zuordnung von gebundenen Wertprozessoren

Attribut sqlalchemy.sql.compiler.ExpandedState.statement: str¶: String-SQL-Anweisung mit vollständig erweiterten Parametern

Klasse sqlalchemy.sql.compiler.GenericTypeCompiler¶

Mitglieder

ensure_kwarg

Klassensignatur

class sqlalchemy.sql.compiler.GenericTypeCompiler (sqlalchemy.sql.compiler.TypeCompiler)

Attribut sqlalchemy.sql.compiler.GenericTypeCompiler.ensure_kwarg: str = 'visit_\\w+'¶

geerbt vom TypeCompiler.ensure_kwarg Attribut von TypeCompiler

Ein regulärer Ausdruck, der Methodennamen angibt, für die die Methode **kw Argumente akzeptieren soll.

Die Klasse scannt nach Methoden mit dem Namensmuster und dekoriert sie bei Bedarf, um sicherzustellen, dass **kw Parameter akzeptiert werden.

Klasse sqlalchemy.log.Identified¶

Klasse sqlalchemy.sql.compiler.IdentifierPreparer¶

Mitglieder

__init__(), format_column(), format_label_name(), format_schema(), format_table(), format_table_seq(), quote(), quote_identifier(), quote_schema(), schema_for_object, unformat_identifiers(), validate_sql_phrase()

Behandelt das Zitieren und Groß-/Kleinschreibung von Bezeichnern basierend auf Optionen.

Methode sqlalchemy.sql.compiler.IdentifierPreparer.__init__(dialect, initial_quote='"', final_quote=None, escape_quote='"', quote_case_sensitive_collations=True, omit_schema=False)¶

Erstellt ein neues IdentifierPreparer Objekt.

initial_quote: Zeichen, das einen abgegrenzten Bezeichner beginnt.
final_quote: Zeichen, das einen abgegrenzten Bezeichner beendet. Standardmäßig initial_quote.
omit_schema: Verhindert das Voranstellen des Schemanamens. Nützlich für Datenbanken, die keine Schemata unterstützen.

Methode sqlalchemy.sql.compiler.IdentifierPreparer.format_column(column, use_table=False, name=None, table_name=None, use_schema=False, anon_map=None)¶: Bereitet einen zitierten Spaltennamen vor.

Methode sqlalchemy.sql.compiler.IdentifierPreparer.format_label_name(name, anon_map=None)¶: Bereitet einen zitierten Spaltennamen vor.

Methode sqlalchemy.sql.compiler.IdentifierPreparer.format_schema(name)¶: Bereitet einen zitierten Schemanamen vor.

Methode sqlalchemy.sql.compiler.IdentifierPreparer.format_table(table, use_schema=True, name=None)¶: Bereitet einen zitierten Tabellen- und Schemanamen vor.

Methode sqlalchemy.sql.compiler.IdentifierPreparer.format_table_seq(table, use_schema=True)¶: Formatiert Tabellenname und Schema als Tupel.

Methode sqlalchemy.sql.compiler.IdentifierPreparer.quote(ident: str, force: Any | None = None) → str¶

Ein Bezeichner wird bedingt zitiert.

Der Bezeichner wird zitiert, wenn er ein reserviertes Wort ist, Anführungszeichen erfordernde Zeichen enthält oder eine Instanz von quoted_name ist, die quote auf True gesetzt hat.

Unterklassen können dies überschreiben, um datenbankspezifisches Verhalten für die Anführungszeichen von Bezeichnernamen bereitzustellen.

Parameter:

ident¶ – String-Bezeichner
force¶ –
ungenutzt

Veraltet seit Version 0.9: Der Parameter IdentifierPreparer.quote.force ist veraltet und wird in einer zukünftigen Version entfernt. Dieses Flag hat keine Auswirkungen auf das Verhalten der Methode IdentifierPreparer.quote(); siehe quoted_name.

Methode sqlalchemy.sql.compiler.IdentifierPreparer.quote_identifier(value: str) → str¶

Zitiert einen Bezeichner.

Unterklassen sollten dies überschreiben, um datenbankspezifisches Verhalten für die Anführungszeichen bereitzustellen.

Methode sqlalchemy.sql.compiler.IdentifierPreparer.quote_schema(schema: str, force: Any | None = None) → str¶

Zitiert einen Schemanamen bedingt.

Der Name wird zitiert, wenn er ein reserviertes Wort ist, Anführungszeichen erfordernde Zeichen enthält oder eine Instanz von quoted_name ist, die quote auf True gesetzt hat.

Unterklassen können dies überschreiben, um datenbankspezifisches Verhalten für die Anführungszeichen von Schemanamen bereitzustellen.

Parameter:

schema¶ – String-Schemaname
force¶ –
ungenutzt

Veraltet seit Version 0.9: Der Parameter IdentifierPreparer.quote_schema.force ist veraltet und wird in einer zukünftigen Version entfernt. Dieses Flag hat keine Auswirkungen auf das Verhalten der Methode IdentifierPreparer.quote(); siehe quoted_name.

Attribut sqlalchemy.sql.compiler.IdentifierPreparer.schema_for_object: _SchemaForObjectCallable = operator.attrgetter('schema')¶

Gibt das .schema-Attribut für ein Objekt zurück.

Für den Standard-IdentifierPreparer ist das Schema eines Objekts immer der Wert des Attributs „.schema“. Wenn der Preparer durch einen mit einer nicht leeren schema_translate_map ersetzt wird, wird der Wert des Attributs „.schema“ als Symbol gerendert, das nach der Kompilierung in einen echten Schemanamen aus der Zuordnung konvertiert wird.

Methode sqlalchemy.sql.compiler.IdentifierPreparer.unformat_identifiers(identifiers)¶: Entpackt „schema.table.column“-ähnliche Zeichenfolgen in Komponenten.

Methode sqlalchemy.sql.compiler.IdentifierPreparer.validate_sql_phrase(element, reg)¶

Filter für Schlüsselwortsequenzen.

Ein Filter für Elemente, die für Schlüsselwortsequenzen bestimmt sind, wie z. B. „INITIALLY“, „INITIALLY DEFERRED“ usw. Es dürfen keine Sonderzeichen vorhanden sein.

Neu in Version 1.3.

Klasse sqlalchemy.sql.compiler.SQLCompiler¶

Standardimplementierung von Compiled.

Kompiliert ClauseElement-Objekte in SQL-Zeichenfolgen.

Klassensignatur

Klasse sqlalchemy.sql.compiler.SQLCompiler (sqlalchemy.sql.compiler.Compiled)

methode sqlalchemy.sql.compiler.SQLCompiler.__init__(dialect: Dialect, statement: ClauseElement | None, cache_key: CacheKey | None = None, column_keys: Sequence[str] | None = None, for_executemany: bool = False, linting: Linting = Linting.NO_LINTING, _supporting_against: SQLCompiler | None = None, **kwargs: Any)¶

Erzeugt ein neues SQLCompiler Objekt.

Parameter:

dialect¶ – Zu verwendende Dialect
statement¶ – Zu kompilierendes ClauseElement
column_keys¶ – eine Liste von Spaltennamen, die in eine INSERT- oder UPDATE-Anweisung kompiliert werden sollen.
for_executemany¶ – ob INSERT / UPDATE-Anweisungen erwarten sollen, dass sie im „executemany“-Stil aufgerufen werden. Dies kann beeinflussen, wie die Anweisung die Werte von Standardwerten und Autoincrement / Sequenzen usw. zurückgeben soll. Abhängig vom verwendeten Backend und Treiber kann die Unterstützung für den Abruf dieser Werte deaktiviert sein, was bedeutet, dass SQL-Ausdrücke inline gerendert werden können, RETURNING möglicherweise nicht gerendert wird usw.
kwargs¶ – zusätzliche Schlüsselwortargumente, die vom Superclass verarbeitet werden.

attribut sqlalchemy.sql.compiler.SQLCompiler.ansi_bind_rules: bool = False¶: SQL 92 erlaubt keine Bindungsparameter in der Spaltenklausel eines SELECT und auch keine mehrdeutigen Ausdrücke wie „? = ?“. Eine Compiler-Unterklasse kann dieses Flag auf False setzen, wenn der Zieltreiber/die Zieldatenbank dies erzwingt.

attribut sqlalchemy.sql.compiler.SQLCompiler.bind_names: Dict[BindParameter[Any], str]¶: Ein Wörterbuch von BindParameter-Instanzen zu „kompilierten“ Namen, die tatsächlich in der generierten SQL vorhanden sind.

attribut sqlalchemy.sql.compiler.SQLCompiler.bindname_escape_characters: ClassVar[Mapping[str, str]] = {' ': '_', '%': 'P', '(': 'A', ')': 'Z', '.': '_', ':': 'C', '[': '_', ']': '_'}¶

Eine Zuordnung (z. B. ein Wörterbuch oder etwas Ähnliches), die eine Nachschlagefunktion von Zeichen enthält, die nach Ersetzung durch Ersatzzeichen angewendet wird, auf alle „Bindungsnamen“ angewendet wird, die in SQL-Anweisungen verwendet werden, als eine Form des „Escaping“; die angegebenen Zeichen werden vollständig durch das „Ersatz“-Zeichen ersetzt, wenn sie in der SQL-Anweisung gerendert werden, und eine ähnliche Übersetzung wird auf die eingehenden Namen angewendet, die in Parameterwörterbüchern verwendet werden, die an Methoden wie Connection.execute() übergeben werden.

Dies ermöglicht es, dass benannte Bindungsparameter, die in bindparam() und anderen Konstrukten verwendet werden, beliebige Zeichen enthalten können, ohne sich um Zeichen kümmern zu müssen, die auf der Ziel-Datenbank überhaupt nicht zulässig sind.

Drittanbieter-Dialekte können hier ihr eigenes Wörterbuch einrichten, um die Standardzuordnung zu ersetzen, was sicherstellt, dass die bestimmten Zeichen in der Zuordnung niemals in einem benannten Bindungsparameter erscheinen.

Das Wörterbuch wird zur **Klassen-Erstellungszeit** ausgewertet und kann daher nicht zur Laufzeit geändert werden; es muss in der Klasse vorhanden sein, wenn die Klasse zuerst deklariert wird.

Beachten Sie, dass für Dialekte, die zusätzliche Regeln für Bindungsparameter haben, wie z. B. zusätzliche Einschränkungen für führende Zeichen, die Methode SQLCompiler.bindparam_string() möglicherweise erweitert werden muss. Sehen Sie sich den cx_Oracle-Compiler als Beispiel dafür an.

Neu in Version 2.0.0rc1.

attribut sqlalchemy.sql.compiler.SQLCompiler.binds: Dict[str, BindParameter[Any]]¶: Ein Wörterbuch von Bindungsparameterschlüsseln zu BindParameter-Instanzen.

attribut sqlalchemy.sql.compiler.SQLCompiler.bindtemplate: str¶: Vorlage zur Darstellung von Bindungsparametern basierend auf dem Parametertyp.

attribut sqlalchemy.sql.compiler.SQLCompiler.compilation_bindtemplate: str¶: Vorlage, die vom Compiler verwendet wird, um Parameter vor der Anwendung des Positions-Parametertyps zu rendern.

methode sqlalchemy.sql.compiler.SQLCompiler.construct_expanded_state(params: _CoreSingleExecuteParams | None = None, escape_names: bool = True) → ExpandedState¶

Gibt einen neuen ExpandedState für einen gegebenen Parametersatz zurück.

Für Abfragen, die „expandierende“ oder andere spät gerenderte Parameter verwenden, bietet diese Methode sowohl den finalisierten SQL-String als auch die Parameter, die für einen bestimmten Parametersatz verwendet würden.

Neu in Version 2.0.0rc1.

methode sqlalchemy.sql.compiler.SQLCompiler.construct_params(params: _CoreSingleExecuteParams | None = None, extracted_parameters: Sequence[BindParameter[Any]] | None = None, escape_names: bool = True, _group_number: int | None = None, _check: bool = True, _no_postcompile: bool = False) → _MutableCoreSingleExecuteParams¶: Gibt ein Wörterbuch von Bindungsparameterschlüsseln und -werten zurück.

attribut sqlalchemy.sql.compiler.SQLCompiler.current_executable¶

Gibt die aktuelle „ausführbare“ Anweisung zurück, die kompiliert wird.

Dies ist derzeit das Select-, Insert-, Update-, Delete-, CompoundSelect-Objekt, das kompiliert wird. Insbesondere wird es der self.stack Liste von Elementen zugewiesen.

Wenn eine Anweisung wie die oben genannte kompiliert wird, wird sie normalerweise auch dem Attribut .statement des Compiler Objekts zugewiesen. Alle SQL-Konstrukte sind jedoch letztendlich verschachtelbar, und dieses Attribut sollte niemals von einer visit_ Methode abgefragt werden, da nicht garantiert ist, dass es zugewiesen ist oder mit der aktuell kompilierten Anweisung übereinstimmt.

Neu in Version 1.3.21: Für die Kompatibilität mit früheren Versionen verwenden Sie das folgende Rezept

statement = getattr(self, "current_executable", False)
if statement is False:
    statement = self.stack[-1]["selectable"]

Stellen Sie für Versionen 1.4 und höher sicher, dass nur .current_executable verwendet wird; das Format von „self.stack“ kann sich ändern.

methode sqlalchemy.sql.compiler.SQLCompiler.default_from()¶

Wird aufgerufen, wenn eine SELECT-Anweisung keine FROM-Objekte hat und keine FROM-Klausel angehängt werden soll.

Gibt der Oracle-Datenbank die Möglichkeit, ein FROM DUAL an die Zeichenkettenausgabe anzuhängen.

methode sqlalchemy.sql.compiler.SQLCompiler.delete_extra_from_clause(update_stmt, from_table, extra_froms, from_hints, **kw)¶

Stellt einen Hook zur Verfügung, um die Generierung einer DELETE..FROM-Klausel zu überschreiben.

Dies kann beispielsweise zur Implementierung von DELETE..USING verwendet werden.

MySQL und MSSQL überschreiben dies.

methode sqlalchemy.sql.compiler.SQLCompiler.delete_limit_clause(delete_stmt)¶: Stellt einen Hook für MySQL bereit, um LIMIT zu DELETE hinzuzufügen.

attribut sqlalchemy.sql.compiler.SQLCompiler.effective_returning¶

Die effektiven „returning“-Spalten für INSERT, UPDATE oder DELETE.

Dies sind entweder die sogenannten „impliziten returning“-Spalten, die vom Compiler dynamisch berechnet werden, oder die, die basierend auf dem Inhalt von self.statement._returning vorhanden sind (expandiert in einzelne Spalten mithilfe des Attributs ._all_selected_columns), d. h. diejenigen, die explizit mithilfe der Methode UpdateBase.returning() gesetzt wurden.

Neu in Version 2.0.

attribut sqlalchemy.sql.compiler.SQLCompiler.escaped_bind_names: util.immutabledict[str, str] = {}¶: Spätes Escaping von benannten Bindungsparametern, das bei der Suche im Parameterwörterbuch in den ursprünglichen Namen umgewandelt werden muss.

methode sqlalchemy.sql.compiler.SQLCompiler.get_select_precolumns(select, **kw)¶: Wird beim Erstellen einer SELECT -Anweisung aufgerufen, die Position ist kurz vor der Spaltenliste.

methode sqlalchemy.sql.compiler.SQLCompiler.group_by_clause(select, **kw)¶: Ermöglicht Dialekten die Anpassung der GROUP BY-Darstellung.

attribut sqlalchemy.sql.compiler.SQLCompiler.has_out_parameters = False¶: Wenn True, dann gibt es BindParameter()-Objekte, bei denen das Flag isoutparam gesetzt ist.

attribut sqlalchemy.sql.compiler.SQLCompiler.implicit_returning: Sequence[ColumnElement[Any]] | None = None¶: Liste von „impliziten“ Rückgabespalten für eine Top-Level-INSERT- oder UPDATE-Anweisung, die verwendet werden, um neu generierte Werte von Spalten zu empfangen.

Neu in Version 2.0: implicit_returning ersetzt die vorherige returning Sammlung, die keine verallgemeinerte RETURNING-Sammlung war, sondern tatsächlich spezifisch für die „implizite returning“-Funktion war.

attribut sqlalchemy.sql.compiler.SQLCompiler.insert_prefetch: Sequence[Column[Any]] = ()¶: Liste von Spalten, für die Standardwerte vor einer INSERT-Operation ausgewertet werden sollen.

attribut sqlalchemy.sql.compiler.SQLCompiler.insert_single_values_expr¶: Wenn eine INSERT-Anweisung mit einem einzelnen Parametersatz in einem VALUES-Ausdruck kompiliert wird, wird die Zeichenkette hier zugewiesen, wo sie für INSERT-Batching-Schemata verwendet werden kann, um den VALUES-Ausdruck neu zu schreiben.

Neu seit Version 1.3.8.

Geändert in Version 2.0: Diese Sammlung wird von den integrierten Dialekten von SQLAlchemy nicht mehr verwendet, zugunsten der derzeit internen Sammlung _insertmanyvalues, die nur von SQLCompiler verwendet wird.

attribut sqlalchemy.sql.compiler.SQLCompiler.isupdate: bool = False¶: Klassenebene Standardwerte, die auf Instanzebene festgelegt werden können, um zu definieren, ob diese Compiled-Instanz INSERT/UPDATE/DELETE darstellt.

attribut sqlalchemy.sql.compiler.SQLCompiler.literal_execute_params: FrozenSet[BindParameter[Any]] = frozenset({})¶: BindParameter-Objekte, die zur Laufzeit der Anweisung als Literalwerte gerendert werden.

methode sqlalchemy.sql.compiler.SQLCompiler.order_by_clause(select, **kw)¶: Ermöglicht Dialekten die Anpassung der ORDER BY-Darstellung.

attribut sqlalchemy.sql.compiler.SQLCompiler.params¶: Gibt das in dieses kompilierte Objekt eingebettete Bindungsparameterwörterbuch zurück, für die Werte, die vorhanden sind.

Siehe auch

Wie rendere ich SQL-Ausdrücke als Zeichenketten, möglicherweise mit eingebetteten Bindungsparametern? - Enthält ein Anwendungsbeispiel für Debugging-Zwecke.

attribut sqlalchemy.sql.compiler.SQLCompiler.positiontup: Liste[str] | None = None¶

Für eine kompilierte Konstruktion, die einen Positions-Parametrisierungsstil verwendet, ist dies eine Sequenz von Zeichenketten, die die Namen der gebundenen Parameter in der Reihenfolge angeben.

Dies wird verwendet, um gebundene Parameter in ihrer korrekten Reihenfolge zu rendern, und wird mit dem Compiled.params-Dictionary kombiniert, um Parameter zu rendern.

Diese Sequenz enthält immer den unescaped Namen der Parameter.

Siehe auch

Wie rendere ich SQL-Ausdrücke als Zeichenketten, möglicherweise mit eingebetteten Bindungsparametern? - Enthält ein Anwendungsbeispiel für Debugging-Zwecke.

attribut sqlalchemy.sql.compiler.SQLCompiler.post_compile_params: Frozenset[BindParameter[Any]] = frozenset({})¶: Bindparameter-Objekte, die als gebundene Parameterplatzhalter zur Ausführungszeit der Anweisung gerendert werden.

attribut sqlalchemy.sql.compiler.SQLCompiler.postfetch: Liste[Spalte[Any]] | None¶: Liste von Spalten, die nach INSERT oder UPDATE nachgeholt werden können, um vom Server aktualisierte Werte zu erhalten.

attribut sqlalchemy.sql.compiler.SQLCompiler.postfetch_lastrowid = False¶: Wenn True und dies ein INSERT ist, verwende cursor.lastrowid, um result.inserted_primary_key zu füllen.

methode sqlalchemy.sql.compiler.SQLCompiler.render_literal_value(value, type_)¶

Rendert den Wert eines gebundenen Parameters als umschlossenes Literal.

Dies wird für Anweisungsabschnitte verwendet, die keine gebundenen Parameter auf dem Ziel-Treiber/Datenbank akzeptieren.

Dies sollte von Unterklassen unter Verwendung der Quoting-Dienste des DBAPI implementiert werden.

attribut sqlalchemy.sql.compiler.SQLCompiler.render_table_with_column_in_update_from: bool = False¶: Klassenweit auf True setzen, um anzuzeigen, dass die SET-Klausel in einer UPDATE-Anweisung mit mehreren Tabellen Spalten mit dem Tabellennamen qualifizieren sollte (d.h. nur MySQL).

attribut sqlalchemy.sql.compiler.SQLCompiler.returning¶: Abwärtskompatibilität; gibt die effektive_returning-Sammlung zurück.

attribut sqlalchemy.sql.compiler.SQLCompiler.returning_precedes_values: bool = False¶: Klassenweit auf True setzen, um RETURNING-Klauseln vor der VALUES- oder WHERE-Klausel zu generieren (d.h. MSSQL).

attribut sqlalchemy.sql.compiler.SQLCompiler.sql_compiler¶

attribut sqlalchemy.sql.compiler.SQLCompiler.stack: Liste[_CompilerStackEntry]¶: Hauptanweisungen wie SELECT, INSERT, UPDATE, DELETE werden auf diesem Stack mit einem Eingabeeintrag verfolgt.

attribut sqlalchemy.sql.compiler.SQLCompiler.translate_select_structure: Any = None¶: Wenn nicht None, sollte ein aufrufbares Objekt sein, das (select_stmt, **kw) akzeptiert und ein select-Objekt zurückgibt. Dies wird für strukturelle Änderungen verwendet, hauptsächlich um LIMIT/OFFSET-Schemata unterzubringen.

methode sqlalchemy.sql.compiler.SQLCompiler.update_from_clause(update_stmt, from_table, extra_froms, from_hints, **kw)¶

Stellt einen Hook bereit, um die Generierung einer UPDATE..FROM-Klausel zu überschreiben.

MySQL und MSSQL überschreiben dies.

methode sqlalchemy.sql.compiler.SQLCompiler.update_limit_clause(update_stmt)¶: Stellt einen Hook für MySQL bereit, um LIMIT zu UPDATE hinzuzufügen.

attribut sqlalchemy.sql.compiler.SQLCompiler.update_prefetch: Sequenz[Spalte[Any]] = ()¶: Liste von Spalten, für die onupdate-Standardwerte vor einer UPDATE-Ausführung ausgewertet werden sollen.

methode sqlalchemy.sql.compiler.SQLCompiler.update_tables_clause(update_stmt, from_table, extra_froms, **kw)¶

Stellt einen Hook bereit, um die anfängliche Tabellenklausel in einer UPDATE-Anweisung zu überschreiben.

MySQL überschreibt dies.

methode sqlalchemy.sql.compiler.SQLCompiler.visit_override_binds(override_binds, **kw)¶

Kompiliert die verschachtelten Elemente eines _OverrideBinds mit ausgetauschten Bind-Parametern.

Normalerweise wird erwartet, dass _OverrideBinds nicht kompiliert wird; es ist dafür gedacht, wenn eine bereits gecachte Anweisung verwendet werden soll, die Kompilierung bereits durchgeführt wurde und nur die gebundenen Parameter zur Ausführungszeit ausgetauscht werden sollen.

Es gibt jedoch Testfälle, die dieses Objekt untersuchen, und zusätzlich ist bekannt, dass der ORM Subquery Loader Ausdrücke, die diese Konstruktion enthalten, in neue Abfragen einspeist (entdeckt in #11173), so dass es auch zur Kompilierungszeit das Richtige tun muss.

klasse sqlalchemy.sql.compiler.StrSQLCompiler¶

Eine SQLCompiler-Unterklasse, die eine kleine Auswahl nicht standardmäßiger SQL-Funktionen zulässt, um sie als Zeichenkettenwert zu rendern.

Der StrSQLCompiler wird aufgerufen, wenn ein Core-Ausdruckselement direkt als Zeichenkette behandelt wird, ohne die Methode ClauseElement.compile() aufzurufen. Er kann eine begrenzte Anzahl von nicht standardmäßigen SQL-Konstrukten rendern, um eine einfache Stringifizierung zu unterstützen. Für umfangreichere benutzerdefinierte oder dialektspezifische SQL-Konstrukte ist es jedoch notwendig, ClauseElement.compile() direkt zu verwenden.

Siehe auch

Wie rendere ich SQL-Ausdrücke als Strings, möglicherweise mit eingebetteten gebundenen Parametern?

Mitglieder

delete_extra_from_clause(), update_from_clause()

Klassensignatur

Klasse sqlalchemy.sql.compiler.StrSQLCompiler (sqlalchemy.sql.compiler.SQLCompiler)

methode sqlalchemy.sql.compiler.StrSQLCompiler.delete_extra_from_clause(update_stmt, from_table, extra_froms, from_hints, **kw)¶

Stellt einen Hook zur Verfügung, um die Generierung einer DELETE..FROM-Klausel zu überschreiben.

Dies kann beispielsweise zur Implementierung von DELETE..USING verwendet werden.

MySQL und MSSQL überschreiben dies.

methode sqlalchemy.sql.compiler.StrSQLCompiler.update_from_clause(update_stmt, from_table, extra_froms, from_hints, **kw)¶

Stellt einen Hook bereit, um die Generierung einer UPDATE..FROM-Klausel zu überschreiben.

MySQL und MSSQL überschreiben dies.

klasse sqlalchemy.engine.AdaptedConnection¶

Schnittstelle eines angepassten Verbindungsobjekts zur Unterstützung des DBAPI-Protokolls.

Wird von asyncio-Dialekten verwendet, um eine PEP-249-Fassade im synchronen Stil über die asyncio-Verbindungs-/Cursor-API des Treibers bereitzustellen.

Mitglieder

driver_connection, run_async()

Neu in Version 1.4.24.

attribut sqlalchemy.engine.AdaptedConnection.driver_connection¶: Das Verbindungsobjekt, wie es vom Treiber nach einer Verbindung zurückgegeben wird.

methode sqlalchemy.engine.AdaptedConnection.run_async(fn: Callable[[Any], Awaitable[_T]]) → _T¶

Führt das von der gegebenen Funktion zurückgegebeneAwaitable aus, das die rohe asyncio-Treiberverbindung übergeben bekommt.

Dies wird verwendet, um awaitable-only Methoden der Treiberverbindung im Kontext einer "synchronen" Methode aufzurufen, wie z.B. einem Connection-Pool-Ereignishandler.

Z. B.

engine = create_async_engine(...)


@event.listens_for(engine.sync_engine, "connect")
def register_custom_types(
    dbapi_connection,  # ...
):
    dbapi_connection.run_async(
        lambda connection: connection.set_type_codec(
            "MyCustomType", encoder, decoder, ...
        )
    )

Neu in Version 1.4.30.

Siehe auch

Verwendung von nur awaitable Treiber-Methoden im Connection Pool und anderen Events

SQLAlchemy 2.0 Dokumentation

SQLAlchemy 2.0 Dokumentation

SQLAlchemy Core

Projektversionen

Core Internals¶