Datenbankobjekte spiegeln¶

Ein Table-Objekt kann angewiesen werden, Informationen über sich selbst aus dem entsprechenden Datenbank-Schemaobjekt zu laden, das bereits in der Datenbank vorhanden ist. Dieser Vorgang wird als Spiegelung bezeichnet. Im einfachsten Fall müssen Sie nur den Tabellennamen, ein MetaData-Objekt und das Argument autoload_with angeben.

>>> messages = Table("messages", metadata_obj, autoload_with=engine)
>>> [c.name for c in messages.columns]
['message_id', 'message_name', 'date']

Die obige Operation verwendet die angegebene Engine, um die Datenbank nach Informationen über die messages-Tabelle abzufragen, und generiert dann Column-, ForeignKey- und andere Objekte, die diesen Informationen entsprechen, so als ob das Table-Objekt von Hand in Python erstellt worden wäre.

Wenn Tabellen gespiegelt werden und eine gegebene Tabelle über einen Fremdschlüssel auf eine andere verweist, wird ein zweites Table-Objekt innerhalb des MetaData-Objekts erstellt, das die Verbindung darstellt. Angenommen, die Tabelle shopping_cart_items verweist auf eine Tabelle namens shopping_carts. Das Spiegeln der Tabelle shopping_cart_items hat zur Folge, dass auch die Tabelle shopping_carts geladen wird.

>>> shopping_cart_items = Table("shopping_cart_items", metadata_obj, autoload_with=engine)
>>> "shopping_carts" in metadata_obj.tables
True

Das MetaData-Objekt hat ein interessantes „Singleton-ähnliches“ Verhalten, sodass, wenn Sie beide Tabellen einzeln anfordern, MetaData sicherstellt, dass für jeden eindeutigen Tabellennamen genau ein Table-Objekt erstellt wird. Der Konstruktor Table gibt Ihnen tatsächlich das bereits vorhandene Table-Objekt zurück, wenn bereits eines mit diesem Namen existiert. Wie unten gezeigt, können wir auf die bereits generierte Tabelle shopping_carts zugreifen, indem wir sie einfach benennen.

shopping_carts = Table("shopping_carts", metadata_obj)

Selbstverständlich ist es ratsam, autoload_with=engine mit der obigen Tabelle zu verwenden, auch wenn sie bereits existiert. Dies stellt sicher, dass die Attribute der Tabelle geladen werden, falls sie noch nicht geladen wurden. Der Ladevorgang wird nur für die Tabelle durchgeführt, wenn sie noch nicht geladen wurde; sobald sie geladen ist, werden neue Aufrufe von Table mit demselben Namen keine Spiegelungsabfragen mehr ausgeben.

Überschreiben gespiegelter Spalten¶

Einzelne Spalten können beim Spiegeln von Tabellen mit expliziten Werten überschrieben werden; dies ist nützlich, um benutzerdefinierte Datentypen, Einschränkungen wie Primärschlüssel, die möglicherweise nicht in der Datenbank konfiguriert sind, usw. anzugeben.

>>> mytable = Table(
...     "mytable",
...     metadata_obj,
...     Column(
...         "id", Integer, primary_key=True
...     ),  # override reflected 'id' to have primary key
...     Column("mydata", Unicode(50)),  # override reflected 'mydata' to be Unicode
...     # additional Column objects which require no change are reflected normally
...     autoload_with=some_engine,
... )

Siehe auch

Arbeiten mit benutzerdefinierten Typen und Spiegelung - zeigt, wie die obige Technik zum Überschreiben von Spalten auf die Verwendung benutzerdefinierter Datentypen bei der Tabellenspiegelung angewendet wird.

Ansichten spiegeln¶

Das Spiegelungssystem kann auch Ansichten spiegeln. Die grundlegende Verwendung ist dieselbe wie bei einer Tabelle.

my_view = Table("some_view", metadata, autoload_with=engine)

Oben ist my_view ein Table-Objekt mit Column-Objekten, die die Namen und Typen jeder Spalte innerhalb der Ansicht „some_view“ darstellen.

Normalerweise ist es gewünscht, mindestens eine Primärschlüsseleinschränkung beim Spiegeln einer Ansicht zu haben, wenn nicht sogar Fremdschlüssel. Die Spiegelung von Ansichten extrapoliert diese Einschränkungen nicht.

Verwenden Sie hierfür die „Überschreibungstechnik“ und geben Sie explizit an, welche Spalten Teil des Primärschlüssels sind oder Fremdschlüsseleinschränkungen aufweisen.

my_view = Table(
    "some_view",
    metadata,
    Column("view_id", Integer, primary_key=True),
    Column("related_thing", Integer, ForeignKey("othertable.thing_id")),
    autoload_with=engine,
)

Alle Tabellen auf einmal spiegeln¶

Das MetaData-Objekt kann auch eine Liste von Tabellen abrufen und den vollständigen Satz spiegeln. Dies wird durch die Methode reflect() erreicht. Nach deren Aufruf sind alle gefundenen Tabellen im Wörterbuch der Tabellen des MetaData-Objekts vorhanden.

metadata_obj = MetaData()
metadata_obj.reflect(bind=someengine)
users_table = metadata_obj.tables["users"]
addresses_table = metadata_obj.tables["addresses"]

metadata.reflect() bietet auch eine praktische Möglichkeit, alle Zeilen in einer Datenbank zu löschen oder zu bereinigen.

metadata_obj = MetaData()
metadata_obj.reflect(bind=someengine)
with someengine.begin() as conn:
    for table in reversed(metadata_obj.sorted_tables):
        conn.execute(table.delete())

Tabellen aus anderen Schemas spiegeln¶

Der Abschnitt Angabe des Schema-Namens führt das Konzept von Tabellenschemata ein, die Namensräume innerhalb einer Datenbank sind, die Tabellen und andere Objekte enthalten und die explizit angegeben werden können. Das „Schema“ für ein Table-Objekt sowie für andere Objekte wie Ansichten, Indizes und Sequenzen kann mithilfe des Parameters Table.schema konfiguriert werden, und auch als Standard-Schema für ein MetaData-Objekt mithilfe des Parameters MetaData.schema.

Die Verwendung dieses Schema-Parameters beeinflusst direkt, wo die Tabellenspiegelungsfunktion nach Objekten sucht, wenn sie zur Spiegelung von Objekten aufgefordert wird. Angenommen, ein MetaData-Objekt ist mit einem Standard-Schema-Namen „project“ über seinen Parameter MetaData.schema konfiguriert.

>>> metadata_obj = MetaData(schema="project")

Die MetaData.reflect()-Methode verwendet dann das konfigurierte .schema für die Spiegelung.

>>> # uses `schema` configured in metadata_obj
>>> metadata_obj.reflect(someengine)

Das Endergebnis ist, dass Tabellen aus dem Schema „project“ gespiegelt werden und schema-qualifiziert mit diesem Namen gefüllt werden.

>>> metadata_obj.tables["project.messages"]
Table('messages', MetaData(), Column('message_id', INTEGER(), table=<messages>), schema='project')

Ebenso wird ein einzelnes Table-Objekt, das den Parameter Table.schema enthält, ebenfalls aus diesem Datenbank-Schema gespiegelt und überschreibt jedes Standard-Schema, das möglicherweise im besitzenden MetaData-Objekt konfiguriert wurde.

>>> messages = Table("messages", metadata_obj, schema="project", autoload_with=someengine)
>>> messages
Table('messages', MetaData(), Column('message_id', INTEGER(), table=<messages>), schema='project')

Schließlich erlaubt die Methode MetaData.reflect() selbst auch einen Parameter MetaData.reflect.schema, sodass wir auch Tabellen aus dem Schema „project“ für ein standardmäßig konfiguriertes MetaData-Objekt laden könnten.

>>> metadata_obj = MetaData()
>>> metadata_obj.reflect(someengine, schema="project")

Wir können MetaData.reflect() beliebig oft mit unterschiedlichen MetaData.schema-Argumenten (oder ohne Argumente) aufrufen, um das MetaData-Objekt mit weiteren Objekten zu füllen.

>>> # add tables from the "customer" schema
>>> metadata_obj.reflect(someengine, schema="customer")
>>> # add tables from the default schema
>>> metadata_obj.reflect(someengine)

Interaktion von Schema-qualifizierter Spiegelung mit dem Standard-Schema¶

Abschnitt Best Practices Zusammenfassung

In diesem Abschnitt diskutieren wir das Spiegelungsverhalten von SQLAlchemy bezüglich Tabellen, die im „Standard-Schema“ einer Datenbanksitzung sichtbar sind, und wie diese mit SQLAlchemy-Direktiven interagieren, die das Schema explizit einschließen. Als Best Practice stellen Sie sicher, dass das „Standard“-Schema für eine Datenbank nur ein einzelner Name und keine Liste von Namen ist; für Tabellen, die Teil dieses „Standard“-Schemas sind und ohne Schema-Qualifizierung in DDL und SQL benannt werden können, lassen Sie die entsprechenden Table.schema und ähnliche Schema-Parameter auf ihrem Standardwert von None gesetzt.

Wie in Angabe eines Standard-Schema-Namens mit MetaData beschrieben, haben Datenbanken, die das Konzept von Schemas haben, normalerweise auch das Konzept eines „Standard“-Schemas. Der Grund dafür ist natürlich, dass, wenn man auf Tabellenobjekte ohne Schema verweist, wie es üblich ist, eine schemafähige Datenbank diese Tabelle dennoch irgendwo in einem „Schema“ betrachtet. Einige Datenbanken wie PostgreSQL gehen dieses Konzept weiter in Richtung eines Schema-Suchpfads, bei dem *mehrere* Schemanamen in einer bestimmten Datenbanksitzung als „implizit“ betrachtet werden können; das Verweisen auf einen Tabellennamen, der in einem dieser Schemas vorhanden ist, erfordert nicht, dass der Schemaname angegeben wird (während es gleichzeitig auch völlig in Ordnung ist, wenn der Schemaname *angegeben* wird).

Da die meisten relationalen Datenbanken daher das Konzept eines bestimmten Tabellenobjekts haben, auf das sowohl mit Schema-Qualifizierung als auch „implizit“ ohne Schema verwiesen werden kann, stellt dies eine Komplexität für die Spiegelungsfunktion von SQLAlchemy dar. Das Spiegeln einer Tabelle auf schema-qualifizierte Weise füllt immer ihr Attribut Table.schema und beeinflusst zusätzlich, wie diese Table in der Sammlung MetaData.tables organisiert wird, d.h. auf schema-qualifizierte Weise. Umgekehrt organisiert das Spiegeln der **selben** Tabelle auf eine nicht-schema-qualifizierte Weise sie in der Sammlung MetaData.tables **ohne** Schema-Qualifizierung. Das Endergebnis ist, dass es zwei separate Table-Objekte in der einzigen MetaData-Sammlung gäbe, die dieselbe Tabelle in der tatsächlichen Datenbank darstellen.

Um die Auswirkungen dieses Problems zu veranschaulichen, betrachten wir die Tabellen aus dem Schema „project“ im vorherigen Beispiel und nehmen an, dass das Schema „project“ auch das Standard-Schema unserer Datenbankverbindung ist, oder wenn wir eine Datenbank wie PostgreSQL verwenden, nehmen wir an, dass das Schema „project“ im PostgreSQL search_path konfiguriert ist. Dies würde bedeuten, dass die Datenbank die folgenden beiden SQL-Anweisungen als äquivalent betrachtet:

-- schema qualified
SELECT message_id FROM project.messages

-- non-schema qualified
SELECT message_id FROM messages

Dies ist kein Problem, da die Tabelle auf beide Arten gefunden werden kann. In SQLAlchemy bestimmt jedoch die **Identität** des Table-Objekts seine semantische Rolle in einer SQL-Anweisung. Basierend auf den aktuellen Entscheidungen innerhalb von SQLAlchemy bedeutet dies, dass, wenn wir dieselbe „messages“-Tabelle sowohl schema-qualifiziert als auch nicht-schema-qualifiziert spiegeln, wir **zwei** Table-Objekte erhalten, die **nicht** semantisch als äquivalent behandelt werden.

>>> # reflect in non-schema qualified fashion
>>> messages_table_1 = Table("messages", metadata_obj, autoload_with=someengine)
>>> # reflect in schema qualified fashion
>>> messages_table_2 = Table(
...     "messages", metadata_obj, schema="project", autoload_with=someengine
... )
>>> # two different objects
>>> messages_table_1 is messages_table_2
False
>>> # stored in two different ways
>>> metadata.tables["messages"] is messages_table_1
True
>>> metadata.tables["project.messages"] is messages_table_2
True

Das obige Problem wird komplizierter, wenn die gespiegelten Tabellen Fremdschlüsselverweise auf andere Tabellen enthalten. Angenommen, „messages“ hat eine Spalte „project_id“, die auf Zeilen in einer anderen Schema-lokalen Tabelle „projects“ verweist, was bedeutet, dass es ein ForeignKeyConstraint-Objekt gibt, das Teil der Definition der „messages“-Tabelle ist.

Wir können uns in einer Situation wiederfinden, in der eine MetaData-Sammlung bis zu vier Table-Objekte enthalten kann, die diese beiden Datenbanktabellen darstellen, wobei ein oder zwei der zusätzlichen Tabellen durch den Spiegelungsprozess generiert wurden; dies liegt daran, dass, wenn der Spiegelungsprozess eine Fremdschlüsseleinschränkung einer zu spiegelnden Tabelle feststellt, er ausweicht, um auch diese referenzierte Tabelle zu spiegeln. Die Entscheidungsfindung, die er verwendet, um das Schema dieser referenzierten Tabelle zuzuweisen, ist, dass SQLAlchemy ein **Standard-Schema weglässt** aus dem gespiegelten ForeignKeyConstraint-Objekt, wenn die besitzende Table ebenfalls ihren Schemanamen weglässt und beide Objekte im selben Schema liegen, aber es **einschließen** wird, wenn es nicht weggelassen wurde.

Das übliche Szenario ist, dass die Spiegelung einer Tabelle auf schema-qualifizierte Weise dann eine zugehörige Tabelle lädt, die ebenfalls auf schema-qualifizierte Weise durchgeführt wird.

>>> # reflect "messages" in a schema qualified fashion
>>> messages_table_1 = Table(
...     "messages", metadata_obj, schema="project", autoload_with=someengine
... )

Die obige messages_table_1 verweist auch auf projects auf schema-qualifizierte Weise. Diese „projects“-Tabelle wird automatisch gespiegelt, da „messages“ darauf verweist.

>>> messages_table_1.c.project_id
Column('project_id', INTEGER(), ForeignKey('project.projects.project_id'), table=<messages>)

Wenn ein anderer Teil des Codes „projects“ auf nicht-schema-qualifizierte Weise spiegelt, gibt es nun zwei Projekte-Tabellen, die nicht identisch sind.

>>> # reflect "projects" in a non-schema qualified fashion
>>> projects_table_1 = Table("projects", metadata_obj, autoload_with=someengine)

>>> # messages does not refer to projects_table_1 above
>>> messages_table_1.c.project_id.references(projects_table_1.c.project_id)
False

>>> # it refers to this one
>>> projects_table_2 = metadata_obj.tables["project.projects"]
>>> messages_table_1.c.project_id.references(projects_table_2.c.project_id)
True

>>> # they're different, as one non-schema qualified and the other one is
>>> projects_table_1 is projects_table_2
False

Die obige Verwirrung kann zu Problemen in Anwendungen führen, die Tabellenspiegelung verwenden, um Anwendungsebene-Table-Objekte zu laden, sowie in Migrationsszenarien, insbesondere bei der Verwendung von Alembic Migrations zur Erkennung neuer Tabellen und Fremdschlüsseleinschränkungen.

Das obige Verhalten kann durch Befolgen einer einfachen Praxis behoben werden.

Fügen Sie den Parameter Table.schema für jede Table weg, die sich im **Standard**-Schema der Datenbank befinden soll.

Für PostgreSQL und andere Datenbanken, die einen „Suchpfad“ für Schemas unterstützen, fügen Sie die folgende zusätzliche Praxis hinzu:

Beschränken Sie den „Suchpfad“ auf **nur ein Schema, nämlich das Standard-Schema**.

Siehe auch

Remote-Schema-Tabellen-Introspektion und PostgreSQL search_path - zusätzliche Details zu diesem Verhalten in Bezug auf die PostgreSQL-Datenbank.

Feingranulare Spiegelung mit Inspector¶

Eine Low-Level-Schnittstelle, die ein Backend-agnostisches System zum Laden von Listen von Schema-, Tabellen-, Spalten- und Einschränkungsbeschreibungen aus einer gegebenen Datenbank bereitstellt, ist ebenfalls verfügbar. Dies ist als „Inspector“ bekannt.

from sqlalchemy import create_engine
from sqlalchemy import inspect

engine = create_engine("...")
insp = inspect(engine)
print(insp.get_table_names())

Objektname	Beschreibung
Inspector	Führt die Inspektion des Datenbankschemas durch.
ReflectedCheckConstraint	Wörterbuch, das die gespiegelten Elemente darstellt, die `CheckConstraint` entsprechen.
ReflectedColumn	Wörterbuch, das die gespiegelten Elemente darstellt, die einem `Column`-Objekt entsprechen.
ReflectedComputed	Stellt die gespiegelten Elemente einer berechneten Spalte dar, die dem `Computed`-Konstrukt entspricht.
ReflectedForeignKeyConstraint	Wörterbuch, das die gespiegelten Elemente darstellt, die `ForeignKeyConstraint` entsprechen.
ReflectedIdentity	Stellt die gespiegelte IDENTITY-Struktur einer Spalte dar, die dem `Identity`-Konstrukt entspricht.
ReflectedIndex	Wörterbuch, das die gespiegelten Elemente darstellt, die `Index` entsprechen.
ReflectedPrimaryKeyConstraint	Wörterbuch, das die gespiegelten Elemente darstellt, die `PrimaryKeyConstraint` entsprechen.
ReflectedTableComment	Wörterbuch, das den gespiegelten Kommentar darstellt, der dem Attribut `Table.comment` entspricht.
ReflectedUniqueConstraint	Wörterbuch, das die gespiegelten Elemente darstellt, die `UniqueConstraint` entsprechen.

class sqlalchemy.engine.reflection.Inspector¶

Führt die Inspektion des Datenbankschemas durch.

Der Inspector fungiert als Proxy für die Spiegelungsmethoden des Dialect und bietet eine konsistente Schnittstelle sowie Caching-Unterstützung für zuvor abgerufene Metadaten.

Ein Inspector-Objekt wird normalerweise über die Funktion inspect() erstellt, der eine Engine oder eine Connection übergeben werden kann.

from sqlalchemy import inspect, create_engine

engine = create_engine("...")
insp = inspect(engine)

Wo oben der zugehörige Dialect der Engine es zulässt, eine Inspector-Unterklasse zurückzugeben, die zusätzliche, spezifische Methoden für die Zieldatenbank des Dialekts bereitstellt.

Klassensignatur

class sqlalchemy.engine.reflection.Inspector (sqlalchemy.inspection.Inspectable)

Methode sqlalchemy.engine.reflection.Inspector.__init__(bind: Engine | Connection)¶

Initialisiert einen neuen Inspector.

Veraltet seit Version 1.4: Die Methode __init__() auf Inspector ist veraltet und wird in einer zukünftigen Version entfernt. Bitte verwenden Sie die Funktion inspect() auf einer Engine oder Connection, um einen Inspector zu erhalten.

Parameter:: bind¶ – Eine Connection, die typischerweise eine Instanz von Engine oder Connection ist.

Für eine dialektspezifische Instanz von Inspector siehe Inspector.from_engine()

Attribut sqlalchemy.engine.reflection.Inspector.bind: Engine | Connection¶

Methode sqlalchemy.engine.reflection.Inspector.clear_cache() → None¶

Setzt den Cache für diesen Inspector zurück.

Inspektionsmethoden, die Daten im Cache haben, senden bei der nächsten Ausführung SQL-Abfragen, um neue Daten zu erhalten.

Neu in Version 2.0.

Attribut sqlalchemy.engine.reflection.Inspector.default_schema_name¶

Gibt den vom Dialekt für den aktuellen Datenbankbenutzer der Engine bereitgestellten Standard-Schemanamen zurück.

Beispiel: Dies ist typischerweise public für PostgreSQL und dbo für SQL Server.

Attribut sqlalchemy.engine.reflection.Inspector.dialect: Dialect¶

Attribut sqlalchemy.engine.reflection.Inspector.engine: Engine¶

Klassenmethode sqlalchemy.engine.reflection.Inspector.from_engine(bind: Engine) → Inspector¶

Erstellt ein neues dialektspezifisches Inspector-Objekt aus der gegebenen Engine oder Connection.

Veraltet seit Version 1.4: Die Methode from_engine() auf Inspector ist veraltet und wird in einer zukünftigen Version entfernt. Bitte verwenden Sie die Funktion inspect() auf einer Engine oder Connection, um einen Inspector zu erhalten.

Parameter:: bind¶ – Eine Connection oder Engine.

Diese Methode unterscheidet sich von einem direkten Konstruktoraufruf von Inspector dadurch, dass dem Dialect die Möglichkeit gegeben wird, eine dialektspezifische Inspector-Instanz bereitzustellen, die zusätzliche Methoden enthalten kann.

Siehe das Beispiel unter Inspector.

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

Gibt Informationen zu CHECK-Constraints in table_name zurück.

Bei Angabe eines Strings table_name und eines optionalen Strings schema werden CHECK-Constraint-Informationen als Liste von ReflectedCheckConstraint zurückgegeben.

Parameter:

table_name¶ – String-Name der Tabelle. Für spezielle Anführungszeichen verwenden Sie quoted_name.
schema¶ – String-Name des Schemas; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

Eine Liste von Dictionaries, die jeweils die Definition eines CHECK-Constraints darstellen.

Siehe auch

Inspector.get_multi_check_constraints()

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

Gibt Informationen zu Spalten in table_name zurück.

Bei Angabe eines Strings table_name und eines optionalen Strings schema werden Spalteninformationen als Liste von ReflectedColumn zurückgegeben.

Parameter:

table_name¶ – String-Name der Tabelle. Für spezielle Anführungszeichen verwenden Sie quoted_name.
schema¶ – String-Name des Schemas; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

Eine Liste von Dictionaries, die jeweils die Definition einer Datenbankspalte darstellen.

Siehe auch

Inspector.get_multi_columns().

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

Gibt Informationen zu Fremdschlüsseln in table_name zurück.

Bei Angabe eines Strings table_name und eines optionalen Strings schema werden Fremdschlüsselinformationen als Liste von ReflectedForeignKeyConstraint zurückgegeben.

Parameter:

table_name¶ – String-Name der Tabelle. Für spezielle Anführungszeichen verwenden Sie quoted_name.
schema¶ – String-Name des Schemas; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

Eine Liste von Dictionaries, die jeweils die Definition eines Fremdschlüssels darstellen.

Siehe auch

Inspector.get_multi_foreign_keys()

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

Gibt Informationen zu Indizes in table_name zurück.

Bei Angabe eines Strings table_name und eines optionalen Strings schema werden Indexinformationen als Liste von ReflectedIndex zurückgegeben.

Parameter:

table_name¶ – String-Name der Tabelle. Für spezielle Anführungszeichen verwenden Sie quoted_name.
schema¶ – String-Name des Schemas; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

Eine Liste von Dictionaries, die jeweils die Definition eines Index darstellen.

Siehe auch

Inspector.get_multi_indexes()

Methode sqlalchemy.engine.reflection.Inspector.get_materialized_view_names(schema: str | None = None, **kw: Any) → List[str]¶

Gibt alle Namen materialisierter Sichten im Schema schema zurück.

Parameter:

schema¶ – Optional, ruft Namen aus einem nicht standardmäßigen Schema ab. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Neu in Version 2.0.

Siehe auch

Inspector.get_view_names()

Methode sqlalchemy.engine.reflection.Inspector.get_multi_check_constraints(schema: str | None = None, filter_names: Sequence[str] | None = None, kind: ObjectKind = ObjectKind.TABLE, scope: ObjectScope = ObjectScope.DEFAULT, **kw: Any) → Dict[TableKey, List[ReflectedCheckConstraint]]¶

Gibt Informationen zu CHECK-Constraints in allen Tabellen des angegebenen Schemas zurück.

Die Tabellen können durch Übergabe der zu verwendenden Namen an filter_names gefiltert werden.

Für jede Tabelle ist der Wert eine Liste von ReflectedCheckConstraint.

Parameter:

schema¶ – String-Name des Schemas; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
filter_names¶ – optional, gibt nur Informationen für die hier aufgeführten Objekte zurück.
kind¶ – ein ObjectKind, der den Typ der zu reflektierenden Objekte angibt. Standardmäßig ObjectKind.TABLE.
scope¶ – ein ObjectScope, der angibt, ob Constraints von Standard-, temporären oder beliebigen Tabellen reflektiert werden sollen. Standardmäßig ObjectScope.DEFAULT.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

Ein Dictionary, bei dem die Schlüssel zweielementige Tupel (Schema, Tabellenname) sind und die Werte Listen von Dictionaries sind, die jeweils die Definition eines CHECK-Constraints darstellen. Das Schema ist None, wenn kein Schema angegeben wurde.

Neu in Version 2.0.

Siehe auch

Inspector.get_check_constraints()

method sqlalchemy.engine.reflection.Inspector.get_multi_columns(schema: str | None = None, filter_names: Sequence[str] | None = None, kind: ObjectKind = ObjectKind.TABLE, scope: ObjectScope = ObjectScope.DEFAULT, **kw: Any) → Dict[TableKey, List[ReflectedColumn]]¶

Gibt Informationen über Spalten in allen Objekten im angegebenen Schema zurück.

Die Objekte können durch Übergabe der zu verwendenden Namen an filter_names gefiltert werden.

Für jede Tabelle ist der Wert eine Liste von ReflectedColumn.

Parameter:

schema¶ – String-Schema-Name; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
filter_names¶ – optional Informationen nur für die hier aufgeführten Objekte zurückgeben.
kind¶ – ein ObjectKind, das den Typ der zu reflektierenden Objekte angibt. Standardwert ist ObjectKind.TABLE.
scope¶ – ein ObjectScope, das angibt, ob Spalten von Standard-, temporären oder beliebigen Tabellen reflektiert werden sollen. Standardwert ist ObjectScope.DEFAULT.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

ein Wörterbuch, bei dem die Schlüssel ein Tupel aus Schema und Tabellenname sind und die Werte eine Liste von Wörterbüchern sind, die jeweils die Definition einer Datenbankspalte darstellen. Das Schema ist None, wenn kein Schema angegeben wird.

Neu in Version 2.0.

Siehe auch

Inspector.get_columns()

method sqlalchemy.engine.reflection.Inspector.get_multi_foreign_keys(schema: str | None = None, filter_names: Sequence[str] | None = None, kind: ObjectKind = ObjectKind.TABLE, scope: ObjectScope = ObjectScope.DEFAULT, **kw: Any) → Dict[TableKey, List[ReflectedForeignKeyConstraint]]¶

Gibt Informationen über Fremdschlüssel in allen Tabellen im angegebenen Schema zurück.

Die Tabellen können durch Übergabe der zu verwendenden Namen an filter_names gefiltert werden.

Für jede Tabelle ist der Wert eine Liste von ReflectedForeignKeyConstraint.

Parameter:

schema¶ – String-Schema-Name; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
filter_names¶ – optional Informationen nur für die hier aufgeführten Objekte zurückgeben.
kind¶ – ein ObjectKind, das den Typ der zu reflektierenden Objekte angibt. Standardwert ist ObjectKind.TABLE.
scope¶ – ein ObjectScope, das angibt, ob Fremdschlüssel von Standard-, temporären oder beliebigen Tabellen reflektiert werden sollen. Standardwert ist ObjectScope.DEFAULT.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

ein Wörterbuch, bei dem die Schlüssel ein Tupel aus Schema und Tabellenname sind und die Werte eine Liste von Wörterbüchern sind, die jeweils eine Fremdschlüsseldefinition darstellen. Das Schema ist None, wenn kein Schema angegeben wird.

Neu in Version 2.0.

Siehe auch

Inspector.get_foreign_keys()

method sqlalchemy.engine.reflection.Inspector.get_multi_indexes(schema: str | None = None, filter_names: Sequence[str] | None = None, kind: ObjectKind = ObjectKind.TABLE, scope: ObjectScope = ObjectScope.DEFAULT, **kw: Any) → Dict[TableKey, List[ReflectedIndex]]¶

Gibt Informationen über Indizes in allen Objekten im angegebenen Schema zurück.

Die Objekte können durch Übergabe der zu verwendenden Namen an filter_names gefiltert werden.

Für jede Tabelle ist der Wert eine Liste von ReflectedIndex.

Parameter:

schema¶ – String-Schema-Name; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
filter_names¶ – optional Informationen nur für die hier aufgeführten Objekte zurückgeben.
kind¶ – ein ObjectKind, das den Typ der zu reflektierenden Objekte angibt. Standardwert ist ObjectKind.TABLE.
scope¶ – ein ObjectScope, das angibt, ob Indizes von Standard-, temporären oder beliebigen Tabellen reflektiert werden sollen. Standardwert ist ObjectScope.DEFAULT.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

ein Wörterbuch, bei dem die Schlüssel ein Tupel aus Schema und Tabellenname sind und die Werte eine Liste von Wörterbüchern sind, die jeweils die Definition eines Index darstellen. Das Schema ist None, wenn kein Schema angegeben wird.

Neu in Version 2.0.

Siehe auch

Inspector.get_indexes()

method sqlalchemy.engine.reflection.Inspector.get_multi_pk_constraint(schema: str | None = None, filter_names: Sequence[str] | None = None, kind: ObjectKind = ObjectKind.TABLE, scope: ObjectScope = ObjectScope.DEFAULT, **kw: Any) → Dict[TableKey, ReflectedPrimaryKeyConstraint]¶

Gibt Informationen über Primärschlüsselbeschränkungen in allen Tabellen im angegebenen Schema zurück.

Die Tabellen können durch Übergabe der zu verwendenden Namen an filter_names gefiltert werden.

Für jede Tabelle ist der Wert eine ReflectedPrimaryKeyConstraint.

Parameter:

schema¶ – String-Schema-Name; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
filter_names¶ – optional Informationen nur für die hier aufgeführten Objekte zurückgeben.
kind¶ – ein ObjectKind, das den Typ der zu reflektierenden Objekte angibt. Standardwert ist ObjectKind.TABLE.
scope¶ – ein ObjectScope, das angibt, ob Primärschlüssel von Standard-, temporären oder beliebigen Tabellen reflektiert werden sollen. Standardwert ist ObjectScope.DEFAULT.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

ein Wörterbuch, bei dem die Schlüssel ein Tupel aus Schema und Tabellenname sind und die Werte Wörterbücher sind, die die Definition einer Primärschlüsselbeschränkung darstellen. Das Schema ist None, wenn kein Schema angegeben wird.

Neu in Version 2.0.

Siehe auch

Inspector.get_pk_constraint()

method sqlalchemy.engine.reflection.Inspector.get_multi_table_comment(schema: str | None = None, filter_names: Sequence[str] | None = None, kind: ObjectKind = ObjectKind.TABLE, scope: ObjectScope = ObjectScope.DEFAULT, **kw: Any) → Dict[TableKey, ReflectedTableComment]¶

Gibt Informationen über den Tabellenkommentar in allen Objekten im angegebenen Schema zurück.

Die Objekte können durch Übergabe der zu verwendenden Namen an filter_names gefiltert werden.

Für jede Tabelle ist der Wert eine ReflectedTableComment.

Löst NotImplementedError für einen Dialekt aus, der keine Kommentare unterstützt.

Parameter:

schema¶ – String-Schema-Name; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
filter_names¶ – optional Informationen nur für die hier aufgeführten Objekte zurückgeben.
kind¶ – ein ObjectKind, das den Typ der zu reflektierenden Objekte angibt. Standardwert ist ObjectKind.TABLE.
scope¶ – ein ObjectScope, das angibt, ob Kommentare von Standard-, temporären oder beliebigen Tabellen reflektiert werden sollen. Standardwert ist ObjectScope.DEFAULT.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

ein Wörterbuch, bei dem die Schlüssel ein Tupel aus Schema und Tabellenname sind und die Werte Wörterbücher sind, die die Tabellenkommentare darstellen. Das Schema ist None, wenn kein Schema angegeben wird.

Neu in Version 2.0.

Siehe auch

Inspector.get_table_comment()

method sqlalchemy.engine.reflection.Inspector.get_multi_table_options(schema: str | None = None, filter_names: Sequence[str] | None = None, kind: ObjectKind = ObjectKind.TABLE, scope: ObjectScope = ObjectScope.DEFAULT, **kw: Any) → Dict[TableKey, Dict[str, Any]]¶

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

Die Tabellen können durch Übergabe der zu verwendenden Namen an filter_names gefiltert werden.

Dies umfasst derzeit einige Optionen, die für MySQL- und Oracle-Tabellen gelten.

Parameter:

schema¶ – String-Schema-Name; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
filter_names¶ – optional Informationen nur für die hier aufgeführten Objekte zurückgeben.
kind¶ – ein ObjectKind, das den Typ der zu reflektierenden Objekte angibt. Standardwert ist ObjectKind.TABLE.
scope¶ – ein ObjectScope, das angibt, ob Optionen von Standard-, temporären oder beliebigen Tabellen reflektiert werden sollen. Standardwert ist ObjectScope.DEFAULT.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

ein Wörterbuch, bei dem die Schlüssel ein Tupel aus Schema und Tabellenname sind und die Werte Wörterbücher mit den Tabellenoptionen sind. Die zurückgegebenen Schlüssel in jedem Wörterbuch hängen vom verwendeten Dialekt ab. Jeder Schlüssel ist mit dem Dialektnamen präfixiert. Das Schema ist None, wenn kein Schema angegeben wird.

Neu in Version 2.0.

Siehe auch

Inspector.get_table_options()

method sqlalchemy.engine.reflection.Inspector.get_multi_unique_constraints(schema: str | None = None, filter_names: Sequence[str] | None = None, kind: ObjectKind = ObjectKind.TABLE, scope: ObjectScope = ObjectScope.DEFAULT, **kw: Any) → Dict[TableKey, List[ReflectedUniqueConstraint]]¶

Gibt Informationen über eindeutige Beschränkungen in allen Tabellen im angegebenen Schema zurück.

Die Tabellen können durch Übergabe der zu verwendenden Namen an filter_names gefiltert werden.

Für jede Tabelle ist der Wert eine Liste von ReflectedUniqueConstraint.

Parameter:

schema¶ – String-Schema-Name; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
filter_names¶ – optional Informationen nur für die hier aufgeführten Objekte zurückgeben.
kind¶ – ein ObjectKind, das den Typ der zu reflektierenden Objekte angibt. Standardwert ist ObjectKind.TABLE.
scope¶ – ein ObjectScope, das angibt, ob eindeutige Beschränkungen von Standard-, temporären oder beliebigen Tabellen reflektiert werden sollen. Standardwert ist ObjectScope.DEFAULT.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

ein Wörterbuch, bei dem die Schlüssel ein Tupel aus Schema und Tabellenname sind und die Werte eine Liste von Wörterbüchern sind, die jeweils die Definition einer eindeutigen Beschränkung darstellen. Das Schema ist None, wenn kein Schema angegeben wird.

Neu in Version 2.0.

Siehe auch

Inspector.get_unique_constraints()

Methode sqlalchemy.engine.reflection.Inspector.get_pk_constraint(table_name: str, schema: str | None = None, **kw: Any) → ReflectedPrimaryKeyConstraint¶

Gibt Informationen zur Primärschlüsselbeschränkung in table_name zurück.

Gibt für einen Zeichenkettennamen table_name und optional einen Zeichenkettennamen schema die Primärschlüsselinformationen als ReflectedPrimaryKeyConstraint zurück.

Parameter:

table_name¶ – Zeichenkettenname der Tabelle. Für spezielle Anführungszeichen verwenden Sie quoted_name.
schema¶ – Zeichenkettenname des Schemas; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

ein Wörterbuch, das die Definition einer Primärschlüsselbeschränkung darstellt.

Siehe auch

Inspector.get_multi_pk_constraint()

Methode sqlalchemy.engine.reflection.Inspector.get_schema_names(**kw: Any) → List[str]¶

Gibt alle Schemanamen zurück.

Parameter:: **kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Methode sqlalchemy.engine.reflection.Inspector.get_sequence_names(schema: str | None = None, **kw: Any) → List[str]¶

Gibt alle Sequenznamen im Schema schema zurück.

Parameter:

schema¶ – Optional, Namen aus einem Nicht-Standardschema abrufen. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Methode sqlalchemy.engine.reflection.Inspector.get_sorted_table_and_fkc_names(schema: str | None = None, **kw: Any) → List[Tuple[str | None, List[Tuple[str, str | None]]]]¶

Gibt abhängigkeitsweise sortierte Tabellen- und Fremdschlüsselbeschränkungsnamen zurück, die sich innerhalb eines bestimmten Schemas befinden.

Dies liefert 2-Tupel von (tabellenname, [(tnamen, fkname), (tnamen, fkname), ...]), bestehend aus Tabellennamen in CREATE-Reihenfolge, gruppiert mit den Fremdschlüsselbeschränkungsnamen, die nicht als Teil eines Zyklus erkannt wurden. Das letzte Element ist (None, [(tnamen, fkname), (tnamen, fkname), ..]), das die verbleibenden Fremdschlüsselbeschränkungsnamen enthält, die nach einem separaten CREATE-Schritt auf Basis von Abhängigkeiten zwischen Tabellen erforderlich wären.

Parameter:

schema¶ – Schema, das abgefragt werden soll, wenn es nicht das Standardschema ist.
**kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Siehe auch

Inspector.get_table_names()

sort_tables_and_constraints() - ähnliche Methode, die mit einem bereits gegebenen MetaData arbeitet.

Methode sqlalchemy.engine.reflection.Inspector.get_table_comment(table_name: str, schema: str | None = None, **kw: Any) → ReflectedTableComment¶

Gibt Informationen zum Tabellenkommentar für table_name zurück.

Gibt für einen Zeichenkettennamen table_name und optional einen Zeichenkettennamen schema die Tabellenkommentarinformationen als ReflectedTableComment zurück.

Löst NotImplementedError für einen Dialekt aus, der keine Kommentare unterstützt.

Parameter:

table_name¶ – Zeichenkettenname der Tabelle. Für spezielle Anführungszeichen verwenden Sie quoted_name.
schema¶ – Zeichenkettenname des Schemas; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

ein Wörterbuch mit dem Tabellenkommentar.

Neu seit Version 1.2.

Siehe auch

Inspector.get_multi_table_comment()

Methode sqlalchemy.engine.reflection.Inspector.get_table_names(schema: str | None = None, **kw: Any) → List[str]¶

Gibt alle Tabellennamen in einem bestimmten Schema zurück.

Die Namen sind als echte Tabellen gedacht und nicht als Views. Views werden stattdessen über die Methoden Inspector.get_view_names() und/oder Inspector.get_materialized_view_names() zurückgegeben.

Parameter:

schema¶ – Schemaname. Wenn schema auf None gesetzt ist, wird das Standardschema der Datenbank verwendet, andernfalls wird das benannte Schema durchsucht. Wenn die Datenbank keine benannten Schemas unterstützt, ist das Verhalten undefiniert, wenn schema nicht als None übergeben wird. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Siehe auch

Inspector.get_sorted_table_and_fkc_names()

MetaData.sorted_tables

Methode sqlalchemy.engine.reflection.Inspector.get_table_options(table_name: str, schema: str | None = None, **kw: Any) → Dict[str, Any]¶

Gibt ein Wörterbuch mit Optionen zurück, die beim Erstellen der Tabelle mit dem angegebenen Namen festgelegt wurden.

Dies umfasst derzeit einige Optionen, die für Tabellen unter MySQL und Oracle Database gelten.

Parameter:

table_name¶ – Zeichenkettenname der Tabelle. Für spezielle Anführungszeichen verwenden Sie quoted_name.
schema¶ – Zeichenkettenname des Schemas; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

ein Wörterbuch mit den Tabellenoptionen. Die zurückgegebenen Schlüssel hängen vom verwendeten Dialekt ab. Jeder Schlüssel ist mit dem Dialektnamen präfixiert.

Siehe auch

Inspector.get_multi_table_options()

Methode sqlalchemy.engine.reflection.Inspector.get_temp_table_names(**kw: Any) → List[str]¶

Gibt eine Liste der temporären Tabellennamen für die aktuelle Verbindung zurück.

Diese Methode wird von den meisten Dialekten nicht unterstützt; derzeit implementieren sie nur Oracle Database, PostgreSQL und SQLite.

Parameter:: **kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Methode sqlalchemy.engine.reflection.Inspector.get_temp_view_names(**kw: Any) → List[str]¶

Gibt eine Liste der temporären View-Namen für die aktuelle Verbindung zurück.

Diese Methode wird von den meisten Dialekten nicht unterstützt; derzeit implementieren sie nur PostgreSQL und SQLite.

Parameter:: **kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Methode sqlalchemy.engine.reflection.Inspector.get_unique_constraints(table_name: str, schema: str | None = None, **kw: Any) → List[ReflectedUniqueConstraint]¶

Gibt Informationen zu eindeutigen Beschränkungen in table_name zurück.

Gibt für einen Zeichenkettennamen table_name und optional einen Zeichenkettennamen schema eindeutige Beschränkungsinformationen als Liste von ReflectedUniqueConstraint zurück.

Parameter:

table_name¶ – Zeichenkettenname der Tabelle. Für spezielle Anführungszeichen verwenden Sie quoted_name.
schema¶ – Zeichenkettenname des Schemas; wenn weggelassen, wird das Standardschema der Datenbankverbindung verwendet. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Gibt zurück:

eine Liste von Wörterbüchern, die jeweils die Definition einer eindeutigen Beschränkung darstellen.

Siehe auch

Inspector.get_multi_unique_constraints()

Methode sqlalchemy.engine.reflection.Inspector.get_view_definition(view_name: str, schema: str | None = None, **kw: Any) → str¶

Gibt die Definition für die einfache oder materialisierte View namens view_name zurück.

Parameter:

view_name¶ – Name der View.
schema¶ – Optional, Namen aus einem Nicht-Standardschema abrufen. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Methode sqlalchemy.engine.reflection.Inspector.get_view_names(schema: str | None = None, **kw: Any) → List[str]¶

Gibt alle nicht-materialisierten View-Namen im Schema schema zurück.

Parameter:

schema¶ – Optional, Namen aus einem Nicht-Standardschema abrufen. Für spezielle Anführungszeichen verwenden Sie quoted_name.
**kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Geändert in Version 2.0: Für Dialekte, die zuvor die Namen materialisierter Views in dieser Liste enthielten (derzeit PostgreSQL), gibt diese Methode die Namen von materialisierten Views nicht mehr zurück. Die Methode Inspector.get_materialized_view_names() sollte stattdessen verwendet werden.

Siehe auch

Inspector.get_materialized_view_names()

Methode sqlalchemy.engine.reflection.Inspector.has_index(table_name: str, index_name: str, schema: str | None = None, **kw: Any) → bool¶

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

Parameter:

table_name¶ – der Name der Tabelle, zu der der Index gehört
index_name¶ – der Name des zu prüfenden Index
schema¶ – Schema, das abgefragt werden soll, wenn es nicht das Standardschema ist.
**kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Neu in Version 2.0.

Methode sqlalchemy.engine.reflection.Inspector.has_schema(schema_name: str, **kw: Any) → bool¶

Gibt True zurück, wenn das Backend ein Schema mit dem angegebenen Namen hat.

Parameter:

schema_name¶ – Name des zu prüfenden Schemas
**kw¶ – Zusätzliches Schlüsselwortargument, das an die dialektspezifische Implementierung übergeben wird. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Neu in Version 2.0.

method sqlalchemy.engine.reflection.Inspector.has_sequence(sequence_name: str, schema: str | None = None, **kw: Any) → bool¶

Gibt True zurück, wenn das Backend eine Sequenz mit dem angegebenen Namen hat.

Parameter:

sequence_name¶ – Name der zu prüfenden Sequenz
schema¶ – Schema-Name für die Abfrage, falls nicht das Standardschema.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden sollen. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Neu in Version 1.4.

method sqlalchemy.engine.reflection.Inspector.has_table(table_name: str, schema: str | None = None, **kw: Any) → bool¶

Gibt True zurück, wenn das Backend eine Tabelle, eine Ansicht oder eine temporäre Tabelle mit dem angegebenen Namen hat.

Parameter:

table_name¶ – Name der zu prüfenden Tabelle
schema¶ – Schema-Name für die Abfrage, falls nicht das Standardschema.
**kw¶ – Zusätzliche Schlüsselwortargumente, die an die dialektspezifische Implementierung übergeben werden sollen. Weitere Informationen finden Sie in der Dokumentation des verwendeten Dialekts.

Neu in Version 1.4: - die Methode Inspector.has_table() ersetzt die Methode Engine.has_table().

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

beliebige Art von Ansichten (einfach oder materialisiert)
temporäre Tabellen jeglicher Art

Zuvor waren diese beiden Prüfungen nicht formell spezifiziert und verschiedene Dialekte verhielten sich unterschiedlich. Die Testsuite für Dialekte enthält nun Tests für all diese Objekttypen und sollte von allen in SQLAlchemy enthaltenen Dialekten unterstützt werden. Die Unterstützung durch Drittanbieter-Dialekte kann jedoch zurückliegen.

attribute sqlalchemy.engine.reflection.Inspector.info_cache: Dict[Any, Any]¶

method sqlalchemy.engine.reflection.Inspector.reflect_table(table: Table, include_columns: Collection[str] | None, exclude_columns: Collection[str] = (), resolve_fks: bool = True, _extend_on: Set[Table] | None = None, _reflect_info: _ReflectionInfo | None = None) → None¶

Lädt basierend auf der Introspektion die internen Konstrukte eines gegebenen Table-Objekts.

Dies ist die zugrunde liegende Methode, die von den meisten Dialekten zur Erzeugung von Tabellenreflexion verwendet wird. Direkte Verwendung ist wie folgt:

from sqlalchemy import create_engine, MetaData, Table
from sqlalchemy import inspect

engine = create_engine("...")
meta = MetaData()
user_table = Table("user", meta)
insp = inspect(engine)
insp.reflect_table(user_table, None)

Geändert in Version 1.4: Umbenannt von reflecttable zu reflect_table

Parameter:

table¶ – eine Table-Instanz.
include_columns¶ – eine Liste von Spaltennamen als Strings, die in den Reflexionsprozess einbezogen werden sollen. Wenn None, werden alle Spalten reflektiert.

Gibt abhängigkeits-sortierte Namen von Tabellen und Fremdschlüssel-Constraints zurück, die sich auf mehrere Schemas beziehen.

Diese Methode kann mit Inspector.get_sorted_table_and_fkc_names() verglichen werden, die auf ein Schema gleichzeitig arbeitet; hier ist die Methode eine Verallgemeinerung, die mehrere Schemas gleichzeitig berücksichtigt und auch übergreifende Fremdschlüssel auflöst.

Neu in Version 2.0.

class sqlalchemy.engine.interfaces.ReflectedColumn¶

Wörterbuch, das die gespiegelten Elemente darstellt, die einem Column-Objekt entsprechen.

Die Struktur ReflectedColumn wird von der Methode get_columns zurückgegeben.

Mitglieder

autoincrement, comment, computed, default, dialect_options, identity, name, nullable, type

Klassensignatur

class sqlalchemy.engine.interfaces.ReflectedColumn (builtins.dict)

attribute sqlalchemy.engine.interfaces.ReflectedColumn.autoincrement: NotRequired[bool]¶

Datenbankspezifisches Autoincrement-Flag.

Dieses Flag zeigt an, ob die Spalte eine datenbankspezifische "Autoincrement"-Flagge irgendeiner Art hat. Innerhalb von SQLAlchemy können auch andere Spaltentypen als "Autoincrement"-Spalten fungieren, ohne notwendigerweise ein solches Flag zu haben.

Siehe Column.autoincrement für weitere Hintergrundinformationen zu "Autoincrement".

attribute sqlalchemy.engine.interfaces.ReflectedColumn.comment: NotRequired[str | None]¶: Kommentar für die Spalte, falls vorhanden. Nur einige Dialekte geben diesen Schlüssel zurück.

attribute sqlalchemy.engine.interfaces.ReflectedColumn.computed: NotRequired[ReflectedComputed]¶: zeigt an, dass diese Spalte von der Datenbank berechnet wird. Nur einige Dialekte geben diesen Schlüssel zurück.

Neu in Version 1.3.16: - Unterstützung für berechnete Reflexion hinzugefügt.

attribute sqlalchemy.engine.interfaces.ReflectedColumn.default: str | None¶: Standard-SQL-Ausdruck der Spalte als SQL-String

attribute sqlalchemy.engine.interfaces.ReflectedColumn.dialect_options: NotRequired[Dict[str, Any]]¶: Zusätzliche dialektspezifische Optionen, die für dieses reflektierte Objekt erkannt wurden

attribute sqlalchemy.engine.interfaces.ReflectedColumn.identity: NotRequired[ReflectedIdentity]¶: zeigt an, dass diese Spalte eine IDENTITY-Spalte ist. Nur einige Dialekte geben diesen Schlüssel zurück.

Neu in Version 1.4: - Unterstützung für die Reflexion von Identitätsspalten hinzugefügt.

attribute sqlalchemy.engine.interfaces.ReflectedColumn.name: str¶: Spaltenname

attribute sqlalchemy.engine.interfaces.ReflectedColumn.nullable: bool¶: Boolean-Flag, ob die Spalte NULL oder NOT NULL ist

attribute sqlalchemy.engine.interfaces.ReflectedColumn.type: TypeEngine[Any]¶: Spaltentyp, repräsentiert als TypeEngine-Instanz.

class sqlalchemy.engine.interfaces.ReflectedComputed¶

Stellt die gespiegelten Elemente einer berechneten Spalte dar, die dem Computed-Konstrukt entspricht.

Die Struktur ReflectedComputed ist Teil der Struktur ReflectedColumn, die von der Methode Inspector.get_columns() zurückgegeben wird.

Mitglieder

persisted, sqltext

Klassensignatur

class sqlalchemy.engine.interfaces.ReflectedComputed (builtins.dict)

attribute sqlalchemy.engine.interfaces.ReflectedComputed.persisted: NotRequired[bool]¶: zeigt an, ob der Wert in der Tabelle gespeichert oder bei Bedarf berechnet wird

attribute sqlalchemy.engine.interfaces.ReflectedComputed.sqltext: str¶: der Ausdruck, der zur Erzeugung dieser Spalte verwendet wird, zurückgegeben als SQL-Ausdruck in Zeichenform

class sqlalchemy.engine.interfaces.ReflectedCheckConstraint¶

Wörterbuch, das die gespiegelten Elemente darstellt, die CheckConstraint entsprechen.

Die Struktur ReflectedCheckConstraint wird von der Methode Inspector.get_check_constraints() zurückgegeben.

Mitglieder

dialect_options, sqltext

Klassensignatur

class sqlalchemy.engine.interfaces.ReflectedCheckConstraint (builtins.dict)

attribute sqlalchemy.engine.interfaces.ReflectedCheckConstraint.dialect_options: NotRequired[Dict[str, Any]]¶: Zusätzliche dialektspezifische Optionen, die für diese Überprüfungseinschränkung erkannt wurden

Neu seit Version 1.3.8.

attribute sqlalchemy.engine.interfaces.ReflectedCheckConstraint.sqltext: str¶: der SQL-Ausdruck der Überprüfungseinschränkung

class sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint¶

Wörterbuch, das die gespiegelten Elemente darstellt, die ForeignKeyConstraint entsprechen.

Die Struktur ReflectedForeignKeyConstraint wird von der Methode Inspector.get_foreign_keys() zurückgegeben.

Mitglieder

constrained_columns, options, referred_columns, referred_schema, referred_table

Klassensignatur

class sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint (builtins.dict)

attribute sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint.constrained_columns: List[str]¶: lokale Spaltennamen, aus denen sich der Fremdschlüssel zusammensetzt

attribute sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint.options: NotRequired[Dict[str, Any]]¶: Zusätzliche Optionen, die für diesen Fremdschlüssel-Constraint erkannt wurden

attribute sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint.referred_columns: List[str]¶: Referenzierte Spaltennamen, die den constrained_columns entsprechen

attribute sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint.referred_schema: str | None¶: Schema-Name der referenzierten Tabelle

attribute sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint.referred_table: str¶: Name der referenzierten Tabelle

class sqlalchemy.engine.interfaces.ReflectedIdentity¶

Stellt die gespiegelte IDENTITY-Struktur einer Spalte dar, die dem Identity-Konstrukt entspricht.

Die ReflectedIdentity-Struktur ist Teil der ReflectedColumn-Struktur, die von der Inspector.get_columns()-Methode zurückgegeben wird.

Mitglieder

always, cache, cycle, increment, maxvalue, minvalue, nomaxvalue, nominvalue, on_null, order, start

Klassensignatur

class sqlalchemy.engine.interfaces.ReflectedIdentity (builtins.dict)

attribute sqlalchemy.engine.interfaces.ReflectedIdentity.always: bool¶: Art der Identitätsspalte

attribute sqlalchemy.engine.interfaces.ReflectedIdentity.cache: int | None¶: Anzahl der zukünftigen Werte in der Sequenz, die im Voraus berechnet werden.

attribute sqlalchemy.engine.interfaces.ReflectedIdentity.cycle: bool¶: ermöglicht es der Sequenz, umzudrehen, wenn der Maximal- oder Minimalwert erreicht wurde.

attribute sqlalchemy.engine.interfaces.ReflectedIdentity.increment: int¶: Inkrementwert der Sequenz

attribute sqlalchemy.engine.interfaces.ReflectedIdentity.maxvalue: int¶: der Maximalwert der Sequenz.

attribute sqlalchemy.engine.interfaces.ReflectedIdentity.minvalue: int¶: der Minimalwert der Sequenz.

attribute sqlalchemy.engine.interfaces.ReflectedIdentity.nomaxvalue: bool¶: kein Maximalwert der Sequenz.

attribute sqlalchemy.engine.interfaces.ReflectedIdentity.nominvalue: bool¶: kein Minimalwert der Sequenz.

attribute sqlalchemy.engine.interfaces.ReflectedIdentity.on_null: bool¶: zeigt ON NULL an

attribute sqlalchemy.engine.interfaces.ReflectedIdentity.order: bool¶: wenn wahr, wird das Schlüsselwort ORDER gerendert.

attribute sqlalchemy.engine.interfaces.ReflectedIdentity.start: int¶: Startindex der Sequenz

class sqlalchemy.engine.interfaces.ReflectedIndex¶

Wörterbuch, das die gespiegelten Elemente darstellt, die Index entsprechen.

Die ReflectedIndex-Struktur wird von der Inspector.get_indexes()-Methode zurückgegeben.

Mitglieder

column_names, column_sorting, dialect_options, duplicates_constraint, expressions, include_columns, name, unique

Klassensignatur

class sqlalchemy.engine.interfaces.ReflectedIndex (builtins.dict)

attribute sqlalchemy.engine.interfaces.ReflectedIndex.column_names: List[str | None]¶: Spaltennamen, auf die der Index verweist. Ein Element dieser Liste ist None, wenn es sich um einen Ausdruck handelt, und wird in der Liste expressions zurückgegeben.

attribute sqlalchemy.engine.interfaces.ReflectedIndex.column_sorting: NotRequired[Dict[str, Tuple[str]]]¶: optionales Wörterbuch, das Spaltennamen oder Ausdrücke auf Tupel von Sortierschlüssel abbildet, welche asc, desc, nulls_first, nulls_last enthalten können.

Neu in Version 1.3.5.

attribute sqlalchemy.engine.interfaces.ReflectedIndex.dialect_options: NotRequired[Dict[str, Any]]¶: Zusätzliche Dialekt-spezifische Optionen, die für diesen Index erkannt wurden

attribute sqlalchemy.engine.interfaces.ReflectedIndex.duplicates_constraint: NotRequired[str | None]¶: Gibt an, ob dieser Index eine Beschränkung mit diesem Namen spiegelt

attribute sqlalchemy.engine.interfaces.ReflectedIndex.expressions: NotRequired[List[str]]¶: Ausdrücke, die den Index bilden. Diese Liste enthält, wenn vorhanden, sowohl einfache Spaltennamen (die sich auch in column_names befinden) als auch Ausdrücke (die in column_names None sind).

attribute sqlalchemy.engine.interfaces.ReflectedIndex.include_columns: NotRequired[List[str]]¶: Spalten, die in der INCLUDE-Klausel für unterstützte Datenbanken enthalten sind.

Veraltet seit Version 2.0: Legacy-Wert, wird ersetzt durch index_dict["dialect_options"]["<dialect name>_include"]

attribute sqlalchemy.engine.interfaces.ReflectedIndex.name: str | None¶: Indexname

attribute sqlalchemy.engine.interfaces.ReflectedIndex.unique: bool¶: ob der Index ein eindeutiges Flag hat oder nicht

class sqlalchemy.engine.interfaces.ReflectedPrimaryKeyConstraint¶

Wörterbuch, das die gespiegelten Elemente darstellt, die PrimaryKeyConstraint entsprechen.

Die ReflectedPrimaryKeyConstraint-Struktur wird von der Inspector.get_pk_constraint()-Methode zurückgegeben.

Mitglieder

constrained_columns, dialect_options

Klassensignatur

class sqlalchemy.engine.interfaces.ReflectedPrimaryKeyConstraint (builtins.dict)

attribute sqlalchemy.engine.interfaces.ReflectedPrimaryKeyConstraint.constrained_columns: List[str]¶: Spaltennamen, aus denen der Primärschlüssel besteht

attribute sqlalchemy.engine.interfaces.ReflectedPrimaryKeyConstraint.dialect_options: NotRequired[Dict[str, Any]]¶: Zusätzliche Dialekt-spezifische Optionen, die für diesen Primärschlüssel erkannt wurden

class sqlalchemy.engine.interfaces.ReflectedUniqueConstraint¶

Wörterbuch, das die gespiegelten Elemente darstellt, die UniqueConstraint entsprechen.

Die ReflectedUniqueConstraint-Struktur wird von der Inspector.get_unique_constraints()-Methode zurückgegeben.

Mitglieder

column_names, dialect_options, duplicates_index

Klassensignatur

class sqlalchemy.engine.interfaces.ReflectedUniqueConstraint (builtins.dict)

attribute sqlalchemy.engine.interfaces.ReflectedUniqueConstraint.column_names: List[str]¶: Spaltennamen, aus denen die eindeutige Beschränkung besteht

attribute sqlalchemy.engine.interfaces.ReflectedUniqueConstraint.dialect_options: NotRequired[Dict[str, Any]]¶: Zusätzliche Dialekt-spezifische Optionen, die für diese eindeutige Beschränkung erkannt wurden

attribute sqlalchemy.engine.interfaces.ReflectedUniqueConstraint.duplicates_index: NotRequired[str | None]¶: Gibt an, ob diese eindeutige Beschränkung einen Index mit diesem Namen dupliziert

class sqlalchemy.engine.interfaces.ReflectedTableComment¶

Wörterbuch, das den gespiegelten Kommentar darstellt, der dem Attribut Table.comment entspricht.

Die ReflectedTableComment-Struktur wird von der Inspector.get_table_comment()-Methode zurückgegeben.

Mitglieder

text

Klassensignatur

class sqlalchemy.engine.interfaces.ReflectedTableComment (builtins.dict)

attribute sqlalchemy.engine.interfaces.ReflectedTableComment.text: str | None¶: Text des Kommentars

Reflektieren mit datenbankunabhängigen Typen¶

Wenn die Spalten einer Tabelle mit dem Parameter Table.autoload_with von Table oder der Methode Inspector.get_columns() von Inspector reflektiert werden, sind die Datentypen so spezifisch wie möglich für die Zieldatenbank. Das bedeutet, wenn ein „Integer“-Datentyp aus einer MySQL-Datenbank reflektiert wird, wird der Typ durch die Klasse sqlalchemy.dialects.mysql.INTEGER repräsentiert, die MySQL-spezifische Attribute wie „display_width“ enthält. Oder bei PostgreSQL kann ein PostgreSQL-spezifischer Datentyp wie sqlalchemy.dialects.postgresql.INTERVAL oder sqlalchemy.dialects.postgresql.ENUM zurückgegeben werden.

Es gibt einen Anwendungsfall für die Reflexion, nämlich dass eine gegebene Table auf eine andere Datenbank eines anderen Anbieters übertragen werden soll. Um diesem Anwendungsfall gerecht zu werden, gibt es eine Technik, mit der diese anbieterspezifischen Datentypen im laufenden Betrieb in Instanzen von SQLAlchemy-backendunabhängigen Datentypen konvertiert werden können, für die obigen Beispiele Typen wie Integer, Interval und Enum. Dies kann durch Abfangen der Spaltenreflexion mithilfe des DDLEvents.column_reflect()-Ereignisses in Verbindung mit der Methode TypeEngine.as_generic() erreicht werden.

Gegeben eine Tabelle in MySQL (gewählt, weil MySQL viele anbieterspezifische Datentypen und Optionen hat)

CREATE TABLE IF NOT EXISTS my_table (
    id INTEGER PRIMARY KEY AUTO_INCREMENT,
    data1 VARCHAR(50) CHARACTER SET latin1,
    data2 MEDIUMINT(4),
    data3 TINYINT(2)
)

Die obige Tabelle enthält MySQL-exklusive Integer-Typen MEDIUMINT und TINYINT sowie einen VARCHAR, der die MySQL-exklusive Option CHARACTER SET enthält. Wenn wir diese Tabelle normal reflektieren, wird ein Table-Objekt erzeugt, das diese MySQL-spezifischen Datentypen und Optionen enthält.

>>> from sqlalchemy import MetaData, Table, create_engine
>>> mysql_engine = create_engine("mysql+mysqldb://scott:tiger@localhost/test")
>>> metadata_obj = MetaData()
>>> my_mysql_table = Table("my_table", metadata_obj, autoload_with=mysql_engine)

Das obige Beispiel reflektiert das obige Tabellenschema in ein neues Table-Objekt. Wir können dann, zu Demonstrationszwecken, die MySQL-spezifische „CREATE TABLE“-Anweisung mithilfe der CreateTable-Konstruktion ausgeben.

>>> fromsqlalchemy.schemaimportCreateTable>>> print(CreateTable(my_mysql_table).compile(mysql_engine))CREATE TABLE my_table (
id INTEGER(11) NOT NULL AUTO_INCREMENT,
data1 VARCHAR(50) CHARACTER SET latin1,
data2 MEDIUMINT(4),
data3 TINYINT(2),
PRIMARY KEY (id)
)ENGINE=InnoDB DEFAULT CHARSET=utf8mb4

Oben wurden die MySQL-spezifischen Datentypen und Optionen beibehalten. Wenn wir stattdessen eine Table wollten, die sauber auf eine andere Datenbank eines anderen Anbieters übertragen werden kann, und die speziellen Datentypen sqlalchemy.dialects.mysql.MEDIUMINT und sqlalchemy.dialects.mysql.TINYINT durch Integer ersetzen, können wir stattdessen die Datentypen dieser Tabelle „generisieren“ oder auf andere Weise nach Belieben ändern, indem wir einen Handler mit dem DDLEvents.column_reflect()-Ereignis einrichten. Der benutzerdefinierte Handler nutzt die Methode TypeEngine.as_generic(), um die obigen MySQL-spezifischen Typobjekte in generische umzuwandeln, indem der Eintrag "type" innerhalb des Spaltendictonary-Eintrags, der an den Ereignishandler übergeben wird, ersetzt wird. Das Format dieses Dictionaries wird unter Inspector.get_columns() beschrieben.

>>> from sqlalchemy import event
>>> metadata_obj = MetaData()

>>> @event.listens_for(metadata_obj, "column_reflect")
... def genericize_datatypes(inspector, tablename, column_dict):
...     column_dict["type"] = column_dict["type"].as_generic()

>>> my_generic_table = Table("my_table", metadata_obj, autoload_with=mysql_engine)

Wir erhalten nun eine neue Table, die generisch ist und Integer für diese Datentypen verwendet. Wir können nun eine „CREATE TABLE“-Anweisung ausgeben, beispielsweise für eine PostgreSQL-Datenbank.

>>> pg_engine=create_engine("postgresql+psycopg2://scott:tiger@localhost/test",echo=True)>>> my_generic_table.create(pg_engine)CREATE TABLE my_table (
    id SERIAL NOT NULL,
    data1 VARCHAR(50),
    data2 INTEGER,
    data3 INTEGER,
    PRIMARY KEY (id)
)

Beachten Sie außerdem, dass SQLAlchemy in den meisten Fällen gute Annahmen für andere Verhaltensweisen trifft, wie z. B. dass die MySQL-Direktive AUTO_INCREMENT in PostgreSQL am besten durch den SERIAL-Autoincrement-Datentyp dargestellt wird.

Neu in Version 1.4: Methode TypeEngine.as_generic() hinzugefügt und zusätzlich die Verwendung des DDLEvents.column_reflect()-Ereignisses verbessert, sodass es zur Vereinfachung auf ein MetaData-Objekt angewendet werden kann.

Einschränkungen der Reflexion¶

Es ist wichtig zu beachten, dass der Reflexionsprozess Table-Metadaten nur anhand von Informationen wiederherstellt, die in der relationalen Datenbank gespeichert sind. Dieser Prozess kann naturgemäß keine Schemaaspekte wiederherstellen, die nicht tatsächlich in der Datenbank gespeichert sind. Zustände, die nicht über die Reflexion verfügbar sind, umfassen unter anderem:

Clientseitige Standardwerte, entweder Python-Funktionen oder SQL-Ausdrücke, die mit dem Schlüsselwort default von Column definiert wurden (beachten Sie, dass dies von server_default getrennt ist, das spezifisch über die Reflexion verfügbar ist).
Spalteninformationen, z. B. Daten, die möglicherweise in das Column.info-Dictionary aufgenommen wurden.
Der Wert der Einstellung .quote für Column oder Table
Die Zuordnung einer bestimmten Sequence zu einer bestimmten Column.

Die relationale Datenbank meldet in vielen Fällen auch Tabellenmetadaten in einem anderen Format, als sie in SQLAlchemy angegeben wurden. Die von der Reflexion zurückgegebenen Table-Objekte können nicht immer darauf vertrauen, dass sie die identische DDL wie die ursprünglichen Python-definierten Table-Objekte erzeugen. Bereiche, in denen dies auftritt, umfassen Server-Standardwerte, spaltenbezogene Sequenzen und verschiedene Eigenheiten in Bezug auf Beschränkungen und Datentypen. Serverseitige Standardwerte können mit CAST-Direktiven (typischerweise fügt PostgreSQL einen ::<type>-Cast hinzu) oder anderen Anführungszeichenmustern als ursprünglich angegeben zurückgegeben werden.

Eine weitere Kategorie von Einschränkungen umfasst Schemastrukturen, für die die Reflexion nur teilweise oder noch nicht definiert ist. Jüngste Verbesserungen der Reflexion ermöglichen die Reflexion von Dingen wie Views, Indizes und Fremdschlüsseloptionen. Zum Zeitpunkt der Erstellung dieses Dokuments werden Strukturen wie CHECK-Constraints, Tabellenkommentare und Trigger nicht reflektiert.

SQLAlchemy 2.0 Dokumentation

SQLAlchemy 2.0 Dokumentation

SQLAlchemy Core

Projektversionen

Datenbankobjekte spiegeln¶

Überschreiben gespiegelter Spalten¶

Ansichten spiegeln¶

Alle Tabellen auf einmal spiegeln¶

Tabellen aus anderen Schemas spiegeln¶

Interaktion von Schema-qualifizierter Spiegelung mit dem Standard-Schema¶

Feingranulare Spiegelung mit Inspector¶

Reflektieren mit datenbankunabhängigen Typen¶

Einschränkungen der Reflexion¶