Datenbanken mit MetaData beschreiben

Dieser Abschnitt behandelt die grundlegenden Objekte Table, Column und MetaData.

Siehe auch

Mit Datenbank-Metadaten arbeiten - Tutorial-Einführung in das Konzept von SQLAlchemy für Datenbank-Metadaten im SQLAlchemy Unified Tutorial

Eine Sammlung von Metadaten-Entitäten wird in einem passend benannten Objekt MetaData gespeichert.

from sqlalchemy import MetaData

metadata_obj = MetaData()

MetaData ist ein Containerobjekt, das viele verschiedene Merkmale einer (oder mehrerer) zu beschreibenden Datenbanken zusammenhält.

Um eine Tabelle darzustellen, verwenden Sie die Klasse Table. Ihre beiden primären Argumente sind der Tabellenname, gefolgt von dem MetaData-Objekt, mit dem sie verknüpft wird. Die verbleibenden Positionsargumente sind größtenteils Column-Objekte, die jede Spalte beschreiben.

from sqlalchemy import Table, Column, Integer, String

user = Table(
    "user",
    metadata_obj,
    Column("user_id", Integer, primary_key=True),
    Column("user_name", String(16), nullable=False),
    Column("email_address", String(60)),
    Column("nickname", String(50), nullable=False),
)

Oben ist eine Tabelle namens user beschrieben, die vier Spalten enthält. Der Primärschlüssel der Tabelle besteht aus der Spalte user_id. Mehreren Spalten kann das Flag primary_key=True zugewiesen werden, was einen Primärschlüssel aus mehreren Spalten bezeichnet, bekannt als zusammengesetzter Primärschlüssel.

Beachten Sie auch, dass jede Spalte ihren Datentyp mithilfe von Objekten beschreibt, die generischen Typen entsprechen, wie z. B. Integer und String. SQLAlchemy bietet Dutzende von Typen mit unterschiedlichen Spezifitätsgraden sowie die Möglichkeit, benutzerdefinierte Typen zu erstellen. Dokumentation zum Typsystem finden Sie unter SQL Datentyp-Objekte.

Tabellen und Spalten zugreifen

Das Objekt MetaData enthält alle Schema-Konstrukte, die wir ihm zugeordnet haben. Es unterstützt einige Methoden zum Zugriff auf diese Tabellenobjekte, wie z. B. den Accessor sorted_tables, der eine Liste jedes Table-Objekts in der Reihenfolge der Abhängigkeiten von Fremdschlüsseln zurückgibt (d. h., jede Tabelle wird von allen Tabellen, auf die sie verweist, vorangestellt).

>>> for t in metadata_obj.sorted_tables:
...     print(t.name)
user
user_preference
invoice
invoice_item

In den meisten Fällen wurden einzelne Table-Objekte explizit deklariert, und diese Objekte werden typischerweise direkt als Modulebene Variablen in einer Anwendung zugegriffen. Sobald eine Table definiert wurde, verfügt sie über eine vollständige Reihe von Accessoren, die die Inspektion ihrer Eigenschaften ermöglichen. Gegeben die folgende Table-Definition:

employees = Table(
    "employees",
    metadata_obj,
    Column("employee_id", Integer, primary_key=True),
    Column("employee_name", String(60), nullable=False),
    Column("employee_dept", Integer, ForeignKey("departments.department_id")),
)

Beachten Sie das ForeignKey-Objekt, das in dieser Tabelle verwendet wird – diese Konstruktion definiert eine Referenz zu einer entfernten Tabelle und wird vollständig unter Fremdschlüssel definieren beschrieben. Methoden zum Abrufen von Informationen über diese Tabelle umfassen:

# access the column "employee_id":
employees.columns.employee_id

# or just
employees.c.employee_id

# via string
employees.c["employee_id"]

# a tuple of columns may be returned using multiple strings
# (new in 2.0)
emp_id, name, type = employees.c["employee_id", "name", "type"]

# iterate through all columns
for c in employees.c:
    print(c)

# get the table's primary key columns
for primary_key in employees.primary_key:
    print(primary_key)

# get the table's foreign key objects:
for fkey in employees.foreign_keys:
    print(fkey)

# access the table's MetaData:
employees.metadata

# access a column's name, type, nullable, primary key, foreign key
employees.c.employee_id.name
employees.c.employee_id.type
employees.c.employee_id.nullable
employees.c.employee_id.primary_key
employees.c.employee_dept.foreign_keys

# get the "key" of a column, which defaults to its name, but can
# be any user-defined string:
employees.c.employee_name.key

# access a column's table:
employees.c.employee_id.table is employees

# get the table related by a foreign key
list(employees.c.employee_dept.foreign_keys)[0].column.table

Tipp

Die Sammlung FromClause.c, synonym mit der Sammlung FromClause.columns, ist eine Instanz von ColumnCollection, die eine **dictionary-ähnliche Schnittstelle** zur Sammlung von Spalten bietet. Namen werden normalerweise wie Attributnamen zugegriffen, z. B. employees.c.employee_name. Für spezielle Namen mit Leerzeichen oder solche, die mit den Namen von Dictionary-Methoden wie ColumnCollection.keys() oder ColumnCollection.values() übereinstimmen, muss jedoch indizierter Zugriff verwendet werden, wie z. B. employees.c['values'] oder employees.c["some column"]. Weitere Informationen finden Sie unter ColumnCollection.

Datenbanktabellen erstellen und löschen

Sobald Sie einige Table-Objekte definiert haben, und vorausgesetzt, Sie arbeiten mit einer brandneuen Datenbank, möchten Sie vielleicht CREATE-Anweisungen für diese Tabellen und ihre zugehörigen Konstrukte ausgeben (als Nebenbemerkung: Es ist auch gut möglich, dass Sie dies *nicht* tun möchten, wenn Sie bereits bevorzugte Methoden wie Tools, die mit Ihrer Datenbank geliefert werden, oder ein bestehendes Skriptsystem haben – in diesem Fall können Sie diesen Abschnitt gerne überspringen – SQLAlchemy hat keine Anforderung, dass es zur Erstellung Ihrer Tabellen verwendet werden muss).

Der übliche Weg, CREATE auszugeben, ist die Verwendung von create_all() auf dem MetaData-Objekt. Diese Methode gibt Abfragen aus, die zuerst auf die Existenz jeder einzelnen Tabelle prüfen, und wenn sie nicht gefunden wird, werden die CREATE-Anweisungen ausgegeben.

engine = create_engine("sqlite:///:memory:")

metadata_obj = MetaData()

user = Table(
    "user",
    metadata_obj,
    Column("user_id", Integer, primary_key=True),
    Column("user_name", String(16), nullable=False),
    Column("email_address", String(60), key="email"),
    Column("nickname", String(50), nullable=False),
)

user_prefs = Table(
    "user_prefs",
    metadata_obj,
    Column("pref_id", Integer, primary_key=True),
    Column("user_id", Integer, ForeignKey("user.user_id"), nullable=False),
    Column("pref_name", String(40), nullable=False),
    Column("pref_value", String(100)),
)

metadata_obj.create_all(engine)
PRAGMA table_info(user){}
CREATE TABLE user(
        user_id INTEGER NOT NULL PRIMARY KEY,
        user_name VARCHAR(16) NOT NULL,
        email_address VARCHAR(60),
        nickname VARCHAR(50) NOT NULL
)
PRAGMA table_info(user_prefs){}
CREATE TABLE user_prefs(
        pref_id INTEGER NOT NULL PRIMARY KEY,
        user_id INTEGER NOT NULL REFERENCES user(user_id),
        pref_name VARCHAR(40) NOT NULL,
        pref_value VARCHAR(100)
)

create_all() erstellt Fremdschlüsselbeziehungen zwischen Tabellen, normalerweise direkt mit der Tabellendefinition selbst, und aus diesem Grund generiert es auch die Tabellen in der Reihenfolge ihrer Abhängigkeit. Es gibt Optionen, dieses Verhalten zu ändern, so dass stattdessen ALTER TABLE verwendet wird.

Das Löschen aller Tabellen wird ähnlich über die Methode drop_all() erreicht. Diese Methode tut das genaue Gegenteil von create_all() – die Anwesenheit jeder Tabelle wird zuerst geprüft und Tabellen werden in umgekehrter Reihenfolge der Abhängigkeit gelöscht.

Das Erstellen und Löschen einzelner Tabellen kann über die Methoden create() und drop() von Table erfolgen. Diese Methoden geben standardmäßig CREATE oder DROP aus, unabhängig davon, ob die Tabelle vorhanden ist.

engine = create_engine("sqlite:///:memory:")

metadata_obj = MetaData()

employees = Table(
    "employees",
    metadata_obj,
    Column("employee_id", Integer, primary_key=True),
    Column("employee_name", String(60), nullable=False, key="name"),
    Column("employee_dept", Integer, ForeignKey("departments.department_id")),
)
employees.create(engine)
CREATE TABLE employees(
    employee_id SERIAL NOT NULL PRIMARY KEY,
    employee_name VARCHAR(60) NOT NULL,
    employee_dept INTEGER REFERENCES departments(department_id)
)
{}

drop() Methode

employees.drop(engine)
DROP TABLE employees
{}

Um die Logik "zuerst prüfen, ob die Tabelle existiert" zu aktivieren, fügen Sie das Argument checkfirst=True zu create() oder drop() hinzu.

employees.create(engine, checkfirst=True)
employees.drop(engine, checkfirst=False)

Datenbankobjekte durch Migrationen ändern

Während SQLAlchemy direkt das Ausgeben von CREATE- und DROP-Anweisungen für Schema-Konstrukte unterstützt, liegt die Fähigkeit, diese Konstrukte zu ändern, normalerweise über die ALTER-Anweisung sowie andere datenbankspezifische Konstrukte, außerhalb des Geltungsbereichs von SQLAlchemy selbst. Obwohl es einfach genug ist, ALTER-Anweisungen und ähnliches von Hand auszugeben, z. B. durch Übergabe eines text()-Konstrukts an Connection.execute() oder durch Verwendung des DDL-Konstrukts, ist es üblich, die Wartung von Datenbankschemata in Bezug auf Anwendungscode mithilfe von Schema-Migrationswerkzeugen zu automatisieren.

Das SQLAlchemy-Projekt bietet das Migrationswerkzeug Alembic für diesen Zweck. Alembic verfügt über eine hochgradig anpassbare Umgebung und ein minimalistisches Nutzungsmuster, das Funktionen wie transaktionale DDL, automatische Generierung von "Kandidaten"-Migrationen, einen "Offline"-Modus, der SQL-Skripte generiert, und Unterstützung für Branch-Auflösung unterstützt.

Alembic löst das Projekt SQLAlchemy-Migrate ab, das das ursprüngliche Migrationswerkzeug für SQLAlchemy ist und jetzt als veraltet gilt.

Den Schemanamen angeben

Die meisten Datenbanken unterstützen das Konzept mehrerer "Schemata" – Namensräume, die alternative Sätze von Tabellen und anderen Konstrukten referenzieren. Die serverseitige Geometrie eines "Schemas" nimmt viele Formen an, darunter Namen von "Schemata" im Geltungsbereich einer bestimmten Datenbank (z. B. PostgreSQL-Schemata), benannte Geschwisterdatenbanken (z. B. MySQL / MariaDB-Zugriff auf andere Datenbanken auf demselben Server) sowie andere Konzepte wie Tabellen, die anderen Benutzernamen gehören (Oracle Database, SQL Server) oder sogar Namen, die auf alternative Datenbankdateien (SQLite ATTACH) oder entfernte Server (Oracle Database DBLINK mit Synonymen) verweisen.

Was alle oben genannten Ansätze (meistens) gemeinsam haben, ist, dass es eine Möglichkeit gibt, diesen alternativen Satz von Tabellen mit einem String-Namen zu referenzieren. SQLAlchemy bezeichnet diesen Namen als **Schemanamen**. Innerhalb von SQLAlchemy ist dies nichts weiter als ein String-Name, der mit einem Table-Objekt verknüpft ist und dann auf eine für die Zielbank geeignete Weise in SQL-Anweisungen gerendert wird, sodass die Tabelle in ihrem entfernten "Schema" referenziert wird, was auch immer dieser Mechanismus auf der Zielbank sein mag.

Der "Schema"-Name kann direkt mit einer Table über das Argument Table.schema verknüpft werden; wenn ORM mit deklarativer Tabelle-Konfiguration verwendet wird, wird der Parameter über das __table_args__-Parameterwörterbuch übergeben.

Der "Schema"-Name kann auch dem Objekt MetaData zugeordnet werden, wo er automatisch für alle Table-Objekte gilt, die diesem MetaData zugeordnet sind und die nicht anderweitig ihren eigenen Namen angeben. Schließlich unterstützt SQLAlchemy auch ein dynamisches Schema-Namenssystem, das häufig für Multi-Tenant-Anwendungen verwendet wird, sodass eine einzelne Menge von Table-Metadaten auf Basis pro Verbindung oder pro Anweisung dynamisch konfigurierte Schemanamen referenzieren kann.

Was ist "Schema"?

SQLAlchemy's Unterstützung für Datenbank-"Schemata" wurde mit direkter Unterstützung für PostgreSQL-ähnliche Schemata entwickelt. In diesem Stil gibt es zuerst eine "Datenbank", die typischerweise einen einzigen "Besitzer" hat. Innerhalb dieser Datenbank kann es eine beliebige Anzahl von "Schemata" geben, die dann die eigentlichen Tabellenobjekte enthalten.

Eine Tabelle innerhalb eines bestimmten Schemas wird explizit unter der Syntax "<schemaname>.<tabellenname>" referenziert. Im Gegensatz dazu steht eine Architektur wie die von MySQL, wo es nur "Datenbanken" gibt, jedoch SQL-Anweisungen mehrere Datenbanken gleichzeitig referenzieren können, wobei die gleiche Syntax verwendet wird, außer dass es "<datenbank>.<tabellenname>" ist. Auf Oracle Database bezieht sich diese Syntax auf noch ein anderes Konzept, den "Besitzer" einer Tabelle. Unabhängig davon, welche Art von Datenbank verwendet wird, verwendet SQLAlchemy den Ausdruck "Schema", um den qualifizierenden Bezeichner innerhalb der allgemeinen Syntax von "<qualifier>.<tablename>" zu bezeichnen.

Siehe auch

Expliziter Schemaname mit deklarativer Tabelle - Schemanamensspezifikation bei Verwendung der ORM deklarativer Tabelle-Konfiguration

Das grundlegendste Beispiel ist das des Arguments Table.schema unter Verwendung eines Core Table-Objekts wie folgt:

metadata_obj = MetaData()

financial_info = Table(
    "financial_info",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("value", String(100), nullable=False),
    schema="remote_banks",
)

SQL, das mit dieser Table gerendert wird, wie z. B. die unten stehende SELECT-Anweisung, qualifiziert den Tabellennamen financial_info explizit mit dem Schemanamen remote_banks.

>>> print(select(financial_info))
SELECT remote_banks.financial_info.id, remote_banks.financial_info.value
FROM remote_banks.financial_info

Wenn ein Table-Objekt mit einem expliziten Schemanamen deklariert wird, wird es im internen MetaData-Namensraum unter Verwendung der Kombination aus Schema- und Tabellennamen gespeichert. Wir können dies in der Sammlung MetaData.tables sehen, indem wir nach dem Schlüssel 'remote_banks.financial_info' suchen.

>>> metadata_obj.tables["remote_banks.financial_info"]
Table('financial_info', MetaData(),
Column('id', Integer(), table=<financial_info>, primary_key=True, nullable=False),
Column('value', String(length=100), table=<financial_info>, nullable=False),
schema='remote_banks')

Dieser Punkt-Name ist auch das, was verwendet werden muss, wenn auf die Tabelle für die Verwendung mit den Objekten ForeignKey oder ForeignKeyConstraint verwiesen wird, auch wenn die referenzierende Tabelle sich ebenfalls in demselben Schema befindet.

customer = Table(
    "customer",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("financial_info_id", ForeignKey("remote_banks.financial_info.id")),
    schema="remote_banks",
)

Das Argument Table.schema kann auch mit bestimmten Dialekten verwendet werden, um einen mehrteiligen (z. B. gepunkteten) Pfad zu einer bestimmten Tabelle anzugeben. Dies ist besonders wichtig bei einer Datenbank wie Microsoft SQL Server, wo es oft gepunktete "Datenbank/Besitzer"-Tokens gibt. Die Tokens können direkt in den Namen auf einmal platziert werden, wie z. B.

schema = "dbo.scott"

Siehe auch

Mehrteilige Schemanamen - beschreibt die Verwendung von gepunkteten Schemanamen mit dem SQL Server-Dialekt.

Tabellen aus anderen Schemata reflektieren

Einen Standard-Schemanamen mit MetaData angeben

Das Objekt MetaData kann auch eine explizite Standardoption für alle Parameter Table.schema festlegen, indem das Argument MetaData.schema an die oberste Ebene der MetaData-Konstruktion übergeben wird.

metadata_obj = MetaData(schema="remote_banks")

financial_info = Table(
    "financial_info",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("value", String(100), nullable=False),
)

Oben, für jedes Table-Objekt (oder Sequence-Objekt, das direkt mit MetaData verbunden ist), das den Parameter Table.schema auf seinem Standardwert None belässt, wird stattdessen so agiert, als wäre der Parameter auf den Wert "remote_banks" gesetzt. Dies schließt ein, dass die Table im MetaData unter dem Schema-qualifizierten Namen katalogisiert wird, d.h.

metadata_obj.tables["remote_banks.financial_info"]

Bei der Verwendung der Objekte ForeignKey oder ForeignKeyConstraint, um auf diese Tabelle zu verweisen, kann entweder der Schema-qualifizierte Name oder der nicht-Schema-qualifizierte Name verwendet werden, um auf die Tabelle remote_banks.financial_info zu verweisen.

# either will work:

refers_to_financial_info = Table(
    "refers_to_financial_info",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("fiid", ForeignKey("financial_info.id")),
)


# or

refers_to_financial_info = Table(
    "refers_to_financial_info",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("fiid", ForeignKey("remote_banks.financial_info.id")),
)

Bei Verwendung eines MetaData-Objekts, das MetaData.schema festlegt, kann eine Table, die angeben möchte, dass sie nicht Schema-qualifiziert werden soll, das spezielle Symbol BLANK_SCHEMA verwenden.

from sqlalchemy import BLANK_SCHEMA

metadata_obj = MetaData(schema="remote_banks")

financial_info = Table(
    "financial_info",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("value", String(100), nullable=False),
    schema=BLANK_SCHEMA,  # will not use "remote_banks"
)

Siehe auch

MetaData.schema

Dynamische Schemanamenskonventionen anwenden

Die vom Parameter Table.schema verwendeten Namen können auch auf eine Nachschlagefunktion angewendet werden, die dynamisch pro Verbindung oder pro Ausführungsebene ist, sodass beispielsweise in Multi-Tenant-Situationen jede Transaktion oder Anweisung auf bestimmte Schemanamen abzielen kann, die sich ändern. Der Abschnitt Übersetzung von Schemanamen beschreibt, wie diese Funktion verwendet wird.

Siehe auch

Übersetzung von Schemanamen

Ein Standard-Schema für neue Verbindungen festlegen

Die oben genannten Ansätze beziehen sich alle auf Methoden zur Einbeziehung eines expliziten Schema-Namens in SQL-Anweisungen. Datenbankverbindungen haben tatsächlich das Konzept eines "Standard"-Schemas, das ist der Name des "Schemas" (oder der Datenbank, des Besitzers usw.), der gilt, wenn ein Tabellenname nicht explizit Schema-qualifiziert ist. Diese Namen werden normalerweise auf Login-Ebene konfiguriert, z. B. beim Verbinden mit einer PostgreSQL-Datenbank, das Standard-"Schema" heißt "public".

Es gibt oft Fälle, in denen das Standard-"Schema" nicht über den Login selbst konfiguriert werden kann und stattdessen nützlicherweise jedes Mal, wenn eine Verbindung hergestellt wird, mit einer Anweisung wie "SET SEARCH_PATH" unter PostgreSQL oder "ALTER SESSION" unter Oracle Database konfiguriert werden würde. Diese Ansätze können durch die Verwendung des Ereignisses PoolEvents.connect() erreicht werden, das Zugriff auf die DBAPI-Verbindung hat, wenn sie zum ersten Mal erstellt wird. Zum Beispiel, um die Oracle Database CURRENT_SCHEMA-Variable auf einen alternativen Namen zu setzen:

from sqlalchemy import event
from sqlalchemy import create_engine

engine = create_engine(
    "oracle+oracledb://scott:tiger@localhost:1521?service_name=freepdb1"
)


@event.listens_for(engine, "connect", insert=True)
def set_current_schema(dbapi_connection, connection_record):
    cursor_obj = dbapi_connection.cursor()
    cursor_obj.execute("ALTER SESSION SET CURRENT_SCHEMA=%s" % schema_name)
    cursor_obj.close()

Oben wird der Ereignishandler set_current_schema() sofort ausgeführt, wenn die obige Engine zum ersten Mal eine Verbindung herstellt; da das Ereignis am Anfang der Handler-Liste "eingefügt" wird, wird es auch ausgeführt, bevor die eigenen Ereignishandler des Dialekts ausgeführt werden, insbesondere einschließlich desjenigen, der das "Standard-Schema" für die Verbindung ermittelt.

Für andere Datenbanken konsultieren Sie die Datenbank- und/oder Dialektdokumentation für spezifische Informationen zur Konfiguration von Standard-Schemata.

Geändert in Version 1.4.0b2: Das obige Rezept funktioniert jetzt ohne die Notwendigkeit, zusätzliche Ereignishandler einzurichten.

Siehe auch

Alternative Suchpfade beim Verbinden festlegen - in der Dokumentation des PostgreSQL-Dialekts.

Schemata und Reflexion

Die Schema-Funktion von SQLAlchemy interagiert mit der Tabellenreflexions-Funktion, die unter Datenbankobjekte reflektieren eingeführt wurde. Weitere Details dazu finden Sie im Abschnitt Tabellen aus anderen Schemas reflektieren.

Backend-spezifische Optionen

Table unterstützt datenbankspezifische Optionen. MySQL hat beispielsweise unterschiedliche Tabellen-Backend-Typen, darunter "MyISAM" und "InnoDB". Dies kann mit Table über mysql_engine ausgedrückt werden.

addresses = Table(
    "engine_email_addresses",
    metadata_obj,
    Column("address_id", Integer, primary_key=True),
    Column("remote_user_id", Integer, ForeignKey(users.c.user_id)),
    Column("email_address", String(20)),
    mysql_engine="InnoDB",
)

Andere Backends unterstützen möglicherweise auch Tabellen-Level-Optionen – diese werden in den individuellen Dokumentationsabschnitten für jeden Dialekt beschrieben.

Column, Table, MetaData API

Objektname	Beschreibung
Column	Repräsentiert eine Spalte in einer Datenbanktabelle.
insert_sentinel([name, type_], *, [default, omit_from_statements])	Bietet eine Ersatz- Column, die als dedizierte Insert- Sentinel-Spalte fungiert und effiziente Masseneinfügungen mit deterministischer RETURNING-Sortierung für Tabellen ermöglicht, die ansonsten keine qualifizierenden Primärschlüsselkonfigurationen aufweisen.
MetaData	Eine Sammlung von Table-Objekten und deren zugehörigen Schema-Konstrukten.
SchemaConst	Eine Aufzählung.
SchemaItem	Basisklasse für Elemente, die ein Datenbankschema definieren.
Table	Repräsentiert eine Tabelle in einer Datenbank.

Attribut sqlalchemy.schema.sqlalchemy.schema.sqlalchemy.schema.BLANK_SCHEMA

Bezieht sich auf SchemaConst.BLANK_SCHEMA.

Attribut sqlalchemy.schema.sqlalchemy.schema.sqlalchemy.schema.RETAIN_SCHEMA

Bezieht sich auf SchemaConst.RETAIN_SCHEMA

Klasse sqlalchemy.schema.Column

Repräsentiert eine Spalte in einer Datenbanktabelle.

Mitglieder

__eq__(), __init__(), __le__(), __lt__(), __ne__(), all_(), anon_key_label, anon_label, any_(), argument_for(), asc(), between(), bitwise_and(), bitwise_lshift(), bitwise_not(), bitwise_or(), bitwise_rshift(), bitwise_xor(), bool_op(), cast(), collate(), compare(), compile(), concat(), contains(), copy(), desc(), dialect_kwargs, dialect_options, distinct(), endswith(), expression, foreign_keys, get_children(), icontains(), iendswith(), ilike(), in_(), index, info, inherit_cache, is_(), is_distinct_from(), is_not(), is_not_distinct_from(), isnot(), isnot_distinct_from(), istartswith(), key, kwargs, label(), like(), match(), not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), params(), proxy_set, references(), regexp_match(), regexp_replace(), reverse_operate(), self_group(), shares_lineage(), startswith(), timetuple, unique, unique_params()

Klassensignatur

class sqlalchemy.schema.Column (sqlalchemy.sql.base.DialectKWArgs, sqlalchemy.schema.SchemaItem, sqlalchemy.sql.expression.ColumnClause)

Methode sqlalchemy.schema.Column.__eq__(other: Any) → ColumnOperators

vererbt von der sqlalchemy.sql.expression.ColumnOperators.__eq__ Methode von ColumnOperators

Implementiert den == Operator.

Im Spaltenkontext wird die Klausel a = b erzeugt. Wenn das Ziel None ist, wird a IS NULL erzeugt.

Methode sqlalchemy.schema.Column.__init__(_Column__name_pos: str | _TypeEngineArgument[_T] | SchemaEventTarget | None = None, _Column__type_pos: _TypeEngineArgument[_T] | SchemaEventTarget | None = None, *args: SchemaEventTarget, name: str | None = None, type_: _TypeEngineArgument[_T] | None = None, autoincrement: _AutoIncrementType = 'auto', default: Any | None = _NoArg.NO_ARG, insert_default: Any | None = _NoArg.NO_ARG, doc: str | None = None, key: str | None = None, index: bool | None = None, unique: bool | None = None, info: _InfoType | None = None, nullable: bool | Literal[SchemaConst.NULL_UNSPECIFIED] | None = SchemaConst.NULL_UNSPECIFIED, onupdate: Any | None = None, primary_key: bool = False, server_default: _ServerDefaultArgument | None = None, server_onupdate: _ServerOnUpdateArgument | None = None, quote: bool | None = None, system: bool = False, comment: str | None = None, insert_sentinel: bool = False, _omit_from_statements: bool = False, _proxies: Any | None = None, **dialect_kwargs: Any)

Erstellt ein neues Column Objekt.

Parameter:

• name –

  Der Name dieser Spalte, wie er in der Datenbank dargestellt wird. Dieses Argument kann das erste Positionsargument sein oder über ein Schlüsselwort angegeben werden.

  Namen, die keine Großbuchstaben enthalten, werden als case-insensitive Namen behandelt und nicht zitiert, es sei denn, sie sind ein reserviertes Wort. Namen mit beliebig vielen Großbuchstaben werden zitiert und exakt übertragen. Beachten Sie, dass dieses Verhalten auch für Datenbanken gilt, die Großbuchstaben standardmäßig als case-insensitive behandeln, wie z. B. Oracle Database.

  Das Feld name kann zum Zeitpunkt der Erstellung ausgelassen und später, jederzeit bevor die Spalte einer Table zugeordnet wird, angewendet werden. Dies dient zur Unterstützung einer bequemen Verwendung innerhalb der declarative-Erweiterung.

• type_ –

  Der Typ der Spalte, angegeben durch eine Instanz, die von TypeEngine erbt. Wenn für den Typ keine Argumente erforderlich sind, kann auch die Klasse des Typs übergeben werden, z. B.

  # use a type with arguments
  Column("data", String(50))
  
  # use no arguments
  Column("level", Integer)

  Das Argument type kann das zweite Positionsargument sein oder als Schlüsselwort angegeben werden.

  Wenn der type None ist oder ausgelassen wird, wird er standardmäßig auf den speziellen Typ NullType gesetzt. Wenn und sobald diese Column mit einer anderen Spalte über ForeignKey und/oder ForeignKeyConstraint referenziert wird, wird der Typ der ferner referenzierten Spalte zu diesem Zeitpunkt in diese Spalte kopiert, wenn der Fremdschlüssel gegen dieses ferne Column-Objekt aufgelöst wird.

• *args – Zusätzliche Positionsargumente umfassen verschiedene von SchemaItem abgeleitete Konstrukte, die als Optionen für die Spalte angewendet werden. Dazu gehören Instanzen von Constraint, ForeignKey, ColumnDefault, Sequence, Computed Identity. In einigen Fällen ist ein äquivalentes Schlüsselwortargument verfügbar, wie z. B. server_default, default und unique.

• autoincrement –

  Richtet die "Auto-Inkrement"-Semantik für eine **Integer-Primärschlüsselspalte ohne Fremdschlüsselabhängigkeiten** ein (siehe weiter unten in dieser Docstring für eine genauere Definition). Dies kann die DDL beeinflussen, die für diese Spalte während einer Tabellenerstellung ausgegeben wird, sowie wie die Spalte bei der Kompilierung und Ausführung von INSERT-Anweisungen berücksichtigt wird.

  Der Standardwert ist der String "auto", was bedeutet, dass einzeilige (d.h. nicht zusammengesetzte) Primärschlüssel vom Typ INTEGER ohne andere client- oder serverseitige Standardkonstrukte automatisch Auto-Inkrement-Semantik erhalten. Andere Werte sind True (erzwingt Auto-Inkrement-Semantik für diese Spalte auch für einen zusammengesetzten Primärschlüssel), False (diese Spalte sollte niemals Auto-Inkrement-Semantik haben) und der String "ignore_fk" (Sonderfall für Fremdschlüsselspalten, siehe unten).

  Der Begriff „Auto-Inkrement-Semantik“ bezieht sich sowohl auf die Art der DDL, die für die Spalte in einer CREATE TABLE-Anweisung ausgegeben wird, wenn Methoden wie MetaData.create_all() und Table.create() aufgerufen werden, als auch darauf, wie die Spalte bei der Kompilierung und Ausgabe einer INSERT-Anweisung an die Datenbank berücksichtigt wird.

  • DDL-Rendering (d. h. MetaData.create_all(), Table.create()): Wenn dies auf einer Column verwendet wird, die kein anderes Standard-generierendes Konstrukt zugeordnet hat (wie z. B. eine Sequence oder ein Identity-Konstrukt), impliziert der Parameter, dass datenbankspezifische Schlüsselwörter wie PostgreSQL SERIAL, MySQL AUTO_INCREMENT oder IDENTITY auf SQL Server ebenfalls gerendert werden sollten. Nicht jedes Backend hat einen „impliziten“ Standardgenerator; z. B. benötigen Oracle Database Backends immer ein explizites Konstrukt wie Identity, das mit einer Column verknüpft ist, damit die gerenderte DDL auch Auto-generierende Konstrukte in der Datenbank enthält.

  • INSERT-Semantik (d. h. wenn ein insert()-Konstrukt in eine SQL-Zeichenkette kompiliert und dann mit Connection.execute() oder einem Äquivalent an eine Datenbank übergeben wird): Eine einzeilige INSERT-Anweisung wird automatisch einen neuen Integer-Primärschlüsselwert für diese Spalte erzeugen, der nach Ausführung der Anweisung über das Attribut CursorResult.inserted_primary_key des Result-Objekts zugänglich ist. Dies gilt auch für die Verwendung des ORM, wenn ORM-gemappte Objekte in die Datenbank persistiert werden, was bedeutet, dass ein neuer Integer-Primärschlüssel für den Identitätsschlüssel dieses Objekts verfügbar sein wird. Dieses Verhalten tritt unabhängig davon auf, welche DDL-Konstrukte der Column zugeordnet sind, und ist unabhängig vom "DDL-Rendering"-Verhalten, das im vorherigen Abschnitt erläutert wurde.

  Der Parameter kann auf True gesetzt werden, um anzuzeigen, dass eine Spalte, die Teil eines zusammengesetzten (d. h. mehrspaltigen) Primärschlüssels ist, Auto-Inkrement-Semantik haben soll, obwohl beachtet werden muss, dass nur eine Spalte innerhalb eines Primärschlüssels diese Einstellung haben kann. Er kann auch auf True gesetzt werden, um Auto-Inkrement-Semantik für eine Spalte anzuzeigen, die eine client- oder serverseitige Standardkonfiguration hat, wobei jedoch zu beachten ist, dass nicht alle Dialekte alle Arten von Standards als „Auto-Inkrement“ unterstützen. Er kann auch auf False für einen einspaltigen Primärschlüssel mit dem Datentyp INTEGER gesetzt werden, um die Auto-Inkrement-Semantik für diese Spalte zu deaktivieren.

  Die Einstellung hat *nur* Auswirkungen auf Spalten, die

  • Integer-basiert sind (d. h. INT, SMALLINT, BIGINT).

  • Teil des Primärschlüssels sind

  • Nicht über ForeignKey auf eine andere Spalte verweisen, es sei denn, der Wert ist als 'ignore_fk' angegeben.

    # turn on autoincrement for this column despite
    # the ForeignKey()
    Column(
        "id",
        ForeignKey("other.id"),
        primary_key=True,
        autoincrement="ignore_fk",
    )

  Es ist normalerweise nicht wünschenswert, "autoincrement" für eine Spalte zu aktivieren, die über einen Fremdschlüssel auf eine andere verweist, da eine solche Spalte auf einen Wert verweisen muss, der von woanders stammt.

  Die Einstellung hat folgende Auswirkungen auf Spalten, die die obigen Kriterien erfüllen:

  • DDL, die für die Spalte ausgegeben wird, wenn die Spalte noch keine Standard-generierende Konstruktion enthält, die vom Backend unterstützt wird (wie z. B. Identity), enthält datenbankspezifische Schlüsselwörter, die diese Spalte für bestimmte Backends als "Autoincrement"-Spalte kennzeichnen. Das Verhalten für primäre SQLAlchemy-Dialekte umfasst:

    • AUTO INCREMENT bei MySQL und MariaDB

    • SERIAL bei PostgreSQL

    • IDENTITY bei MS-SQL – dies geschieht auch ohne das Identity-Konstrukt, da der Parameter Column.autoincrement vor diesem Konstrukt existiert.

    • SQLite - SQLite Integer-Primärschlüsselspalten sind implizit „automatisch inkrementierend“, und es werden keine zusätzlichen Schlüsselwörter gerendert. Um das spezielle SQLite-Schlüsselwort AUTOINCREMENT zu rendern, ist dieses nicht enthalten, da es unnötig ist und vom Datenbankanbieter nicht empfohlen wird. Weitere Informationen finden Sie im Abschnitt SQLite Auto Incrementing Behavior.

    • Oracle Database - Die Oracle Database-Dialekte haben derzeit keine standardmäßige „autoincrement“-Funktion. Stattdessen wird die Identity-Konstruktion empfohlen, um dies zu erreichen (die Sequence-Konstruktion kann ebenfalls verwendet werden).

    • Drittanbieter-Dialekte - Konsultieren Sie die Dokumentation dieser Dialekte für Details zu ihren spezifischen Verhaltensweisen.

  • Wenn eine Einzeilen-insert()-Konstruktion kompiliert und ausgeführt wird, die nicht den Insert.inline()-Modifikator setzt, werden neu generierte Primärschlüsselwerte für diese Spalte automatisch nach der Ausführung der Anweisung mithilfe einer spezifischen Methode des verwendeten Datenbanktreibers abgerufen.

    • MySQL, SQLite - Aufruf von cursor.lastrowid() (siehe https://pythonlang.de/dev/peps/pep-0249/#lastrowid)

    • PostgreSQL, SQL Server, Oracle Database - Verwenden Sie RETURNING oder eine äquivalente Konstruktion beim Rendern einer INSERT-Anweisung und rufen Sie dann die neu generierten Primärschlüsselwerte nach der Ausführung ab.

    • PostgreSQL, Oracle Database für Table-Objekte, die Table.implicit_returning auf False setzen - nur für eine Sequence wird die Sequence explizit vor der INSERT-Anweisung aufgerufen, damit der neu generierte Primärschlüsselwert für den Client verfügbar ist.

    • SQL Server für Table-Objekte, die Table.implicit_returning auf False setzen - die SELECT scope_identity()-Konstruktion wird nach der Invokation der INSERT-Anweisung verwendet, um den neu generierten Primärschlüsselwert abzurufen.

    • Drittanbieter-Dialekte - Konsultieren Sie die Dokumentation dieser Dialekte für Details zu ihren spezifischen Verhaltensweisen.

  • Für mehrzeilige insert()-Konstruktionen, die mit einer Liste von Parametern aufgerufen werden (d. h. „executemany“-Semantik), sind die Verhaltensweisen zum Abrufen von Primärschlüsseln im Allgemeinen deaktiviert. Es können jedoch spezielle APIs vorhanden sein, die zum Abrufen von Listen neuer Primärschlüsselwerte für ein „executemany“ verwendet werden können, wie z. B. die „fast insertmany“-Funktion von psycopg2. Solche Funktionen sind sehr neu und sind möglicherweise noch nicht gut in der Dokumentation abgedeckt.

• default –

  Ein Skalarwert, eine Python-Callable oder eine ColumnElement-Expression, die den *Standardwert* für diese Spalte darstellt und bei einer Einfügung aufgerufen wird, wenn diese Spalte sonst nicht in der VALUES-Klausel der Einfügung angegeben ist. Dies ist eine Abkürzung zur Verwendung von ColumnDefault als positionelles Argument; siehe diese Klasse für vollständige Details zur Struktur des Arguments.

  Stellen Sie dieses Argument Column.server_default gegenüber, das einen Standardwertgenerator auf der Datenbankseite erstellt.

  Siehe auch

  Column INSERT/UPDATE Defaults

• insert_default –

  Ein Alias von Column.default zur Kompatibilität mit mapped_column().

• doc – Optionaler String, der von der ORM oder ähnlichem zur Dokumentation von Attributen auf der Python-Seite verwendet werden kann. Dieses Attribut rendert **keine** SQL-Kommentare; verwenden Sie zu diesem Zweck den Parameter Column.comment.

• key – Ein optionaler String-Identifier, der dieses Column-Objekt auf der Table identifiziert. Wenn ein Schlüssel angegeben wird, ist dies die einzige Kennung, die die Column innerhalb der Anwendung, einschließlich der ORM-Attributzuordnung, referenziert; das Feld name wird nur beim Rendern von SQL verwendet.

• index –

  Wenn True, zeigt an, dass für diese Column automatisch eine Index-Konstruktion generiert wird, was zu einer „CREATE INDEX“-Anweisung für die Table führt, wenn die DDL-Erstellungsoperation aufgerufen wird.

  Die Verwendung dieser Flagge ist gleichbedeutend mit der expliziten Verwendung der Index-Konstruktion auf der Ebene der Table-Konstruktion selbst.

  Table(
      "some_table",
      metadata,
      Column("x", Integer),
      Index("ix_some_table_x", "x"),
  )

  Um die Flagge Index.unique zur Index hinzuzufügen, setzen Sie gleichzeitig sowohl die Flaggen Column.unique als auch Column.index auf True, was dazu führt, dass die DDL-Anweisung „CREATE UNIQUE INDEX“ anstelle von „CREATE INDEX“ gerendert wird.

  Der Name des Indexes wird mithilfe der Standard-Namenskonvention generiert, die für die Index-Konstruktion die Form ix_<tablename>_<columnname> hat.

  Da diese Flagge nur als Bequemlichkeit für den üblichen Fall gedacht ist, einen einzelnen Spaltenindex mit Standardkonfiguration zu einer Tabellendefinition hinzuzufügen, sollte für die meisten Anwendungsfälle die explizite Verwendung der Index-Konstruktion bevorzugt werden, einschließlich zusammengesetzter Indizes, die mehr als eine Spalte umfassen, Indizes mit SQL-Ausdrücken oder Sortierung, Backend-spezifischen Indexkonfigurationsoptionen und Indizes, die einen bestimmten Namen verwenden.

  Hinweis

  Das Attribut Column.index auf Column **zeigt nicht an**, ob diese Spalte indiziert ist oder nicht, sondern nur, ob diese Flagge hier explizit gesetzt wurde. Um Indizes für eine Spalte anzuzeigen, sehen Sie die Sammlung Table.indexes an oder verwenden Sie Inspector.get_indexes().

  Siehe auch

  Indizes

  Konfiguration von Constraint-Namenskonventionen

  Column.unique

• info – Optionales Datenwörterbuch, das in das Attribut SchemaItem.info dieses Objekts eingetragen wird.

• nullable –

  Wenn auf False gesetzt, wird beim Generieren von DDL für die Spalte der Phrasenteil „NOT NULL“ hinzugefügt. Wenn True, wird normalerweise nichts generiert (in SQL ist dies standardmäßig „NULL“), außer in sehr spezifischen Backend-spezifischen Ausnahmefällen, bei denen „NULL“ explizit gerendert werden kann. Standardmäßig True, es sei denn, Column.primary_key ist ebenfalls True oder die Spalte gibt eine Identity an, in welchem Fall der Standardwert False ist. Dieser Parameter wird nur bei der Ausgabe von CREATE TABLE-Anweisungen verwendet.

  Hinweis

  Wenn die Spalte eine Identity angibt, wird dieser Parameter vom DDL-Compiler im Allgemeinen ignoriert. Die PostgreSQL-Datenbank erlaubt nullable Identitätsspalten, indem dieser Parameter explizit auf True gesetzt wird.

• onupdate –

  Ein Skalarwert, ein Python-Callable oder eine ClauseElement, die einen Standardwert für die Spalte in UPDATE-Anweisungen darstellt und bei einer Aktualisierung aufgerufen wird, wenn diese Spalte nicht in der SET-Klausel des Updates enthalten ist. Dies ist eine Abkürzung zur Verwendung von ColumnDefault als positionelles Argument mit for_update=True.

  Siehe auch

  Column INSERT/UPDATE Defaults - vollständige Diskussion von onupdate

• primary_key – Wenn True, wird diese Spalte als Primärschlüsselspalte markiert. Mehrere Spalten können diese Flagge gesetzt haben, um zusammengesetzte Primärschlüssel zu spezifizieren. Alternativ kann der Primärschlüssel einer Table über ein explizites PrimaryKeyConstraint-Objekt angegeben werden.

• server_default –

  Eine Instanz von FetchedValue, ein String, Unicode oder eine text()-Konstruktion, die den DDL DEFAULT-Wert für die Spalte darstellt.

  String-Typen werden als-is ausgegeben, umgeben von einfachen Anführungszeichen.

  Column("x", Text, server_default="val")

  wird gerendert

  x TEXT DEFAULT 'val'

  Eine text()-Expression wird als-is, ohne Anführungszeichen, gerendert.

  Column("y", DateTime, server_default=text("NOW()"))

  wird gerendert

  y DATETIME DEFAULT NOW()

  Strings und text() werden bei der Initialisierung in ein DefaultClause-Objekt umgewandelt.

  Dieser Parameter kann auch komplexe Kombinationen von kontextuell gültigen SQLAlchemy-Ausdrücken oder -Konstruktionen akzeptieren.

  from sqlalchemy import create_engine
  from sqlalchemy import Table, Column, MetaData, ARRAY, Text
  from sqlalchemy.dialects.postgresql import array
  
  engine = create_engine(
      "postgresql+psycopg2://scott:tiger@localhost/mydatabase"
  )
  metadata_obj = MetaData()
  tbl = Table(
      "foo",
      metadata_obj,
      Column(
          "bar", ARRAY(Text), server_default=array(["biz", "bang", "bash"])
      ),
  )
  metadata_obj.create_all(engine)

  Das obige Ergebnis führt zur Erstellung einer Tabelle mit folgendem SQL:

  CREATE TABLE foo (
      bar TEXT[] DEFAULT ARRAY['biz', 'bang', 'bash']
  )

  Verwenden Sie FetchedValue, um anzugeben, dass eine bereits vorhandene Spalte einen Standardwert auf der Datenbankseite generiert, der SQLAlchemy zum Nachholen nach Einfügungen zur Verfügung steht. Diese Konstruktion gibt keine DDL an, und die Implementierung bleibt der Datenbank überlassen, z. B. über einen Trigger.

  Siehe auch

  Server-invoked DDL-Explicit Default Expressions - vollständige Diskussion von serverseitigen Standardwerten

• server_onupdate –

  Eine Instanz von FetchedValue, die eine datenbankseitige Standardgenerierungsfunktion, wie z. B. einen Trigger, darstellt. Dies zeigt SQLAlchemy an, dass ein neu generierter Wert nach Aktualisierungen verfügbar sein wird. Diese Konstruktion implementiert keine Generierungsfunktion in der Datenbank, die stattdessen separat angegeben werden muss.

  Warnung

  Diese Direktive erzeugt derzeit **nicht** die MySQL-Klausel „ON UPDATE CURRENT_TIMESTAMP()“. Siehe Rendering ON UPDATE CURRENT TIMESTAMP für MySQL / MariaDBs explicit_defaults_for_timestamp für Hintergrundinformationen, wie diese Klausel erzeugt wird.

  Siehe auch

  Markieren von implizit generierten Werten, Zeitstempeln und getriggerten Spalten

• quote – Erzwingt das Quoting des Namens dieser Spalte ein oder aus, entsprechend True oder False. Wenn der Standardwert None beibehalten wird, wird der Spaltenbezeichner gemäß der Groß-/Kleinschreibung (Bezeichner mit mindestens einem Großbuchstaben werden als groß-/kleinschreibungsempfindlich behandelt) oder ob es sich um ein reserviertes Wort handelt, gequotet. Diese Flagge ist nur erforderlich, um ein reserviertes Wort zu quoten, das dem SQLAlchemy-Dialekt nicht bekannt ist.

• unique –

  Wenn True und der Parameter Column.index auf seinem Standardwert False belassen wird, zeigt dies an, dass für diese Column automatisch eine UniqueConstraint-Konstruktion generiert wird, was dazu führt, dass eine Klausel „UNIQUE CONSTRAINT“, die sich auf diese Spalte bezieht, in die CREATE TABLE-Anweisung aufgenommen wird, wenn die DDL-Erstellungsoperation für das Table-Objekt aufgerufen wird.

  Wenn diese Flagge True ist, während der Parameter Column.index gleichzeitig auf True gesetzt ist, wird stattdessen eine Index-Konstruktion generiert, die den Parameter Index.unique auf True gesetzt hat. Weitere Details finden Sie in der Dokumentation zu Column.index.

  Die Verwendung dieser Flagge ist gleichbedeutend mit der expliziten Verwendung der UniqueConstraint-Konstruktion auf der Ebene der Table-Konstruktion selbst.

  Table("some_table", metadata, Column("x", Integer), UniqueConstraint("x"))

  Der Parameter UniqueConstraint.name des eindeutigen Constraint-Objekts wird auf seinem Standardwert None belassen; in Abwesenheit einer Namenskonvention für die umschließende MetaData wird die UNIQUE CONSTRAINT-Konstruktion unbenannt ausgegeben, was typischerweise eine datenbankspezifische Namenskonvention aufruft.

  Da diese Flagge nur als Bequemlichkeit für den üblichen Fall gedacht ist, eine einzelne Spalte mit Standardkonfiguration zu einer Tabellendefinition hinzuzufügen, sollte für die meisten Anwendungsfälle die explizite Verwendung der UniqueConstraint-Konstruktion bevorzugt werden, einschließlich zusammengesetzter Constraints, die mehr als eine Spalte umfassen, Backend-spezifischer Indexkonfigurationsoptionen und Constraints, die einen bestimmten Namen verwenden.

  Hinweis

  Das Attribut Column.unique auf Column **zeigt nicht an**, ob diese Spalte einen eindeutigen Constraint hat oder nicht, sondern nur, ob diese Flagge hier explizit gesetzt wurde. Um Indizes und eindeutige Constraints anzuzeigen, die diese Spalte betreffen könnten, sehen Sie die Sammlungen Table.indexes und/oder Table.constraints an oder verwenden Sie Inspector.get_indexes() und/oder Inspector.get_unique_constraints().

  Siehe auch

  UNIQUE Constraint

  Konfiguration von Constraint-Namenskonventionen

  Column.index

• system –

  Wenn True, zeigt dies an, dass es sich um eine „System“-Spalte handelt, d. h. eine Spalte, die von der Datenbank automatisch zur Verfügung gestellt wird und nicht in die Spaltenliste für eine CREATE TABLE-Anweisung aufgenommen werden sollte.

  Für aufwändigere Szenarien, in denen Spalten auf verschiedenen Backends bedingt unterschiedlich gerendert werden sollen, sollten Sie benutzerdefinierte Kompilierungsregeln für CreateColumn in Betracht ziehen.

• comment –

  Optionaler String, der beim Erstellen der Tabelle einen SQL-Kommentar rendert.

  Neu in Version 1.2: Der Parameter Column.comment wurde zu Column hinzugefügt.

• insert_sentinel –

  Markiert diese Column als insert sentinel, die zur Leistungsoptimierung der insertmanyvalues-Funktion für Tabellen verwendet wird, die keine geeigneten Primärschlüsselkonfigurationen aufweisen.

  Neu in Version 2.0.10.

  Siehe auch

  insert_sentinel() - ein All-in-One-Helfer zur Deklaration von Sentinel-Spalten.

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

  Konfiguration von Sentinel-Spalten

method sqlalchemy.schema.Column.__le__(other: Any) → ColumnOperators

geerbt von der sqlalchemy.sql.expression.ColumnOperators.__le__ Methode von ColumnOperators

Implementiert den Operator <=.

In einem Spaltenkontext wird die Klausel a <= b erzeugt.

method sqlalchemy.schema.Column.__lt__(other: Any) → ColumnOperators

geerbt von der sqlalchemy.sql.expression.ColumnOperators.__lt__ Methode von ColumnOperators

Implementiert den Operator <.

In einem Spaltenkontext wird die Klausel a < b erzeugt.

method sqlalchemy.schema.Column.__ne__(other: Any) → ColumnOperators

geerbt von der sqlalchemy.sql.expression.ColumnOperators.__ne__ Methode von ColumnOperators

Implementiert den Operator !=.

In einem Spaltenkontext wird die Klausel a != b erzeugt. Wenn das Ziel None ist, wird a IS NOT NULL erzeugt.

method sqlalchemy.schema.Column.all_() → ColumnOperators

geerbt von der ColumnOperators.all_() Methode von ColumnOperators

Erzeugt eine all_()-Klausel gegen das übergeordnete Objekt.

Beispiele finden Sie in der Dokumentation zu all_().

Hinweis

Verwechseln Sie die neuere Methode ColumnOperators.all_() nicht mit der **Legacy**-Version dieser Methode, der Methode Comparator.all(), die spezifisch für ARRAY ist und einen anderen Aufrufstil verwendet.

attribute sqlalchemy.schema.Column.anon_key_label

geerbt von der ColumnElement.anon_key_label Attribut von ColumnElement

Veraltet seit Version 1.4: Das Attribut ColumnElement.anon_key_label ist jetzt privat, und der öffentliche Zugriff ist veraltet.

attribute sqlalchemy.schema.Column.anon_label

geerbt von der ColumnElement.anon_label Attribut von ColumnElement

Veraltet seit Version 1.4: Das Attribut ColumnElement.anon_label ist jetzt privat, und der öffentliche Zugriff ist veraltet.

method sqlalchemy.schema.Column.any_() → ColumnOperators

geerbt von der ColumnOperators.any_() Methode von ColumnOperators

Erzeugt eine any_()-Klausel gegen das übergeordnete Objekt.

Beispiele finden Sie in der Dokumentation zu any_().

Hinweis

Verwechseln Sie die neuere Methode ColumnOperators.any_() nicht mit der **Legacy**-Version dieser Methode, der Methode Comparator.any(), die spezifisch für ARRAY ist und einen anderen Aufrufstil verwendet.

classmethod sqlalchemy.schema.Column.argument_for(dialect_name, argument_name, default)

geerbt von der DialectKWArgs.argument_for() Methode von DialectKWArgs

Fügt eine neue Art von dialektspezifischem Schlüsselwortargument für diese Klasse hinzu.

Z. B.

Index.argument_for("mydialect", "length", None)

some_index = Index("a", "b", mydialect_length=5)

Die Methode DialectKWArgs.argument_for() ist ein pro-Argument-Weg, um zusätzliche Argumente zum Dictionary DefaultDialect.construct_arguments hinzuzufügen. Dieses Dictionary enthält eine Liste von Argumentnamen, die von verschiedenen schema-level Konstrukten im Auftrag eines Dialekts akzeptiert werden.

Neue Dialekte sollten dieses Wörterbuch typischerweise auf einmal als Datenmember der Dialektklasse angeben. Der Anwendungsfall für die ad-hoc-Addition von Argumentnamen ist typischerweise für Endbenutzercode, der auch ein benutzerdefiniertes Kompilierungsschema verwendet, das die zusätzlichen Argumente konsumiert.

Parameter:

• dialect_name – Name eines Dialekts. Der Dialekt muss auffindbar sein, andernfalls wird ein NoSuchModuleError ausgelöst. Der Dialekt muss außerdem eine vorhandene DefaultDialect.construct_arguments Sammlung enthalten, die angibt, dass er am System zur Validierung und Standardisierung von Schlüsselwortargumenten teilnimmt, andernfalls wird ein ArgumentError ausgelöst. Wenn der Dialekt diese Sammlung nicht enthält, kann jedes Schlüsselwortargument bereits für diesen Dialekt angegeben werden. Alle in SQLAlchemy enthaltenen Dialekte enthalten diese Sammlung. Bei Drittanbieter-Dialekten kann die Unterstützung variieren.

• argument_name – Name des Parameters.

• default – Standardwert des Parameters.

method sqlalchemy.schema.Column.asc() → ColumnOperators

geerbt von der ColumnOperators.asc() Methode von ColumnOperators

Erzeugt eine asc() Klausel gegen das übergeordnete Objekt.

method sqlalchemy.schema.Column.between(cleft: Any, cright: Any, symmetric: bool = False) → ColumnOperators

geerbt von der ColumnOperators.between() Methode von ColumnOperators

Erzeugt eine between() Klausel gegen das übergeordnete Objekt, gegeben den unteren und oberen Bereich.

method sqlalchemy.schema.Column.bitwise_and(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_and() Methode von ColumnOperators

Erzeugt eine bitweise AND-Operation, typischerweise über den Operator &.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.schema.Column.bitwise_lshift(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_lshift() Methode von ColumnOperators

Erzeugt eine bitweise LSHIFT-Operation, typischerweise über den Operator <<.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.schema.Column.bitwise_not() → ColumnOperators

geerbt von der ColumnOperators.bitwise_not() Methode von ColumnOperators

Erzeugt eine bitweise NOT-Operation, typischerweise über den Operator ~.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.schema.Column.bitwise_or(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_or() Methode von ColumnOperators

Erzeugt eine bitweise OR-Operation, typischerweise über den Operator |.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.schema.Column.bitwise_rshift(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_rshift() Methode von ColumnOperators

Erzeugt eine bitweise RSHIFT-Operation, typischerweise über den Operator >>.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.schema.Column.bitwise_xor(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_xor() Methode von ColumnOperators

Erzeugt eine bitweise XOR-Operation, typischerweise über den Operator ^ oder # für PostgreSQL.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.schema.Column.bool_op(opstring: str, precedence: int = 0, python_impl: Callable[[...], Any] | None = None) → Callable[[Any], Operators]

geerbt von der Operators.bool_op() Methode von Operators

Gibt einen benutzerdefinierten booleschen Operator zurück.

Diese Methode ist eine Kurzform für den Aufruf von Operators.op() und die Übergabe des Flags Operators.op.is_comparison mit True. Ein wesentlicher Vorteil der Verwendung von Operators.bool_op() ist, dass bei Verwendung von Spaltensymbolen die "boolesche" Natur des zurückgegebenen Ausdrucks für PEP 484 Zwecke vorhanden ist.

Siehe auch

Operators.op()

method sqlalchemy.schema.Column.cast(type_: _TypeEngineArgument[_OPT]) → Cast[_OPT]

geerbt von der ColumnElement.cast() Methode von ColumnElement

Erzeugt eine Typumwandlung, d. h. CAST(<expression> AS <type>).

Dies ist eine Abkürzung zur Funktion cast().

Siehe auch

Datentypumwandlungen und Typkoerzion

cast()

type_coerce()

method sqlalchemy.schema.Column.collate(collation: str) → ColumnOperators

geerbt von der ColumnOperators.collate() Methode von ColumnOperators

Erzeugt eine collate() Klausel gegen das übergeordnete Objekt, gegeben den Kollationsstring.

Siehe auch

collate()

method sqlalchemy.schema.Column.compare(other: ClauseElement, **kw: Any) → bool

Geerbt von der ClauseElement.compare() Methode von ClauseElement

Vergleicht dieses ClauseElement mit dem gegebenen ClauseElement.

Unterklassen sollten das Standardverhalten überschreiben, das ein direkter Identitätsvergleich ist.

**kw sind Argumente, die von den `compare()`-Methoden von Unterklassen verwendet werden und zur Modifizierung der Vergleichskriterien verwendet werden können (siehe ColumnElement).

method sqlalchemy.schema.Column.compile(bind: _HasDialect | None = None, dialect: Dialect | None = None, **kw: Any) → Compiled

geerbt von der CompilerElement.compile() Methode von CompilerElement

Kompiliert diesen SQL-Ausdruck.

Der Rückgabewert ist ein Compiled Objekt. Das Aufrufen von str() oder unicode() auf dem zurückgegebenen Wert ergibt eine String-Repräsentation des Ergebnisses. Das Compiled Objekt kann auch ein Dictionary von Bindungsparameternamen und -werten über den params-Accessor zurückgeben.

Parameter:

• bind – Eine Connection oder Engine, die einen Dialect bereitstellen kann, um ein Compiled Objekt zu generieren. Wenn die Parameter bind und dialect beide weggelassen werden, wird ein Standard-SQL-Compiler verwendet.

• column_keys – Wird für INSERT- und UPDATE-Anweisungen verwendet. Eine Liste von Spaltennamen, die in der VALUES-Klausel der kompilierten Anweisung enthalten sein sollten. Wenn None, werden alle Spalten aus dem Zieltabellenobjekt gerendert.

• dialect – Eine Dialect-Instanz, die ein Compiled Objekt generieren kann. Dieses Argument hat Vorrang vor dem bind-Argument.

• compile_kwargs –

  optionales Dictionary mit zusätzlichen Parametern, die an den Compiler in allen "visit"-Methoden weitergegeben werden. Dies ermöglicht es beispielsweise, benutzerdefinierte Flags an benutzerdefinierte Kompilierungskonstrukte zu übergeben. Es wird auch für den Fall verwendet, dass das Flag literal_binds weitergegeben wird.

  from sqlalchemy.sql import table, column, select
  
  t = table("t", column("x"))
  
  s = select(t).where(t.c.x == 5)
  
  print(s.compile(compile_kwargs={"literal_binds": True}))

Siehe auch

Wie rendere ich SQL-Ausdrücke als Strings, möglicherweise mit eingebetteten gebundenen Parametern?

method sqlalchemy.schema.Column.concat(other: Any) → ColumnOperators

geerbt von der ColumnOperators.concat() Methode von ColumnOperators

Implementiert den 'concat'-Operator.

In einem Spaltenkontext erzeugt dies die Klausel a || b oder verwendet den concat()-Operator unter MySQL.

method sqlalchemy.schema.Column.contains(other: Any, **kw: Any) → ColumnOperators

geerbt von der ColumnOperators.contains() Methode von ColumnOperators

Implementiert den 'contains'-Operator.

Erzeugt einen LIKE-Ausdruck, der gegen eine Übereinstimmung am Ende eines String-Wertes prüft.

column LIKE '%' || <other> || '%'

Z. B.

stmt = select(sometable).where(sometable.c.column.contains("foobar"))

Da der Operator LIKE verwendet, verhalten sich auch Platzhalterzeichen "%" und "_", die innerhalb des <other> Ausdrucks vorhanden sind, wie Platzhalter. Für literale Zeichenfolgen kann das Flag ColumnOperators.contains.autoescape auf True gesetzt werden, um Maskierungen auf Vorkommen dieser Zeichen innerhalb des Zeichenfolgenwerts anzuwenden, damit sie als sie selbst und nicht als Platzhalter übereinstimmen. Alternativ legt der Parameter ColumnOperators.contains.escape ein bestimmtes Zeichen als Maskierungszeichen fest, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge ist.

Parameter:

• other – Zu vergleichender Ausdruck. Dies ist normalerweise ein einfacher Zeichenfolgenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Platzhalterzeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag ColumnOperators.contains.autoescape ist auf True gesetzt.

• autoescape –

  Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

  Ein Ausdruck wie

  somecolumn.contains("foo%bar", autoescape=True)

  Wird gerendert als

  somecolumn LIKE '%' || :param || '%' ESCAPE '/'

  Mit dem Wert von :param als "foo/%bar".

• escape –

  ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

  Ein Ausdruck wie

  somecolumn.contains("foo/%bar", escape="^")

  Wird gerendert als

  somecolumn LIKE '%' || :param || '%' ESCAPE '^'

  Der Parameter kann auch mit ColumnOperators.contains.autoescape kombiniert werden.

  somecolumn.contains("foo%bar^bat", escape="^", autoescape=True)

  Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

ColumnOperators.startswith()

ColumnOperators.endswith()

ColumnOperators.like()

method sqlalchemy.schema.Column.copy(**kw: Any) → Column[Any]

Deprecated since version 1.4: Die Methode Column.copy() ist veraltet und wird in einer zukünftigen Version entfernt.

method sqlalchemy.schema.Column.desc() → ColumnOperators

geerbt von der ColumnOperators.desc() Methode von ColumnOperators

Erzeugt eine desc() Klausel gegen das übergeordnete Objekt.

attribute sqlalchemy.schema.Column.dialect_kwargs

geerbt von der DialectKWArgs.dialect_kwargs Attribut von DialectKWArgs

Eine Sammlung von Schlüsselwortargumenten, die als Dialekt-spezifische Optionen für dieses Konstrukt angegeben wurden.

Die Argumente sind hier in ihrem ursprünglichen Format <dialect>_<kwarg> enthalten. Nur tatsächlich übergebene Argumente sind enthalten; im Gegensatz zur Sammlung DialectKWArgs.dialect_options, die alle vom Dialekt bekannten Optionen, einschließlich Standardwerte, enthält.

Die Sammlung ist auch beschreibbar; Schlüssel werden im Format <dialect>_<kwarg> akzeptiert, wobei der Wert in die Liste der Optionen aufgenommen wird.

Siehe auch

DialectKWArgs.dialect_options - verschachtelte Dictionary-Form

attribute sqlalchemy.schema.Column.dialect_options

geerbt von der DialectKWArgs.dialect_options Attribut von DialectKWArgs

Eine Sammlung von Schlüsselwortargumenten, die als Dialekt-spezifische Optionen für dieses Konstrukt angegeben wurden.

Dies ist eine zweistufig verschachtelte Registry, die auf <dialect_name> und <argument_name> geschlüsselt ist. Zum Beispiel ist das Argument postgresql_where auffindbar unter

arg = my_object.dialect_options["postgresql"]["where"]

Neu in Version 0.9.2.

Siehe auch

DialectKWArgs.dialect_kwargs - flache Dictionary-Form

Methode sqlalchemy.schema.Column.distinct() → ColumnOperators

geerbt von der ColumnOperators.distinct() Methode von ColumnOperators

Erzeugt eine distinct()-Klausel gegen das übergeordnete Objekt.

Methode sqlalchemy.schema.Column.endswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

geerbt von der ColumnOperators.endswith() Methode von ColumnOperators

Implementiert den 'endswith'-Operator.

Erzeugt einen LIKE-Ausdruck, der gegen eine Übereinstimmung am Ende eines String-Wertes prüft.

column LIKE '%' || <other>

Z. B.

stmt = select(sometable).where(sometable.c.column.endswith("foobar"))

Da der Operator LIKE verwendet, verhalten sich Wildcard-Zeichen "%" und "_", die in der <other>-Expression vorhanden sind, ebenfalls wie Wildcards. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.endswith.autoescape auf True gesetzt werden, um die Maskierung von Vorkommen dieser Zeichen in der Zeichenfolge anzuwenden, damit sie als sie selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ dazu legt der Parameter ColumnOperators.endswith.escape ein bestimmtes Zeichen als Escape-Zeichen fest, was nützlich sein kann, wenn die Ziel-Expression keine literale Zeichenfolge ist.

Parameter:

• other – zu vergleichende Expression. Dies ist normalerweise ein einfacher Zeichenfolgenwert, kann aber auch eine beliebige SQL-Expression sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag ColumnOperators.endswith.autoescape ist auf True gesetzt.

• autoescape –

  Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

  Ein Ausdruck wie

  somecolumn.endswith("foo%bar", autoescape=True)

  Wird gerendert als

  somecolumn LIKE '%' || :param ESCAPE '/'

  Mit dem Wert von :param als "foo/%bar".

• escape –

  ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

  Ein Ausdruck wie

  somecolumn.endswith("foo/%bar", escape="^")

  Wird gerendert als

  somecolumn LIKE '%' || :param ESCAPE '^'

  Der Parameter kann auch mit ColumnOperators.endswith.autoescape kombiniert werden.

  somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)

  Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

ColumnOperators.startswith()

ColumnOperators.contains()

ColumnOperators.like()

Attribut sqlalchemy.schema.Column.expression

geerbt von der ColumnElement.expression Attribut von ColumnElement

Gibt eine Spaltenexpression zurück.

Teil der Inspektionsoberfläche; gibt sich selbst zurück.

Attribut sqlalchemy.schema.Column.foreign_keys: Set[ForeignKey] = frozenset({})

geerbt von der ColumnElement.foreign_keys Attribut von ColumnElement

Eine Sammlung aller ForeignKey-Markierungsobjekte, die dieser Column zugeordnet sind.

Jedes Objekt ist Mitglied einer Table-weiten ForeignKeyConstraint.

Siehe auch

Table.foreign_keys

Methode sqlalchemy.schema.Column.get_children(*, column_tables=False, **kw)

geerbt von der ColumnClause.get_children() Methode von ColumnClause

Gibt direkte Kind-Elemente HasTraverseInternals dieses HasTraverseInternals zurück.

Dies wird für die Besuchs-Traversal verwendet.

**kw kann Flags enthalten, die die zurückgegebene Sammlung ändern, z. B. um eine Teilmenge von Elementen zurückzugeben, um größere Traversierungen zu reduzieren, oder um Kind-Elemente aus einem anderen Kontext zurückzugeben (z. B. Schema-Ebene Sammlungen anstelle von Klausel-Ebene).

Methode sqlalchemy.schema.Column.icontains(other: Any, **kw: Any) → ColumnOperators

geerbt von der ColumnOperators.icontains() Methode von ColumnOperators

Implementiert den Operator icontains, z. B. die Groß-/Kleinschreibung ignorierende Version von ColumnOperators.contains().

Erzeugt einen LIKE-Ausdruck, der gegen eine unempfindliche Übereinstimmung in der Mitte eines Zeichenkettenwerts testet.

lower(column) LIKE '%' || lower(<other>) || '%'

Z. B.

stmt = select(sometable).where(sometable.c.column.icontains("foobar"))

Da der Operator LIKE verwendet, verhalten sich Wildcard-Zeichen "%" und "_", die in der <other>-Expression vorhanden sind, ebenfalls wie Wildcards. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.icontains.autoescape auf True gesetzt werden, um die Maskierung von Vorkommen dieser Zeichen in der Zeichenfolge anzuwenden, damit sie als sie selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ dazu legt der Parameter ColumnOperators.icontains.escape ein bestimmtes Zeichen als Escape-Zeichen fest, was nützlich sein kann, wenn die Ziel-Expression keine literale Zeichenfolge ist.

Parameter:

• other – zu vergleichende Expression. Dies ist normalerweise ein einfacher Zeichenfolgenwert, kann aber auch eine beliebige SQL-Expression sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag ColumnOperators.icontains.autoescape ist auf True gesetzt.

• autoescape –

  Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

  Ein Ausdruck wie

  somecolumn.icontains("foo%bar", autoescape=True)

  Wird gerendert als

  lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'

  Mit dem Wert von :param als "foo/%bar".

• escape –

  ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

  Ein Ausdruck wie

  somecolumn.icontains("foo/%bar", escape="^")

  Wird gerendert als

  lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'

  Der Parameter kann auch mit ColumnOperators.contains.autoescape kombiniert werden.

  somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)

  Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

ColumnOperators.contains()

Methode sqlalchemy.schema.Column.iendswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

geerbt von der ColumnOperators.iendswith() Methode von ColumnOperators

Implementiert den Operator iendswith, z. B. die Groß-/Kleinschreibung ignorierende Version von ColumnOperators.endswith().

Erzeugt einen LIKE-Ausdruck, der gegen eine unempfindliche Übereinstimmung am Ende eines Zeichenkettenwerts testet.

lower(column) LIKE '%' || lower(<other>)

Z. B.

stmt = select(sometable).where(sometable.c.column.iendswith("foobar"))

Da der Operator LIKE verwendet, verhalten sich Wildcard-Zeichen "%" und "_", die in der <other>-Expression vorhanden sind, ebenfalls wie Wildcards. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.iendswith.autoescape auf True gesetzt werden, um die Maskierung von Vorkommen dieser Zeichen in der Zeichenfolge anzuwenden, damit sie als sie selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ dazu legt der Parameter ColumnOperators.iendswith.escape ein bestimmtes Zeichen als Escape-Zeichen fest, was nützlich sein kann, wenn die Ziel-Expression keine literale Zeichenfolge ist.

Parameter:

• other – zu vergleichende Expression. Dies ist normalerweise ein einfacher Zeichenfolgenwert, kann aber auch eine beliebige SQL-Expression sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag ColumnOperators.iendswith.autoescape ist auf True gesetzt.

• autoescape –

  Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

  Ein Ausdruck wie

  somecolumn.iendswith("foo%bar", autoescape=True)

  Wird gerendert als

  lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'

  Mit dem Wert von :param als "foo/%bar".

• escape –

  ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

  Ein Ausdruck wie

  somecolumn.iendswith("foo/%bar", escape="^")

  Wird gerendert als

  lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'

  Der Parameter kann auch mit ColumnOperators.iendswith.autoescape kombiniert werden.

  somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)

  Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

ColumnOperators.endswith()

Methode sqlalchemy.schema.Column.ilike(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.ilike() Methode von ColumnOperators

Implementiert den ilike Operator, z. B. die Groß-/Kleinschreibung-unabhängige LIKE-Abfrage.

In einem Spaltenkontext wird ein Ausdruck erzeugt, entweder in der Form

lower(a) LIKE lower(other)

Oder auf Backends, die den ILIKE-Operator unterstützen

a ILIKE other

Z. B.

stmt = select(sometable).where(sometable.c.column.ilike("%foobar%"))

Parameter:

• other – zu vergleichende Expression

• escape –

  optionales Escape-Zeichen, rendert das ESCAPE Schlüsselwort, z. B.

  somecolumn.ilike("foo/%bar", escape="/")

Siehe auch

ColumnOperators.like()

Methode sqlalchemy.schema.Column.in_(other: Any) → ColumnOperators

geerbt von der ColumnOperators.in_() Methode von ColumnOperators

Implementiert den in Operator.

In einem Spaltenkontext wird die Klausel column IN <other> erzeugt.

Der angegebene Parameter other kann sein

• Eine Liste von literalen Werten, z. B.

  stmt.where(column.in_([1, 2, 3]))

  In dieser Aufrufform wird die Liste der Elemente in eine Menge von gebundenen Parametern der gleichen Länge wie die angegebene Liste umgewandelt.

  WHERE COL IN (?, ?, ?)

• Eine Liste von Tupeln kann angegeben werden, wenn der Vergleich gegen ein tuple_() mit mehreren Ausdrücken erfolgt.

  from sqlalchemy import tuple_
  
  stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))

• Eine leere Liste, z. B.

  stmt.where(column.in_([]))

  In dieser Aufrufform rendert der Ausdruck einen "leeren Mengen"-Ausdruck. Diese Ausdrücke sind auf einzelne Backends zugeschnitten und versuchen im Allgemeinen, eine leere SELECT-Anweisung als Unterabfrage zu erhalten. Auf SQLite ist der Ausdruck

  WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

  Geändert in Version 1.4: Leere IN-Ausdrücke verwenden nun in allen Fällen eine zur Laufzeit generierte SELECT-Unterabfrage.

• Ein gebundener Parameter, z. B. bindparam(), kann verwendet werden, wenn er das Flag bindparam.expanding enthält.

  stmt.where(column.in_(bindparam("value", expanding=True)))

  In dieser Aufrufform rendert der Ausdruck einen speziellen nicht-SQL-Platzhalter-Ausdruck, der wie folgt aussieht:

  WHERE COL IN ([EXPANDING_value])

  Dieser Platzhalter-Ausdruck wird zur Laufzeit der Anweisung abgefangen und in die variable Anzahl von gebundenen Parametern umgewandelt, wie zuvor gezeigt. Wenn die Anweisung ausgeführt würde als

  connection.execute(stmt, {"value": [1, 2, 3]})

  Die Datenbank würde für jeden Wert einen gebundenen Parameter erhalten.

  WHERE COL IN (?, ?, ?)

  Neu in Version 1.2: "expanding" gebundene Parameter hinzugefügt.

  Wenn eine leere Liste übergeben wird, wird ein spezieller "leere Liste"-Ausdruck gerendert, der für die verwendete Datenbank spezifisch ist. Auf SQLite wäre dies

  WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

  Neu in Version 1.3: "expanding" gebundene Parameter unterstützen nun leere Listen.

• ein select()-Konstrukt, das normalerweise ein korrelierter Skalar-Select ist.

  stmt.where(
      column.in_(select(othertable.c.y).where(table.c.x == othertable.c.x))
  )

  In dieser Aufrufform rendert ColumnOperators.in_() wie angegeben.

  WHERE COL IN (SELECT othertable.y
  FROM othertable WHERE othertable.x = table.x)

Parameter:

other – eine Liste von Literalen, ein select()-Konstrukt oder ein bindparam()-Konstrukt, das das Flag bindparam.expanding auf True gesetzt enthält.

Attribut sqlalchemy.schema.Column.index: bool | None

Der Wert des Parameters Column.index.

Gibt nicht an, ob diese Column tatsächlich indiziert ist oder nicht; verwenden Sie Table.indexes.

Siehe auch

Table.indexes

Attribut sqlalchemy.schema.Column.info

geerbt von der SchemaItem.info Attribut von SchemaItem

Info-Dictionary, das dem Objekt zugeordnet ist und es ermöglicht, benutzerdefinierte Daten diesem SchemaItem zuzuordnen.

Das Dictionary wird automatisch generiert, wenn es zum ersten Mal aufgerufen wird. Es kann auch im Konstruktor einiger Objekte, wie z. B. Table und Column, angegeben werden.

Attribut sqlalchemy.schema.Column.inherit_cache: bool | None = True

Gibt an, ob diese HasCacheKey-Instanz das Cache-Schlüsselgenerierungsschema ihrer unmittelbaren Oberklasse verwenden soll.

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

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

Siehe auch

Unterstützung für das Caching benutzerdefinierter Konstrukte aktivieren - Allgemeine Richtlinien für das Setzen des Attributs HasCacheKey.inherit_cache für Drittanbieter- oder benutzerdefinierte SQL-Konstrukte.

Methode sqlalchemy.schema.Column.is_(other: Any) → ColumnOperators

geerbt von der ColumnOperators.is_() Methode von ColumnOperators

Implementiert den IS Operator.

Normalerweise wird IS automatisch generiert, wenn mit einem Wert von None verglichen wird, was zu NULL aufgelöst wird. Eine explizite Verwendung von IS kann jedoch wünschenswert sein, wenn auf bestimmten Plattformen mit booleschen Werten verglichen wird.

Siehe auch

ColumnOperators.is_not()

Methode sqlalchemy.schema.Column.is_distinct_from(other: Any) → ColumnOperators

geerbt von der ColumnOperators.is_distinct_from() Methode von ColumnOperators

Implementiert den IS DISTINCT FROM Operator.

Rendert auf den meisten Plattformen "a IS DISTINCT FROM b"; auf einigen wie SQLite möglicherweise "a IS NOT b".

Methode sqlalchemy.schema.Column.is_not(other: Any) → ColumnOperators

geerbt von der ColumnOperators.is_not() Methode von ColumnOperators

Implementiert den IS NOT Operator.

Normalerweise wird IS NOT automatisch generiert, wenn mit einem Wert von None verglichen wird, was zu NULL aufgelöst wird. Eine explizite Verwendung von IS NOT kann jedoch wünschenswert sein, wenn auf bestimmten Plattformen mit booleschen Werten verglichen wird.

Geändert in Version 1.4: Der is_not() Operator wurde von isnot() in früheren Versionen umbenannt. Der vorherige Name bleibt aus Kompatibilitätsgründen erhalten.

Siehe auch

ColumnOperators.is_()

Methode sqlalchemy.schema.Column.is_not_distinct_from(other: Any) → ColumnOperators

geerbt von der ColumnOperators.is_not_distinct_from() Methode von ColumnOperators

Implementiert den IS NOT DISTINCT FROM Operator.

Rendert auf den meisten Plattformen "a IS NOT DISTINCT FROM b"; auf einigen wie SQLite möglicherweise "a IS b".

Geändert in Version 1.4: Der is_not_distinct_from() Operator wurde von isnot_distinct_from() in früheren Versionen umbenannt. Der vorherige Name bleibt aus Kompatibilitätsgründen erhalten.

Methode sqlalchemy.schema.Column.isnot(other: Any) → ColumnOperators

geerbt von der ColumnOperators.isnot() Methode von ColumnOperators

Implementiert den IS NOT Operator.

Normalerweise wird IS NOT automatisch generiert, wenn mit einem Wert von None verglichen wird, was zu NULL aufgelöst wird. Eine explizite Verwendung von IS NOT kann jedoch wünschenswert sein, wenn auf bestimmten Plattformen mit booleschen Werten verglichen wird.

Geändert in Version 1.4: Der is_not() Operator wurde von isnot() in früheren Versionen umbenannt. Der vorherige Name bleibt aus Kompatibilitätsgründen erhalten.

Siehe auch

ColumnOperators.is_()

Methode sqlalchemy.schema.Column.isnot_distinct_from(other: Any) → ColumnOperators

geerbt von der ColumnOperators.isnot_distinct_from() Methode von ColumnOperators

Implementiert den IS NOT DISTINCT FROM Operator.

Rendert auf den meisten Plattformen "a IS NOT DISTINCT FROM b"; auf einigen wie SQLite möglicherweise "a IS b".

Geändert in Version 1.4: Der is_not_distinct_from() Operator wurde von isnot_distinct_from() in früheren Versionen umbenannt. Der vorherige Name bleibt aus Kompatibilitätsgründen erhalten.

Methode sqlalchemy.schema.Column.istartswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

geerbt von der ColumnOperators.istartswith() Methode von ColumnOperators

Implementiert den Operator istartswith, z. B. die Groß-/Kleinschreibung ignorierende Version von ColumnOperators.startswith().

Erzeugt einen LIKE-Ausdruck, der gegen eine unempfindliche Übereinstimmung am Anfang eines Zeichenkettenwerts testet.

lower(column) LIKE lower(<other>) || '%'

Z. B.

stmt = select(sometable).where(sometable.c.column.istartswith("foobar"))

Da der Operator LIKE verwendet, verhalten sich auch Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, als Wildcards. Für literale Zeichenkettenwerte kann das Flag ColumnOperators.istartswith.autoescape auf True gesetzt werden, um die Maskierung von Vorkommen dieser Zeichen innerhalb des Zeichenkettenwerts anzuwenden, damit sie als diese selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.istartswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenkette ist.

Parameter:

• other – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenkettenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag ColumnOperators.istartswith.autoescape ist auf True gesetzt.

• autoescape –

  Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

  Ein Ausdruck wie

  somecolumn.istartswith("foo%bar", autoescape=True)

  Wird gerendert als

  lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'

  Mit dem Wert von :param als "foo/%bar".

• escape –

  ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

  Ein Ausdruck wie

  somecolumn.istartswith("foo/%bar", escape="^")

  Wird gerendert als

  lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'

  Der Parameter kann auch mit ColumnOperators.istartswith.autoescape kombiniert werden.

  somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)

  Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

ColumnOperators.startswith()

attribute sqlalchemy.schema.Column.key: str = None

geerbt von dem ColumnElement.key Attribut von ColumnElement

Der 'key', der unter bestimmten Umständen in einem Python-Namespace auf dieses Objekt verweist.

Dies bezieht sich typischerweise auf den "Schlüssel" der Spalte, wie er in der .c Sammlung eines wählbaren Objekts vorhanden ist, z. B. sometable.c["somekey"] gibt eine Column mit einem .key von "somekey" zurück.

attribute sqlalchemy.schema.Column.kwargs

geerbt von dem DialectKWArgs.kwargs Attribut von DialectKWArgs

Ein Synonym für DialectKWArgs.dialect_kwargs.

method sqlalchemy.schema.Column.label(name: str | None) → Label[_T]

geerbt von der ColumnElement.label() Methode von ColumnElement

Erzeugt ein Spaltenlabel, d. h. <columnname> AS <name>.

Dies ist eine Abkürzung für die Funktion label().

Wenn 'name' None ist, wird ein anonymer Labelname generiert.

method sqlalchemy.schema.Column.like(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.like() Methode von ColumnOperators

Implementiert den like Operator.

In einem Spaltenkontext wird der Ausdruck erzeugt

a LIKE other

Z. B.

stmt = select(sometable).where(sometable.c.column.like("%foobar%"))

Parameter:

• other – Ausdruck, der verglichen werden soll

• escape –

  optionales Escape-Zeichen, rendert das ESCAPE Schlüsselwort, z. B.

  somecolumn.like("foo/%bar", escape="/")

Siehe auch

ColumnOperators.ilike()

method sqlalchemy.schema.Column.match(other: Any, **kwargs: Any) → ColumnOperators

geerbt von der ColumnOperators.match() Methode von ColumnOperators

Implementiert einen datenbankspezifischen 'match'-Operator.

ColumnOperators.match() versucht, eine vom Backend bereitgestellte MATCH-ähnliche Funktion oder einen Operator aufzulösen. Beispiele hierfür sind

• PostgreSQL - rendert x @@ plainto_tsquery(y)

  Geändert in Version 2.0: plainto_tsquery() wird jetzt anstelle von to_tsquery() für PostgreSQL verwendet; für Kompatibilität mit anderen Formen siehe Volltextsuche.

• MySQL - rendert MATCH (x) AGAINST (y IN BOOLEAN MODE)

  Siehe auch

  match - MySQL-spezifische Konstruktion mit zusätzlichen Funktionen.

• Oracle Database - rendert CONTAINS(x, y)

• andere Backends können spezielle Implementierungen bereitstellen.

• Backends ohne spezielle Implementierung geben den Operator als „MATCH“ aus. Dies ist beispielsweise mit SQLite kompatibel.

method sqlalchemy.schema.Column.not_ilike(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.not_ilike() Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.ilike(), d. h. ~x.ilike(y).

Geändert in Version 1.4: Der Operator not_ilike() wurde von notilike() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Siehe auch

ColumnOperators.ilike()

method sqlalchemy.schema.Column.not_in(other: Any) → ColumnOperators

geerbt von der ColumnOperators.not_in() Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.in_(), d. h. ~x.in_(y).

Wenn other eine leere Sequenz ist, erzeugt der Compiler einen Ausdruck "leeres not in". Dieser entspricht standardmäßig dem Ausdruck "1 = 1", um in allen Fällen true zu ergeben. Die create_engine.empty_in_strategy kann verwendet werden, um dieses Verhalten zu ändern.

Geändert in Version 1.4: Der Operator not_in() wurde von notin_() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Geändert in Version 1.2: Die Operatoren ColumnOperators.in_() und ColumnOperators.not_in() erzeugen jetzt standardmäßig einen "statischen" Ausdruck für eine leere IN-Sequenz.

Siehe auch

ColumnOperators.in_()

method sqlalchemy.schema.Column.not_like(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.not_like() Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.like(), d. h. ~x.like(y).

Geändert in Version 1.4: Der Operator not_like() wurde von notlike() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Siehe auch

ColumnOperators.like()

method sqlalchemy.schema.Column.notilike(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.notilike() Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.ilike(), d. h. ~x.ilike(y).

Geändert in Version 1.4: Der Operator not_ilike() wurde von notilike() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Siehe auch

ColumnOperators.ilike()

method sqlalchemy.schema.Column.notin_(other: Any) → ColumnOperators

geerbt von der ColumnOperators.notin_() Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.in_(), d. h. ~x.in_(y).

Wenn other eine leere Sequenz ist, erzeugt der Compiler einen Ausdruck "leeres not in". Dieser entspricht standardmäßig dem Ausdruck "1 = 1", um in allen Fällen true zu ergeben. Die create_engine.empty_in_strategy kann verwendet werden, um dieses Verhalten zu ändern.

Geändert in Version 1.4: Der Operator not_in() wurde von notin_() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Geändert in Version 1.2: Die Operatoren ColumnOperators.in_() und ColumnOperators.not_in() erzeugen jetzt standardmäßig einen "statischen" Ausdruck für eine leere IN-Sequenz.

Siehe auch

ColumnOperators.in_()

method sqlalchemy.schema.Column.notlike(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.notlike() Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.like(), d. h. ~x.like(y).

Geändert in Version 1.4: Der Operator not_like() wurde von notlike() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Siehe auch

ColumnOperators.like()

method sqlalchemy.schema.Column.nulls_first() → ColumnOperators

geerbt von der ColumnOperators.nulls_first() Methode von ColumnOperators

Erzeugt eine nulls_first()-Klausel für das übergeordnete Objekt.

Geändert in Version 1.4: Der Operator nulls_first() wurde von nullsfirst() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

method sqlalchemy.schema.Column.nulls_last() → ColumnOperators

geerbt von der ColumnOperators.nulls_last() Methode von ColumnOperators

Erzeugt eine nulls_last()-Klausel für das übergeordnete Objekt.

Geändert in Version 1.4: Der Operator nulls_last() wurde von nullslast() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

method sqlalchemy.schema.Column.nullsfirst() → ColumnOperators

geerbt von der ColumnOperators.nullsfirst() Methode von ColumnOperators

Erzeugt eine nulls_first()-Klausel für das übergeordnete Objekt.

Geändert in Version 1.4: Der Operator nulls_first() wurde von nullsfirst() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

method sqlalchemy.schema.Column.nullslast() → ColumnOperators

geerbt von der ColumnOperators.nullslast() Methode von ColumnOperators

Erzeugt eine nulls_last()-Klausel für das übergeordnete Objekt.

Geändert in Version 1.4: Der Operator nulls_last() wurde von nullslast() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

method sqlalchemy.schema.Column.op(opstring: str, precedence: int = 0, is_comparison: bool = False, return_type: Type[TypeEngine[Any]] | TypeEngine[Any] | None = None, python_impl: Callable[..., Any] | None = None) → Callable[[Any], Operators]

geerbt von der Operators.op() Methode von Operators

Erzeugt eine generische Operatorfunktion.

z. B.

somecolumn.op("*")(5)

produziert

somecolumn * 5

Diese Funktion kann auch verwendet werden, um bitweise Operatoren explizit zu machen. Zum Beispiel

somecolumn.op("&")(0xFF)

ist ein bitweises UND des Wertes in somecolumn.

Parameter:

• opstring – Eine Zeichenkette, die als Infix-Operator zwischen diesem Element und dem an die generierte Funktion übergebenen Ausdruck ausgegeben wird.

• precedence –

  die Priorität, die die Datenbank erwartungsgemäß auf den Operator in SQL-Ausdrücken anwenden soll. Dieser ganzzahlige Wert dient als Hinweis für den SQL-Compiler, wann explizite Klammern um eine bestimmte Operation gerendert werden sollen. Ein niedrigerer Wert führt dazu, dass der Ausdruck bei der Anwendung auf einen anderen Operator mit höherer Priorität geklammert wird. Der Standardwert von 0 ist niedriger als alle Operatoren, außer dem Komma (,) und dem AS Operator. Ein Wert von 100 ist höher oder gleich allen Operatoren und -100 ist niedriger oder gleich allen Operatoren.

  Siehe auch

  Ich verwende op() zur Erzeugung eines benutzerdefinierten Operators und meine Klammern werden nicht richtig ausgegeben - detaillierte Beschreibung, wie der SQLAlchemy SQL-Compiler Klammern rendert

• is_comparison –

  veraltet; wenn True, wird der Operator als "Vergleichsoperator" betrachtet, d. h. er ergibt einen booleschen Wahr/Falsch-Wert, wie z. B. ==, > usw. Dieses Flag wird bereitgestellt, damit ORM-Beziehungen feststellen können, dass der Operator ein Vergleichsoperator ist, wenn er in einer benutzerdefinierten Join-Bedingung verwendet wird.

  Die Verwendung des Parameters is_comparison wird durch die Verwendung der Methode Operators.bool_op() ersetzt; dieser prägnantere Operator setzt diesen Parameter automatisch, bietet aber auch korrekte PEP 484-Typisierungsunterstützung, da das zurückgegebene Objekt einen "booleschen" Datentyp ausdrückt, d. h. BinaryExpression[bool].

• return_type – eine TypeEngine-Klasse oder ein Objekt, das den Rückgabetyp eines von diesem Operator erzeugten Ausdrucks auf diesen Typ erzwingt. Standardmäßig werden Operatoren, die Operators.op.is_comparison angeben, zu Boolean aufgelöst, und diejenigen, die dies nicht tun, haben denselben Typ wie der linke Operand.

• python_impl –

  eine optionale Python-Funktion, die zwei Python-Werte auf die gleiche Weise auswerten kann, wie dieser Operator auf dem Datenbankserver funktioniert. Nützlich für die SQL-Ausdrucksauswertung innerhalb von Python, z. B. für ORM-Hybridattribute und den ORM "Evaluator", der verwendet wird, um Objekte in einer Sitzung nach einem Mehrzeilen-Update oder -Löschvorgang abzugleichen.

  z. B.

  >>> expr = column("x").op("+", python_impl=lambda a, b: a + b)("y")

  Der Operator für den obigen Ausdruck funktioniert auch für nicht-SQL-linke und rechte Objekte

  >>> expr.operator(5, 10)
  15

  Neu in Version 2.0.

Siehe auch

Operators.bool_op()

Neudefinition und Erstellung neuer Operatoren

Verwendung benutzerdefinierter Operatoren in Verknüpfungsbedingungen

method sqlalchemy.schema.Column.operate(op: OperatorType, *other: Any, **kwargs: Any) → ColumnElement[Any]

geerbt von der ColumnElement.operate() Methode von ColumnElement

Operiert auf einem Argument.

Dies ist die niedrigste Ebene der Operation, löst standardmäßig NotImplementedError aus.

Das Überschreiben dieser Methode in einer Unterklasse kann es ermöglichen, allgemeines Verhalten auf alle Operationen anzuwenden. Zum Beispiel, das Überschreiben von ColumnOperators, um func.lower() auf die linke und rechte Seite anzuwenden

class MyComparator(ColumnOperators):
    def operate(self, op, other, **kwargs):
        return op(func.lower(self), func.lower(other), **kwargs)

Parameter:

• op – Operator aufrufbar.

• *other – die "andere" Seite der Operation. Wird für die meisten Operationen ein einzelner Skalar sein.

• **kwargs – Modifikatoren. Diese können von speziellen Operatoren wie ColumnOperators.contains() übergeben werden.

methode sqlalchemy.schema.Column.params(*optionaldict, **kwargs)

geerbt von der Immutable.params() Methode von Immutable

Gibt eine Kopie zurück, bei der bindparam() Elemente ersetzt wurden.

Gibt eine Kopie dieses ClauseElement zurück, bei der bindparam() Elemente durch Werte aus dem angegebenen Wörterbuch ersetzt wurden.

>>> clause = column("x") + bindparam("foo")
>>> print(clause.compile().params)
{'foo':None}
>>> print(clause.params({"foo": 7}).compile().params)
{'foo':7}

attribut sqlalchemy.schema.Column.proxy_set: util.generic_fn_descriptor[FrozenSet[Any]]

geerbt von der ColumnElement.proxy_set Attribut von ColumnElement

Set aller Spalten, die wir proxen

ab 2.0 sind dies explizit deannotierte Spalten. Zuvor waren es effektiv deannotierte Spalten, aber es wurde nicht durchgesetzt. Annotierte Spalten sollten grundsätzlich nicht in Sets aufgenommen werden, wenn überhaupt möglich, da ihr Hashing-Verhalten sehr leistungsschwach ist.

methode sqlalchemy.schema.Column.references(column: Column[Any]) → bool

Gibt True zurück, wenn diese Spalte die gegebene Spalte über einen Fremdschlüssel referenziert.

methode sqlalchemy.schema.Column.regexp_match(pattern: Any, flags: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.regexp_match() Methode von ColumnOperators

Implementiert einen datenbankspezifischen „regexp match“-Operator.

Z. B.

stmt = select(table.c.some_column).where(
    table.c.some_column.regexp_match("^(b|c)")
)

ColumnOperators.regexp_match() versucht, sich auf eine REGEXP-ähnliche Funktion oder einen Operator aufzulösen, die vom Backend bereitgestellt werden. Die spezifische Syntax für reguläre Ausdrücke und die verfügbaren Flags sind jedoch **nicht backend-agnostisch**.

Beispiele hierfür sind:

• PostgreSQL - rendert x ~ y oder x !~ y bei Negation.

• Oracle Database - rendert REGEXP_LIKE(x, y)

• SQLite - verwendet den Platzhalteroperator REGEXP von SQLite und ruft die Python-Builtin-Funktion re.match() auf.

• andere Backends können spezielle Implementierungen bereitstellen.

• Backends ohne spezielle Implementierung geben den Operator als „REGEXP“ oder „NOT REGEXP“ aus. Dies ist beispielsweise mit SQLite und MySQL kompatibel.

Reguläre Ausdrucksunterstützung ist derzeit für Oracle Database, PostgreSQL, MySQL und MariaDB implementiert. Teilweise Unterstützung ist für SQLite verfügbar. Die Unterstützung bei Drittanbieter-Dialekten kann variieren.

Parameter:

• pattern – Der String mit dem regulären Ausdruck oder die Spaltenklausel.

• flags – Beliebige Flags für reguläre Ausdrücke, die als reiner Python-String übergeben werden. Diese Flags sind backend-spezifisch. Einige Backends wie PostgreSQL und MariaDB können die Flags alternativ als Teil des Patterns angeben. Bei Verwendung des Ignoriere-Groß-/Kleinschreibung-Flags 'i' in PostgreSQL wird der REGEXP-Operator, der Groß-/Kleinschreibung ignoriert, ~* oder !~* verwendet.

Neu in Version 1.4.

Geändert in Version 1.4.48,: 2.0.18 Aufgrund eines Implementierungsfehlers akzeptierte der Parameter „flags“ zuvor SQL-Ausdrucksobjekte wie Spaltenausdrücke zusätzlich zu einfachen Python-Strings. Diese Implementierung funktionierte nicht korrekt mit Caching und wurde entfernt; es sollten nur Strings für den Parameter „flags“ übergeben werden, da diese Flags als wörtliche Inline-Werte innerhalb von SQL-Ausdrücken gerendert werden.

Siehe auch

ColumnOperators.regexp_replace()

methode sqlalchemy.schema.Column.regexp_replace(pattern: Any, replacement: Any, flags: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.regexp_replace() Methode von ColumnOperators

Implementiert einen datenbankspezifischen „regexp replace“-Operator.

Z. B.

stmt = select(
    table.c.some_column.regexp_replace("b(..)", "X
Y", flags="g")
)

ColumnOperators.regexp_replace() versucht, sich auf eine REGEXP_REPLACE-ähnliche Funktion aufzulösen, die vom Backend bereitgestellt wird und normalerweise die Funktion REGEXP_REPLACE() ausgibt. Die spezifische Syntax für reguläre Ausdrücke und die verfügbaren Flags sind jedoch **nicht backend-agnostisch**.

Unterstützung für reguläre Ersetzungen ist derzeit für Oracle Database, PostgreSQL, MySQL 8 oder höher und MariaDB implementiert. Die Unterstützung bei Drittanbieter-Dialekten kann variieren.

Parameter:

• pattern – Der String mit dem regulären Ausdruck oder die Spaltenklausel.

• pattern – Der Ersatzstring oder die Spaltenklausel.

• flags – Beliebige Flags für reguläre Ausdrücke, die als reiner Python-String übergeben werden. Diese Flags sind backend-spezifisch. Einige Backends wie PostgreSQL und MariaDB können die Flags alternativ als Teil des Patterns angeben.

Neu in Version 1.4.

Geändert in Version 1.4.48,: 2.0.18 Aufgrund eines Implementierungsfehlers akzeptierte der Parameter „flags“ zuvor SQL-Ausdrucksobjekte wie Spaltenausdrücke zusätzlich zu einfachen Python-Strings. Diese Implementierung funktionierte nicht korrekt mit Caching und wurde entfernt; es sollten nur Strings für den Parameter „flags“ übergeben werden, da diese Flags als wörtliche Inline-Werte innerhalb von SQL-Ausdrücken gerendert werden.

Siehe auch

ColumnOperators.regexp_match()

methode sqlalchemy.schema.Column.reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → ColumnElement[Any]

geerbt von der ColumnElement.reverse_operate() Methode von ColumnElement

Umgekehrte Operation auf ein Argument.

Die Verwendung ist dieselbe wie bei operate().

methode sqlalchemy.schema.Column.self_group(against: OperatorType | None = None) → ColumnElement[Any]

geerbt von der ColumnElement.self_group() Methode von ColumnElement

Wendet eine "Gruppierung" auf dieses ClauseElement an.

Diese Methode wird von Unterklassen überschrieben, um ein "Gruppierungs"-Konstrukt zurückzugeben, d. h. Klammern. Insbesondere wird sie von "binären" Ausdrücken verwendet, um eine Gruppierung um sich herum zu schaffen, wenn sie in einen größeren Ausdruck eingefügt werden, sowie von select() Konstrukten, wenn sie in die FROM-Klausel eines anderen select() eingefügt werden. (Beachten Sie, dass Subabfragen normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen benannte verschachtelte SELECT-Anweisungen erfordern).

Wenn Ausdrücke zusammengesetzt werden, ist die Anwendung von self_group() automatisch - Endbenutzercode muss diese Methode niemals direkt verwenden. Beachten Sie, dass die Klauselkonstrukte von SQLAlchemy die Operatorpriorität berücksichtigen - daher sind Klammern möglicherweise nicht erforderlich, z. B. in einem Ausdruck wie x OR (y AND z) - AND hat Vorrang vor OR.

Die Basis self_group() Methode von ClauseElement gibt einfach self zurück.

methode sqlalchemy.schema.Column.shares_lineage(othercolumn: ColumnElement[Any]) → bool

geerbt von der ColumnElement.shares_lineage() Methode von ColumnElement

Gibt True zurück, wenn das gegebene ColumnElement einen gemeinsamen Vorfahren zu diesem ColumnElement hat.

methode sqlalchemy.schema.Column.startswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

geerbt von der ColumnOperators.startswith() Methode von ColumnOperators

Implementiert den Operator startswith.

Erzeugt einen LIKE-Ausdruck, der gegen eine Übereinstimmung mit dem Anfang eines String-Wertes testet.

column LIKE <other> || '%'

Z. B.

stmt = select(sometable).where(sometable.c.column.startswith("foobar"))

Da der Operator LIKE verwendet, verhalten sich Platzhalterzeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls wie Platzhalter. Für literale Zeichenkettenwerte kann das Flag ColumnOperators.startswith.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen in der Zeichenkette zu maskieren, damit sie als sie selbst und nicht als Platzhalterzeichen übereinstimmen. Alternativ legt der Parameter ColumnOperators.startswith.escape ein bestimmtes Zeichen als Escape-Zeichen fest, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenkette ist.

Parameter:

• other – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein literaler Zeichenkettenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Platzhalterzeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag ColumnOperators.startswith.autoescape ist auf True gesetzt.

• autoescape –

  Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

  Ein Ausdruck wie

  somecolumn.startswith("foo%bar", autoescape=True)

  Wird gerendert als

  somecolumn LIKE :param || '%' ESCAPE '/'

  Mit dem Wert von :param als "foo/%bar".

• escape –

  ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

  Ein Ausdruck wie

  somecolumn.startswith("foo/%bar", escape="^")

  Wird gerendert als

  somecolumn LIKE :param || '%' ESCAPE '^'

  Der Parameter kann auch mit ColumnOperators.startswith.autoescape kombiniert werden.

  somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True)

  Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

ColumnOperators.endswith()

ColumnOperators.contains()

ColumnOperators.like()

attribut sqlalchemy.schema.Column.timetuple: Literal[None] = None

geerbt von der ColumnOperators.timetuple Attribut von ColumnOperators

Hack, erlaubt den Vergleich von Datetime-Objekten auf der linken Seite.

attribut sqlalchemy.schema.Column.unique: bool | None

Der Wert des Column.unique Parameters.

Gibt nicht an, ob diese Column tatsächlich einer eindeutigen Einschränkung unterliegt oder nicht; verwenden Sie Table.indexes und Table.constraints.

Siehe auch

Table.indexes

Table.constraints.

methode sqlalchemy.schema.Column.unique_params(*optionaldict, **kwargs)

geerbt von der Immutable.unique_params() Methode von Immutable

Gibt eine Kopie zurück, bei der bindparam() Elemente ersetzt wurden.

Gleiche Funktionalität wie ClauseElement.params(), fügt jedoch unique=True zu betroffenen Bindparametern hinzu, damit mehrere Anweisungen verwendet werden können.

klasse sqlalchemy.schema.MetaData

Eine Sammlung von Table-Objekten und deren zugehörigen Schema-Konstrukten.

Enthält eine Sammlung von Table Objekten sowie eine optionale Bindung an eine Engine oder Connection. Wenn gebunden, können die Table Objekte in der Sammlung und ihre Spalten an impliziter SQL-Ausführung teilnehmen.

Die Table Objekte selbst werden im Wörterbuch MetaData.tables gespeichert.

MetaData ist ein threadsicheres Objekt für Leseoperationen. Die Erstellung neuer Tabellen innerhalb eines einzelnen MetaData Objekts, sei es explizit oder durch Reflektion, ist möglicherweise nicht vollständig threadsicher.

Siehe auch

Datenbanken mit MetaData beschreiben - Einführung in die Datenbankmetadaten.

Mitglieder

__init__(), clear(), create_all(), drop_all(), reflect(), remove(), sorted_tables, tables

Klassensignatur

Klasse sqlalchemy.schema.MetaData (sqlalchemy.schema.HasSchemaAttr)

methode sqlalchemy.schema.MetaData.__init__(schema: str | None = None, quote_schema: bool | None = None, naming_convention: _NamingSchemaParameter | None = None, info: _InfoType | None = None) → None

Erstellt ein neues MetaData-Objekt.

Parameter:

• schema –

  Das Standard-Schema, das für die Table, Sequence und potenziell andere Objekte, die mit diesem MetaData assoziiert sind, verwendet werden soll. Standardmäßig ist dies None.

  Siehe auch

  Angabe eines Standard-Schema-Namens mit MetaData - Details zur Verwendung des Parameters MetaData.schema.

  Table.schema

  Sequence.schema

• quote_schema – Setzt das quote_schema Flag für jene Table, Sequence und andere Objekte, die den lokalen schema Namen verwenden.

• info – Optionale Daten, die in das Attribut SchemaItem.info dieses Objekts geschrieben werden.

• naming_convention –

  Ein Wörterbuch, das sich auf Werte bezieht, die Standard-Namenskonventionen für Constraint und Index Objekte festlegen, für jene Objekte, denen kein expliziter Name zugewiesen wurde.

  Die Schlüssel dieses Wörterbuchs können sein

  • eine Constraint- oder Indexklasse, z. B. die Klasse UniqueConstraint, ForeignKeyConstraint, die Klasse Index

  • ein Zeichenkettenkürzel für eine der bekannten Constraint-Klassen; "fk", "pk", "ix", "ck", "uq" für Fremdschlüssel-, Primärschlüssel-, Index-, Prüf- bzw. eindeutige Constraints.

  • der Zeichenkettenname eines benutzerdefinierten "Tokens", das zur Definition neuer Namens-Tokens verwendet werden kann.

  Die Werte, die jeder "Constraint-Klasse" oder jedem "Constraint-Kürzel"-Schlüssel zugeordnet sind, sind Zeichenketten-Namensvorlagen, wie z. B. "uq_%(table_name)s_%(column_0_name)s", die beschreiben, wie der Name zusammengesetzt werden soll. Die Werte, die benutzerdefinierten "Token"-Schlüsseln zugeordnet sind, sollten aufrufbare Funktionen der Form fn(constraint, table) sein, die das Constraint-/Indexobjekt und die Table als Argumente erhalten und eine Zeichenkette zurückgeben.

  Die integrierten Namen sind wie folgt, einige davon sind möglicherweise nur für bestimmte Arten von Constraints verfügbar.

  • %(table_name)s - der Name des Table Objekts, das dem Constraint zugeordnet ist.

  • %(referred_table_name)s - der Name des Table Objekts, das dem referenzierten Ziel eines ForeignKeyConstraint zugeordnet ist.

  • %(column_0_name)s - der Name der Column an Position "0" innerhalb des Constraints.

  • %(column_0N_name)s - der Name aller Column Objekte in Reihenfolge innerhalb des Constraints, ohne Trennzeichen verbunden.

  • %(column_0_N_name)s - der Name aller Column-Objekte in der Reihenfolge innerhalb der Beschränkung, verbunden mit einem Unterstrich als Trennzeichen.

  • %(column_0_label)s, %(column_0N_label)s, %(column_0_N_label)s - das Label der nullten Column oder aller Columns, getrennt mit oder ohne Unterstrich

  • %(column_0_key)s, %(column_0N_key)s, %(column_0_N_key)s - der Schlüssel der nullten Column oder aller Columns, getrennt mit oder ohne Unterstrich

  • %(referred_column_0_name)s, %(referred_column_0N_name)s %(referred_column_0_N_name)s, %(referred_column_0_key)s, %(referred_column_0N_key)s, … Spaltentoken, die die Namen/Schlüssel/Labels von Spalten rendern, auf die von einer ForeignKeyConstraint verwiesen wird.

  • %(constraint_name)s - ein spezieller Schlüssel, der sich auf den vorhandenen Namen bezieht, der der Beschränkung gegeben wurde. Wenn dieser Schlüssel vorhanden ist, wird der vorhandene Name des Constraint-Objekts durch einen ersetzt, der aus der Vorlagenzeichenkette zusammengesetzt wird, die dieses Token verwendet. Wenn dieses Token vorhanden ist, muss der Constraint im Voraus einen expliziten Namen erhalten.

  • benutzerdefiniert: Jedes zusätzliche Token kann implementiert werden, indem es zusammen mit einem aufrufbaren fn(constraint, table) an das `naming_convention`-Dictionary übergeben wird.

  Neu in Version 1.3.0: - hinzugefügte neue %(column_0N_name)s, %(column_0_N_name)s und verwandte Tokens, die Verknüpfungen von Namen, Schlüsseln oder Labels für alle Spalten erzeugen, auf die von einer gegebenen Beschränkung verwiesen wird.

  Siehe auch

  Konfiguration von Namenskonventionen für Beschränkungen - für detaillierte Nutzungsbeispiele.

methode sqlalchemy.schema.MetaData.clear() → None

Löscht alle `Table`-Objekte aus dieser `MetaData`.

methode sqlalchemy.schema.MetaData.create_all(bind: _CreateDropBind, tables: _typing_Sequence[Table] | None = None, checkfirst: bool = True) → None

Erstellt alle Tabellen, die in dieser `MetaData` gespeichert sind.

Standardmäßig bedingt, es wird nicht versucht, bereits vorhandene Tabellen in der Zieldatenbank neu zu erstellen.

Parameter:

• bind – Eine Connection oder Engine, die zum Zugriff auf die Datenbank verwendet wird.

• tables – Optionale Liste von Table-Objekten, die eine Teilmenge der gesamten Tabellen in der MetaData darstellt (andere werden ignoriert).

• checkfirst – Standardmäßig True, keine CREATE-Befehle ausgeben für Tabellen, die bereits in der Zieldatenbank vorhanden sind.

methode sqlalchemy.schema.MetaData.drop_all(bind: _CreateDropBind, tables: _typing_Sequence[Table] | None = None, checkfirst: bool = True) → None

Löscht alle Tabellen, die in dieser `MetaData` gespeichert sind.

Standardmäßig bedingt, es wird nicht versucht, Tabellen zu löschen, die nicht in der Zieldatenbank vorhanden sind.

Parameter:

• bind – Eine Connection oder Engine, die zum Zugriff auf die Datenbank verwendet wird.

• tables – Optionale Liste von Table-Objekten, die eine Teilmenge der gesamten Tabellen in der MetaData darstellt (andere werden ignoriert).

• checkfirst – Standardmäßig True, nur DROP-Befehle ausgeben für Tabellen, die nachweislich in der Zieldatenbank vorhanden sind.

methode sqlalchemy.schema.MetaData.reflect(bind: Engine | Connection, schema: str | None = None, views: bool = False, only: _typing_Sequence[str] | Callable[[str, MetaData], bool] | None = None, extend_existing: bool = False, autoload_replace: bool = True, resolve_fks: bool = True, **dialect_kwargs: Any) → None

Lädt alle verfügbaren Tabellendefinitionen aus der Datenbank.

Erstellt automatisch Table-Einträge in dieser MetaData für jede Tabelle, die in der Datenbank verfügbar, aber noch nicht in der MetaData vorhanden ist. Kann mehrmals aufgerufen werden, um kürzlich zur Datenbank hinzugefügte Tabellen zu erfassen. Es werden jedoch keine besonderen Maßnahmen ergriffen, wenn eine Tabelle in dieser MetaData nicht mehr in der Datenbank existiert.

Parameter:

• bind – Eine Connection oder Engine, die zum Zugriff auf die Datenbank verwendet wird.

• schema – Optional, Tabellen aus einem alternativen Schema abfragen und reflektieren. Wenn None, wird das Schema verwendet, das dieser MetaData zugeordnet ist, falls vorhanden.

• views – Wenn True, auch Views (materialisiert und einfach) reflektieren.

• only –

  Optional. Nur eine Teilmenge der verfügbaren benannten Tabellen laden. Kann als Sequenz von Namen oder als aufrufbar angegeben werden.

  Wenn eine Sequenz von Namen angegeben wird, werden nur diese Tabellen reflektiert. Wenn eine angeforderte Tabelle nicht verfügbar ist, wird ein Fehler ausgelöst. Benannte Tabellen, die bereits in dieser MetaData vorhanden sind, werden ignoriert.

  Wenn ein aufrufbares Objekt angegeben wird, wird es als boolescher Prädikat verwendet, um die Liste der potenziellen Tabellennamen zu filtern. Das aufrufbare Objekt wird mit einem Tabellennamen und dieser MetaData-Instanz als Positionsargumente aufgerufen und sollte für jede zu reflektierende Tabelle einen wahren Wert zurückgeben.

• extend_existing – Wird an jede Table als Table.extend_existing weitergegeben.

• autoload_replace – Wird an jede Table als Table.autoload_replace weitergegeben.

• resolve_fks –

  Wenn True, werden Table-Objekte reflektiert, die mit ForeignKey-Objekten in jeder Table verknüpft sind. Für MetaData.reflect() hat dies zur Folge, dass verwandte Tabellen reflektiert werden, die möglicherweise sonst nicht in der Liste der reflektierten Tabellen enthalten wären, z. B. wenn sich die referenzierte Tabelle in einem anderen Schema befindet oder über den MetaData.reflect.only-Parameter ausgeschlossen wurde. Wenn False, werden ForeignKey-Objekte nicht zu der Table verfolgt, auf die sie verweisen. Wenn die verwandte Tabelle jedoch auch Teil der Liste der Tabellen ist, die in jedem Fall reflektiert würden, löst das ForeignKey-Objekt nach Abschluss des MetaData.reflect()-Vorgangs weiterhin seine verwandte Table auf. Standardmäßig True.

  Neu in Version 1.3.0.

  Siehe auch

  Table.resolve_fks

• **dialect_kwargs – Zusätzliche Schlüsselwortargumente, die oben nicht erwähnt sind, sind dialektspezifisch und werden in der Form <dialektname>_<argname> übergeben. Einzelheiten zu dokumentierten Argumenten finden Sie in der Dokumentation zu einem einzelnen Dialekt unter Dialekte.

Siehe auch

Datenbankobjekte reflektieren

DDLEvents.column_reflect() - Ereignis zur Anpassung der reflektierten Spalten. Wird normalerweise verwendet, um Typen mit TypeEngine.as_generic() zu verallgemeinern

Reflektieren mit datenbankunabhängigen Typen - beschreibt, wie Tabellen mit allgemeinen Typen reflektiert werden.

methode sqlalchemy.schema.MetaData.remove(table: Table) → None

Entfernt das gegebene `Table`-Objekt aus dieser `MetaData`.

attribut sqlalchemy.schema.MetaData.sorted_tables

Gibt eine Liste von Table-Objekten zurück, die nach der Fremdschlüsselabhängigkeit sortiert sind.

Die Sortierung platziert Table-Objekte, die Abhängigkeiten haben, vor den Abhängigkeiten selbst, was die Reihenfolge darstellt, in der sie erstellt werden können. Um die Reihenfolge zu erhalten, in der die Tabellen gelöscht würden, verwenden Sie die Python-Built-in-Funktion reversed().

Warnung

Das Attribut MetaData.sorted_tables kann nicht allein zyklische Abhängigkeiten zwischen Tabellen automatisch auflösen, die normalerweise durch wechselseitig abhängige Fremdschlüsselbeschränkungen verursacht werden. Wenn diese Zyklen erkannt werden, werden die Fremdschlüssel dieser Tabellen bei der Sortierung nicht berücksichtigt. Eine Warnung wird ausgegeben, wenn diese Bedingung auftritt, was in einer zukünftigen Version zu einer Ausnahme führen wird. Tabellen, die nicht Teil des Zyklus sind, werden weiterhin in Abhängigkeitsreihenfolge zurückgegeben.

Um diese Zyklen aufzulösen, kann der Parameter ForeignKeyConstraint.use_alter auf die Beschränkungen angewendet werden, die einen Zyklus erzeugen. Alternativ gibt die Funktion sort_tables_and_constraints() bei Erkennung von Zyklen Fremdschlüsselbeschränkungen separat zurück, damit sie separat auf ein Schema angewendet werden können.

Geändert in Version 1.3.17: - es wird eine Warnung ausgegeben, wenn MetaData.sorted_tables aufgrund zyklischer Abhängigkeiten keine korrekte Sortierung durchführen kann. Dies wird in einer zukünftigen Version zu einer Ausnahme führen. Zusätzlich wird die Sortierung weiterhin andere Tabellen zurückgeben, die nicht am Zyklus beteiligt sind, in Abhängigkeitsreihenfolge, was zuvor nicht der Fall war.

Siehe auch

sort_tables()

sort_tables_and_constraints()

MetaData.tables

Inspector.get_table_names()

Inspector.get_sorted_table_and_fkc_names()

attribut sqlalchemy.schema.MetaData.tables: util.FacadeDict[str, Table]

Ein Wörterbuch von Table-Objekten, die zu ihrem Namen oder „Tabellenschlüssel“ zugeordnet sind.

Der exakte Schlüssel ist der, der vom Attribut Table.key bestimmt wird; für eine Tabelle ohne Table.schema-Attribut ist dies dasselbe wie Table.name. Für eine Tabelle mit einem Schema hat es normalerweise die Form schemaname.tablename.

Siehe auch

MetaData.sorted_tables

klasse sqlalchemy.schema.SchemaConst

Eine Aufzählung.

Mitglieder

BLANK_SCHEMA, NULL_UNSPECIFIED, RETAIN_SCHEMA

Klassensignatur

class sqlalchemy.schema.SchemaConst (enum.Enum)

attribut sqlalchemy.schema.SchemaConst.BLANK_SCHEMA = 2

Symbol, das angibt, dass eine Table oder Sequence für ihr Schema „None“ haben soll, auch wenn die übergeordnete MetaData ein Schema angegeben hat.

Siehe auch

MetaData.schema

Table.schema

Sequence.schema

attribut sqlalchemy.schema.SchemaConst.NULL_UNSPECIFIED = 3

Symbol, das angibt, dass das Schlüsselwort „nullable“ nicht an eine Spalte übergeben wurde.

Dies wird verwendet, um den Anwendungsfall der Übergabe von nullable=None an eine Column zu unterscheiden, was auf einigen Backends wie SQL Server eine besondere Bedeutung hat.

attribut sqlalchemy.schema.SchemaConst.RETAIN_SCHEMA = 1

Symbol, das angibt, dass ein Table-, Sequence- oder in einigen Fällen ein ForeignKey-Objekt, in Situationen, in denen das Objekt für eine Table.to_metadata()-Operation kopiert wird, den bereits vorhandenen Schemanamen beibehalten soll.

klasse sqlalchemy.schema.SchemaItem

Basisklasse für Elemente, die ein Datenbankschema definieren.

Mitglieder

info

Klassensignatur

class sqlalchemy.schema.SchemaItem (sqlalchemy.sql.expression.SchemaEventTarget, sqlalchemy.sql.visitors.Visitable)

Attribut sqlalchemy.schema.SchemaItem.info

Info-Dictionary, das dem Objekt zugeordnet ist und es ermöglicht, benutzerdefinierte Daten diesem SchemaItem zuzuordnen.

Das Dictionary wird automatisch generiert, wenn es zum ersten Mal aufgerufen wird. Es kann auch im Konstruktor einiger Objekte, wie z. B. Table und Column, angegeben werden.

Funktion sqlalchemy.schema.insert_sentinel(name: str | None = None, type_: _TypeEngineArgument[_T] | None = None, *, default: Any | None = None, omit_from_statements: bool = True) → Column[Any]

Bietet eine Ersatz- Column, die als dedizierte Insert- Sentinel-Spalte fungiert und effiziente Masseneinfügungen mit deterministischer RETURNING-Sortierung für Tabellen ermöglicht, die ansonsten keine qualifizierenden Primärschlüsselkonfigurationen aufweisen.

Das Hinzufügen dieser Spalte zu einem Table-Objekt erfordert, dass eine entsprechende Datenbanktabelle diese Spalte tatsächlich enthält. Wenn sie zu einem vorhandenen Modell hinzugefügt wird, müssten vorhandene Datenbanktabellen migriert werden (z. B. mit ALTER TABLE oder ähnlichem), um diese Spalte aufzunehmen.

Hintergrundinformationen zur Verwendung dieses Objekts finden Sie im Abschnitt Konfigurieren von Sentinel-Spalten als Teil des Abschnitts "Insert Many Values" Verhalten für INSERT-Anweisungen.

Die zurückgegebene Column ist standardmäßig eine nullable Integer-Spalte und verwendet einen Sentinel-spezifischen Standardgenerator, der nur für "insertmanyvalues"-Operationen verwendet wird.

Siehe auch

orm_insert_sentinel()

Column.insert_sentinel

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

Konfiguration von Sentinel-Spalten

Neu in Version 2.0.10.

Klasse sqlalchemy.schema.Table

Repräsentiert eine Tabelle in einer Datenbank.

z. B.

mytable = Table(
    "mytable",
    metadata,
    Column("mytable_id", Integer, primary_key=True),
    Column("value", String(50)),
)

Das Table-Objekt konstruiert eine eindeutige Instanz von sich selbst basierend auf seinem Namen und einem optionalen Schemanamen innerhalb des gegebenen MetaData-Objekts. Das mehrmalige Aufrufen des Table-Konstruktors mit demselben Namen und demselben MetaData-Argument gibt dasselbe Table-Objekt zurück. Auf diese Weise fungiert der Table-Konstruktor als Registrierungsfunktion.

Siehe auch

Datenbanken mit MetaData beschreiben - Einführung in die Datenbankmetadaten.

Mitglieder

__init__(), add_is_dependent_on(), alias(), append_column(), append_constraint(), argument_for(), autoincrement_column, c, columns, compare(), compile(), constraints, corresponding_column(), create(), delete(), description, dialect_kwargs, dialect_options, drop(), entity_namespace, exported_columns, foreign_key_constraints, foreign_keys, get_children(), implicit_returning, indexes, info, inherit_cache, insert(), is_derived_from(), join(), key, kwargs, lateral(), outerjoin(), params(), primary_key, replace_selectable(), schema, select(), self_group(), table_valued(), tablesample(), to_metadata(), tometadata(), unique_params(), update()

Klassensignatur

class sqlalchemy.schema.Table (sqlalchemy.sql.base.DialectKWArgs, sqlalchemy.schema.HasSchemaAttr, sqlalchemy.sql.expression.TableClause, sqlalchemy.inspection.Inspectable)

Methode sqlalchemy.schema.Table.__init__(name: str, metadata: MetaData, *args: SchemaItem, schema: str | Literal[SchemaConst.BLANK_SCHEMA] | None = None, quote: bool | None = None, quote_schema: bool | None = None, autoload_with: Engine | Connection | None = None, autoload_replace: bool = True, keep_existing: bool = False, extend_existing: bool = False, resolve_fks: bool = True, include_columns: Collection[str] | None = None, implicit_returning: bool = True, comment: str | None = None, info: Dict[Any, Any] | None = None, listeners: _typing_Sequence[Tuple[str, Callable[..., Any]]] | None = None, prefixes: _typing_Sequence[str] | None = None, _extend_on: Set[Table] | None = None, _no_init: bool = True, **kw: Any) → None

Konstruktor für Table.

Parameter:

• name –

  Der Name dieser Tabelle, wie sie in der Datenbank dargestellt wird.

  Der Tabellenname bildet zusammen mit dem Wert des Parameters schema einen Schlüssel, der diese Table innerhalb der besitzenden MetaData-Sammlung eindeutig identifiziert. Zusätzliche Aufrufe von Table mit demselben Namen, Metadaten und Schemanamen geben dasselbe Table-Objekt zurück.

  Namen ohne Großbuchstaben werden als case-insensitiv behandelt und nicht in Anführungszeichen gesetzt, es sei denn, sie sind ein reserviertes Wort oder enthalten Sonderzeichen. Ein Name mit beliebiger Anzahl von Großbuchstaben gilt als case-sensitiv und wird in Anführungszeichen gesetzt.

  Um die bedingungslose Quoting für den Tabellennamen zu aktivieren, geben Sie das Flag quote=True an den Konstruktor an oder verwenden Sie die quoted_name-Konstruktion, um den Namen anzugeben.

• metadata – ein MetaData-Objekt, das diese Tabelle enthalten wird. Die Metadaten werden als Bezugspunkt für die Zuordnung dieser Tabelle zu anderen Tabellen verwendet, auf die über Fremdschlüssel verwiesen wird. Sie können auch verwendet werden, um diese Tabelle einem bestimmten Connection oder Engine zuzuordnen.

• *args – Zusätzliche positionsbezogene Argumente werden hauptsächlich verwendet, um die Liste der Column-Objekte hinzuzufügen, die diese Tabelle enthält. Ähnlich wie bei einer CREATE TABLE-Anweisung können hier andere SchemaItem-Konstrukte hinzugefügt werden, einschließlich PrimaryKeyConstraint und ForeignKeyConstraint.

• autoload_replace –

  Standardmäßig True; bei Verwendung von Table.autoload_with in Verbindung mit Table.extend_existing gibt an, dass Column-Objekte, die in der bereits vorhandenen Table vorhanden sind, durch Spalten mit demselben Namen ersetzt werden sollen, die aus dem Autoload-Prozess abgerufen wurden. Wenn False, werden bereits vorhandene Spalten unter bestehenden Namen vom Reflexionsprozess ausgeschlossen.

  Beachten Sie, dass diese Einstellung keine Auswirkungen auf Column-Objekte hat, die programmatisch im Aufruf von Table angegeben werden, das ebenfalls autoloading durchführt; diese Column-Objekte ersetzen immer vorhandene Spalten mit demselben Namen, wenn Table.extend_existing auf True gesetzt ist.

  Siehe auch

  Table.autoload_with

  Table.extend_existing

• autoload_with –

  Ein Engine oder Connection-Objekt oder ein Inspector-Objekt, wie es von inspect() für eines dieser Objekte zurückgegeben wird, mit dem dieses Table-Objekt reflektiert wird. Wenn auf einen Nicht-Null-Wert gesetzt, wird der Autoload-Prozess für diese Tabelle gegen die gegebene Engine oder Verbindung durchgeführt.

  Siehe auch

  Datenbankobjekte reflektieren

  DDLEvents.column_reflect()

  Reflexion mit datenbankunabhängigen Typen

• extend_existing –

  Wenn True, gibt an, dass, wenn diese Table bereits in den gegebenen MetaData vorhanden ist, weitere Argumente im Konstruktor auf die vorhandene Table angewendet werden.

  Wenn Table.extend_existing oder Table.keep_existing nicht gesetzt sind und der gegebene Name der neuen Table sich auf eine Table bezieht, die bereits in der Ziel-MetaData vorhanden ist, und diese Table zusätzliche Spalten oder andere Konstrukte oder Flags spezifiziert, die den Zustand der Tabelle modifizieren, wird ein Fehler ausgelöst. Der Zweck dieser beiden sich gegenseitig ausschließenden Flags ist es, anzugeben, welche Aktion ausgeführt werden soll, wenn eine Table angegeben wird, die einer vorhandenen Table entspricht, aber zusätzliche Konstrukte spezifiziert.

  Table.extend_existing funktioniert auch in Verbindung mit Table.autoload_with, um eine neue Reflexionsoperation gegen die Datenbank auszuführen, auch wenn eine Table mit demselben Namen bereits in den Ziel-MetaData vorhanden ist; neu reflektierte Column-Objekte und andere Optionen werden in den Zustand der Table aufgenommen und können vorhandene Spalten und Optionen mit demselben Namen überschreiben.

  Wie immer bei Table.autoload_with können Column-Objekte im selben Table-Konstruktor angegeben werden, was Vorrang hat. Unten wird die vorhandene Tabelle mytable um Column-Objekte erweitert, die sowohl aus der Datenbank reflektiert als auch mit der angegebenen Column namens „y“.

  Table(
      "mytable",
      metadata,
      Column("y", Integer),
      extend_existing=True,
      autoload_with=engine,
  )

  Siehe auch

  Table.autoload_with

  Table.autoload_replace

  Table.keep_existing

• implicit_returning –

  Standardmäßig True – gibt an, dass RETURNING verwendet werden kann, typischerweise vom ORM, um serverseitig generierte Werte wie Primärschlüssel und serverseitige Standardwerte abzurufen, auf den Backends, die RETURNING unterstützen.

  Im modernen SQLAlchemy gibt es im Allgemeinen keinen Grund, diese Einstellung zu ändern, außer in einigen Backend-spezifischen Fällen (siehe Trigger in der SQL Server-Dialektdokumentation als ein solches Beispiel).

• include_columns – Eine Liste von Strings, die eine Teilmenge der Spalten angeben, die über den autoload-Vorgang geladen werden sollen; Tabellenspalten, die nicht in dieser Liste enthalten sind, werden nicht im resultierenden Table-Objekt dargestellt. Standardmäßig None, was bedeutet, dass alle Spalten reflektiert werden sollen.

• resolve_fks –

  Ob Table-Objekte, die über ForeignKey-Objekte mit dieser verbunden sind, reflektiert werden sollen, wenn Table.autoload_with angegeben ist. Standardmäßig True. Auf False gesetzt, um die Reflexion von zugehörigen Tabellen zu deaktivieren, wenn ForeignKey-Objekte angetroffen werden; kann entweder zur Einsparung von SQL-Aufrufen oder zur Vermeidung von Problemen mit zugehörigen Tabellen, auf die nicht zugegriffen werden kann, verwendet werden. Beachten Sie, dass, wenn eine zugehörige Tabelle bereits in der MetaData-Sammlung vorhanden ist oder später vorhanden wird, ein ForeignKey-Objekt, das dieser Table zugeordnet ist, normalerweise auf diese Tabelle aufgelöst wird.

  Neu in Version 1.3.

  Siehe auch

  MetaData.reflect.resolve_fks

• info – Optionale Daten zu einem Wörterbuch, das in das Attribut SchemaItem.info dieses Objekts aufgenommen wird.

• keep_existing –

  Wenn True, gibt an, dass, wenn diese Tabelle bereits in den gegebenen MetaData vorhanden ist, weitere Argumente im Konstruktor für die vorhandene Table ignoriert werden und das Table-Objekt so zurückgegeben wird, wie es ursprünglich erstellt wurde. Dies soll es einer Funktion ermöglichen, beim ersten Aufruf eine neue Table zu definieren, bei nachfolgenden Aufrufen jedoch dasselbe Table-Objekt zurückzugeben, ohne dass die Deklarationen (insbesondere Constraints) ein zweites Mal angewendet werden.

  Wenn Table.extend_existing oder Table.keep_existing nicht gesetzt sind und der gegebene Name der neuen Table sich auf eine Table bezieht, die bereits in der Ziel-MetaData vorhanden ist, und diese Table zusätzliche Spalten oder andere Konstrukte oder Flags spezifiziert, die den Zustand der Tabelle modifizieren, wird ein Fehler ausgelöst. Der Zweck dieser beiden sich gegenseitig ausschließenden Flags ist es, anzugeben, welche Aktion ausgeführt werden soll, wenn eine Table angegeben wird, die einer vorhandenen Table entspricht, aber zusätzliche Konstrukte spezifiziert.

  Siehe auch

  Table.extend_existing

• listeners –

  Eine Liste von Tupeln der Form (<eventname>, <fn>), die bei der Konstruktion an listen() übergeben werden. Dieser alternative Hook zu listen() ermöglicht die Einrichtung einer Listener-Funktion, die spezifisch für diese Table ist, bevor der „autoload“-Prozess beginnt. Historisch wurde dies für die Verwendung mit dem DDLEvents.column_reflect()-Ereignis vorgesehen. Beachten Sie jedoch, dass dieser Ereignis-Hook nun direkt mit dem MetaData-Objekt verknüpft sein kann.

  def listen_for_reflect(table, column_info):
      "handle the column reflection event"
      # ...
  
  
  t = Table(
      "sometable",
      autoload_with=engine,
      listeners=[("column_reflect", listen_for_reflect)],
  )

  Siehe auch

  DDLEvents.column_reflect()

• must_exist – Wenn True, bedeutet dies, dass diese Tabelle bereits in der angegebenen MetaData-Sammlung vorhanden sein muss, andernfalls wird eine Ausnahme ausgelöst.

• prefixes – Eine Liste von Zeichenketten, die nach CREATE in der CREATE TABLE-Anweisung eingefügt werden. Sie werden durch Leerzeichen getrennt.

• quote –

  Erzwingt das Anführungszeichen für den Namen dieser Tabelle, entsprechend True oder False. Wenn dieser Wert auf dem Standardwert None belassen wird, wird der Spaltenidentifikator entsprechend der Groß-/Kleinschreibung (Bezeichner mit mindestens einem Großbuchstaben werden als groß-/kleinschreibungsabhängig behandelt) oder ob es sich um ein reserviertes Wort handelt, in Anführungszeichen gesetzt. Dieses Flag ist nur erforderlich, um ein reserviertes Wort, das dem SQLAlchemy-Dialekt nicht bekannt ist, in Anführungszeichen zu setzen.

  Hinweis

  Das Setzen dieses Flags auf False bietet kein Case-Insensitive-Verhalten für die Tabellenspiegelung; die Tabellenspiegelung sucht immer nach einem gemischtsprachigen Namen in einer Case-Sensitive-Weise. Case-Insensitive Namen werden in SQLAlchemy nur durch Angabe des Namens mit ausschließlich Kleinbuchstaben angegeben.

• quote_schema – dasselbe wie 'quote', gilt aber für den Schema-Identifier.

• schema –

  Der Schemaname für diese Tabelle, der erforderlich ist, wenn die Tabelle in einem anderen Schema als dem standardmäßig ausgewählten Schema für die Datenbankverbindung der Engine liegt. Standardmäßig None.

  Wenn die übergeordnete MetaData dieser Table ihren eigenen MetaData.schema-Parameter angibt, dann wird dieser Schemaname auf diese Table angewendet, wenn der Schema-Parameter hier auf None gesetzt ist. Um einen leeren Schemanamen für eine Table festzulegen, die ansonsten das auf der übergeordneten MetaData gesetzte Schema verwenden würde, geben Sie das spezielle Symbol BLANK_SCHEMA an.

  Die Regeln für die Anführungszeichen für den Schemanamen sind dieselben wie für den Parameter name, insofern als Anführungszeichen für reservierte Wörter oder groß-/kleinschreibungsabhängige Namen angewendet werden; um eine bedingungslose Anführungszeichensetzung für den Schemanamen zu aktivieren, geben Sie das Flag quote_schema=True im Konstruktor an oder verwenden Sie das quoted_name-Konstrukt, um den Namen anzugeben.

• comment –

  Optionaler String, der beim Erstellen der Tabelle einen SQL-Kommentar rendert.

  Neu in Version 1.2: Der Parameter Table.comment wurde zu Table hinzugefügt.

• **kw – Zusätzliche Schlüsselwortargumente, die nicht oben erwähnt sind, sind Dialekt-spezifisch und werden in der Form <dialectname>_<argname> übergeben. Weitere Details zu dokumentierten Argumenten finden Sie in der Dokumentation zu den einzelnen Dialekten unter Dialekte.

methode sqlalchemy.schema.Table.add_is_dependent_on(table: Table) → None

Fügt eine „Abhängigkeit“ für diese Tabelle hinzu.

Dies ist ein weiteres Tabellenobjekt, das zuerst erstellt werden muss, bevor dieses erstellt werden kann, oder nach diesem gelöscht werden kann.

Normalerweise werden Abhängigkeiten zwischen Tabellen über ForeignKey-Objekte ermittelt. Für andere Situationen, die Abhängigkeiten außerhalb von Fremdschlüsseln erzeugen (Regeln, Vererbung), kann diese Methode jedoch manuell eine solche Verknüpfung herstellen.

methode sqlalchemy.schema.Table.alias(name: str | None = None, flat: bool = False) → NamedFromClause

geerbt von der FromClause.alias()-Methode von FromClause

Gibt einen Alias dieser FromClause zurück.

Z. B.

a2 = some_table.alias("a2")

Der obige Code erstellt ein Alias-Objekt, das als FROM-Klausel in jeder SELECT-Anweisung verwendet werden kann.

Siehe auch

Verwendung von Aliasen

alias()

methode sqlalchemy.schema.Table.append_column(column: ColumnClause[Any], replace_existing: bool = False) → None

Fügt eine Column zu dieser Table hinzu.

Der „Schlüssel“ der neu hinzugefügten Column, d.h. der Wert ihres .key-Attributs, ist dann in der .c-Sammlung dieser Table verfügbar und die Spaltendefinition wird in allen CREATE TABLE-, SELECT-, UPDATE- usw. Anweisungen enthalten sein, die aus diesem Table-Konstrukt generiert werden.

Beachten Sie, dass dies die Definition der Tabelle, wie sie in einer zugrundeliegenden Datenbank existiert, **nicht** ändert, vorausgesetzt, diese Tabelle wurde bereits in der Datenbank erstellt. Relationale Datenbanken unterstützen das Hinzufügen von Spalten zu bestehenden Tabellen mit dem SQL ALTER-Befehl, der für eine bereits existierende Tabelle, die die neu hinzugefügte Spalte nicht enthält, ausgegeben werden müsste.

Parameter:

replace_existing –

Wenn True, ermöglicht das Ersetzen vorhandener Spalten. Wenn False (Standard), wird eine Warnung ausgegeben, wenn bereits eine Spalte mit demselben .key existiert. Eine zukünftige Version von SQLAlchemy wird stattdessen eine Warnung ausgeben.

Neu in Version 1.4.0.

methode sqlalchemy.schema.Table.append_constraint(constraint: Index | Constraint) → None

Fügt eine Constraint zu dieser Table hinzu.

Dies hat zur Folge, dass die Einschränkung in jede zukünftige CREATE TABLE-Anweisung aufgenommen wird, vorausgesetzt, dass keine spezifischen DDL-Erstellungsereignisse mit dem gegebenen Constraint-Objekt verknüpft wurden.

Beachten Sie, dass dies die Einschränkung **nicht** automatisch in der relationalen Datenbank für eine Tabelle erzeugt, die bereits in der Datenbank existiert. Um eine Einschränkung zu einer bestehenden relationalen Datenbanktabelle hinzuzufügen, muss der SQL ALTER-Befehl verwendet werden. SQLAlchemy bietet auch das AddConstraint-Konstrukt, das diese SQL-Anweisung bei Ausführung als ausführbare Klausel erzeugen kann.

classmethod sqlalchemy.schema.Table.argument_for(dialect_name, argument_name, default)

geerbt von der DialectKWArgs.argument_for() Methode von DialectKWArgs

Fügt eine neue Art von dialektspezifischem Schlüsselwortargument für diese Klasse hinzu.

Z. B.

Index.argument_for("mydialect", "length", None)

some_index = Index("a", "b", mydialect_length=5)

Die Methode DialectKWArgs.argument_for() ist ein pro-Argument-Weg, um zusätzliche Argumente zum Dictionary DefaultDialect.construct_arguments hinzuzufügen. Dieses Dictionary enthält eine Liste von Argumentnamen, die von verschiedenen schema-level Konstrukten im Auftrag eines Dialekts akzeptiert werden.

Neue Dialekte sollten dieses Wörterbuch typischerweise auf einmal als Datenmember der Dialektklasse angeben. Der Anwendungsfall für die ad-hoc-Addition von Argumentnamen ist typischerweise für Endbenutzercode, der auch ein benutzerdefiniertes Kompilierungsschema verwendet, das die zusätzlichen Argumente konsumiert.

Parameter:

• dialect_name – Name eines Dialekts. Der Dialekt muss auffindbar sein, andernfalls wird eine NoSuchModuleError ausgelöst. Der Dialekt muss auch eine vorhandene DefaultDialect.construct_arguments-Sammlung enthalten, die angibt, dass er am Validierungs- und Standard-System für Schlüsselwortargumente teilnimmt, andernfalls wird eine ArgumentError ausgelöst. Wenn der Dialekt diese Sammlung nicht enthält, kann jedes Schlüsselwortargument bereits für diesen Dialekt angegeben werden. Alle in SQLAlchemy enthaltenen Dialekte enthalten diese Sammlung, bei Drittanbieter-Dialekten kann die Unterstützung jedoch variieren.

• argument_name – Name des Parameters.

• default – Standardwert des Parameters.

attribut sqlalchemy.schema.Table.autoincrement_column

Gibt das Column-Objekt zurück, das derzeit die „auto increment“-Spalte repräsentiert, falls vorhanden, andernfalls None.

Dies basiert auf den Regeln für Column, wie sie durch den Parameter Column.autoincrement definiert sind, was im Allgemeinen bedeutet, dass die Spalte innerhalb einer einzelnen Integer-Spalten-Primärschlüssel-Einschränkung liegt, die nicht durch einen Fremdschlüssel eingeschränkt ist. Wenn die Tabelle keine solche Primärschlüsseleinschränkung hat, gibt es keine „autoincrement“-Spalte. Eine Table kann nur eine Spalte als „autoincrement“-Spalte definiert haben.

Neu seit Version 2.0.4.

Siehe auch

Column.autoincrement

attribut sqlalchemy.schema.Table.c

geerbt von dem FromClause.c-Attribut von FromClause

Ein Synonym für FromClause.columns

Gibt zurück:

eine ColumnCollection

attribut sqlalchemy.schema.Table.columns

geerbt von dem FromClause.columns-Attribut von FromClause

Eine namensbasierte Sammlung von ColumnElement-Objekten, die von dieser FromClause verwaltet werden.

Die columns- oder c-Sammlung ist das Tor zur Konstruktion von SQL-Ausdrücken unter Verwendung von tabellengebundenen oder anderen auswählbaren Spalten.

select(mytable).where(mytable.c.somecolumn == 5)

Gibt zurück:

ein ColumnCollection-Objekt.

methode sqlalchemy.schema.Table.compare(other: ClauseElement, **kw: Any) → bool

Geerbt von der ClauseElement.compare() Methode von ClauseElement

Vergleicht dieses ClauseElement mit dem gegebenen ClauseElement.

Unterklassen sollten das Standardverhalten überschreiben, das ein direkter Identitätsvergleich ist.

**kw sind Argumente, die von den `compare()`-Methoden von Unterklassen verwendet werden und zur Modifizierung der Vergleichskriterien verwendet werden können (siehe ColumnElement).

methode sqlalchemy.schema.Table.compile(bind: _HasDialect | None = None, dialect: Dialect | None = None, **kw: Any) → Compiled

geerbt von der CompilerElement.compile() Methode von CompilerElement

Kompiliert diesen SQL-Ausdruck.

Der Rückgabewert ist ein Compiled Objekt. Das Aufrufen von str() oder unicode() auf dem zurückgegebenen Wert ergibt eine String-Repräsentation des Ergebnisses. Das Compiled Objekt kann auch ein Dictionary von Bindungsparameternamen und -werten über den params-Accessor zurückgeben.

Parameter:

• bind – Eine Connection oder Engine, die einen Dialect zur Erzeugung eines Compiled-Objekts bereitstellen kann. Wenn die Parameter bind und dialect beide weggelassen werden, wird ein Standard-SQL-Compiler verwendet.

• column_keys – Wird für INSERT- und UPDATE-Anweisungen verwendet, eine Liste von Spaltennamen, die in der VALUES-Klausel der kompilierten Anweisung enthalten sein sollen. Wenn None, werden alle Spalten des Zieltabellenobjekts gerendert.

• dialect – Eine Dialect-Instanz, die ein Compiled-Objekt erzeugen kann. Dieses Argument hat Vorrang vor dem bind-Argument.

• compile_kwargs –

  optionales Dictionary mit zusätzlichen Parametern, die an den Compiler in allen "visit"-Methoden weitergegeben werden. Dies ermöglicht es beispielsweise, benutzerdefinierte Flags an benutzerdefinierte Kompilierungskonstrukte zu übergeben. Es wird auch für den Fall verwendet, dass das Flag literal_binds weitergegeben wird.

  from sqlalchemy.sql import table, column, select
  
  t = table("t", column("x"))
  
  s = select(t).where(t.c.x == 5)
  
  print(s.compile(compile_kwargs={"literal_binds": True}))

Siehe auch

Wie rendere ich SQL-Ausdrücke als Strings, möglicherweise mit eingebetteten gebundenen Parametern?

attribut sqlalchemy.schema.Table.constraints: Set[Constraint]

Eine Sammlung aller Constraint-Objekte, die dieser Table zugeordnet sind.

Beinhaltet PrimaryKeyConstraint, ForeignKeyConstraint, UniqueConstraint, CheckConstraint. Eine separate Sammlung Table.foreign_key_constraints verweist auf die Sammlung aller ForeignKeyConstraint-Objekte, und das Attribut Table.primary_key verweist auf die einzelne PrimaryKeyConstraint, die der Table zugeordnet ist.

Siehe auch

Table.constraints

Table.primary_key

Table.foreign_key_constraints

Table.indexes

Inspektor

methode sqlalchemy.schema.Table.corresponding_column(column: KeyedColumnElement[Any], require_embedded: bool = False) → KeyedColumnElement[Any] | None

geerbt von der Selectable.corresponding_column()-Methode von Selectable

Gibt ein ColumnElement zurück, das aus der Selectable.exported_columns-Sammlung dieser Selectable exportiert wird und das dem ursprünglichen ColumnElement über einen gemeinsamen Elternelement-Spalte entspricht.

Parameter:

• column – Das Ziel ColumnElement, das abgeglichen werden soll.

• require_embedded – Nur entsprechende Spalten für das gegebene ColumnElement zurückgeben, wenn das gegebene ColumnElement tatsächlich innerhalb eines Unterelements dieser Selectable vorhanden ist. Normalerweise stimmt die Spalte überein, wenn sie lediglich einen gemeinsamen Elternteil mit einer der exportierten Spalten dieser Selectable teilt.

Siehe auch

Selectable.exported_columns - die ColumnCollection, die für den Vorgang verwendet wird.

ColumnCollection.corresponding_column() - Implementierungsmethode.

methode sqlalchemy.schema.Table.create(bind: _CreateDropBind, checkfirst: bool = False) → None

Gibt eine CREATE-Anweisung für diese Table aus und verwendet die angegebene Connection oder Engine für die Konnektivität.

Siehe auch

MetaData.create_all().

methode sqlalchemy.schema.Table.delete() → Delete

geerbt von der TableClause.delete() Methode von TableClause

Generieren Sie eine delete() Konstruktion für diese TableClause.

Z. B.

table.delete().where(table.c.id == 7)

Siehe delete() für Argumente und Nutzungsinformationen.

Attribut sqlalchemy.schema.Table.description

geerbt von der TableClause.description Attribut von TableClause

Attribut sqlalchemy.schema.Table.dialect_kwargs

geerbt von der DialectKWArgs.dialect_kwargs Attribut von DialectKWArgs

Eine Sammlung von Schlüsselwortargumenten, die als Dialekt-spezifische Optionen für dieses Konstrukt angegeben wurden.

Die Argumente sind hier in ihrem ursprünglichen Format <dialect>_<kwarg> enthalten. Nur tatsächlich übergebene Argumente sind enthalten; im Gegensatz zur Sammlung DialectKWArgs.dialect_options, die alle vom Dialekt bekannten Optionen, einschließlich Standardwerte, enthält.

Die Sammlung ist auch beschreibbar; Schlüssel werden im Format <dialect>_<kwarg> akzeptiert, wobei der Wert in die Liste der Optionen aufgenommen wird.

Siehe auch

DialectKWArgs.dialect_options - verschachtelte Dictionary-Form

Attribut sqlalchemy.schema.Table.dialect_options

geerbt von der DialectKWArgs.dialect_options Attribut von DialectKWArgs

Eine Sammlung von Schlüsselwortargumenten, die als Dialekt-spezifische Optionen für dieses Konstrukt angegeben wurden.

Dies ist eine zweistufig verschachtelte Registry, die auf <dialect_name> und <argument_name> geschlüsselt ist. Zum Beispiel ist das Argument postgresql_where auffindbar unter

arg = my_object.dialect_options["postgresql"]["where"]

Neu in Version 0.9.2.

Siehe auch

DialectKWArgs.dialect_kwargs - flache Dictionary-Form

Methode sqlalchemy.schema.Table.drop(bind: _CreateDropBind, checkfirst: bool = False) → None

Gibt eine DROP Anweisung für diese Table aus, unter Verwendung der angegebenen Connection oder Engine für die Konnektivität.

Siehe auch

MetaData.drop_all().

Attribut sqlalchemy.schema.Table.entity_namespace

geerbt von der FromClause.entity_namespace Attribut von FromClause

Gibt einen Namespace zurück, der für den namensbasierten Zugriff in SQL-Ausdrücken verwendet wird.

Dies ist der Namespace, der zur Auflösung von Ausdrücken vom Typ "filter_by()" verwendet wird, wie z. B.

stmt.filter_by(address="some address")

Standardmäßig ist dies die .c Sammlung, intern kann sie jedoch mithilfe der Annotation "entity_namespace" überschrieben werden, um alternative Ergebnisse zu liefern.

Attribut sqlalchemy.schema.Table.exported_columns

geerbt von der FromClause.exported_columns Attribut von FromClause

Eine ColumnCollection, die die "exportierten" Spalten dieser Selectable darstellt.

Die "exportierten" Spalten für ein FromClause Objekt sind gleichbedeutend mit der FromClause.columns Sammlung.

Neu in Version 1.4.

Siehe auch

Selectable.exported_columns

SelectBase.exported_columns

Attribut sqlalchemy.schema.Table.foreign_key_constraints

ForeignKeyConstraint Objekte, auf die diese Table verweist.

Diese Liste wird aus der Sammlung der aktuell zugeordneten ForeignKey Objekte erstellt.

Siehe auch

Table.constraints

Table.foreign_keys

Table.indexes

Attribut sqlalchemy.schema.Table.foreign_keys

geerbt von der FromClause.foreign_keys Attribut von FromClause

Gibt die Sammlung von ForeignKey Markierungsobjekten zurück, auf die sich diese FromClause bezieht.

Jede ForeignKey ist Mitglied einer Table-weiten ForeignKeyConstraint.

Siehe auch

Table.foreign_key_constraints

Methode sqlalchemy.schema.Table.get_children(*, omit_attrs: Tuple[str, ...] = (), **kw: Any) → Iterable[HasTraverseInternals]

geerbt von der HasTraverseInternals.get_children() Methode von HasTraverseInternals

Gibt direkte Kind-Elemente HasTraverseInternals dieses HasTraverseInternals zurück.

Dies wird für die Besuchs-Traversal verwendet.

**kw kann Flags enthalten, die die zurückgegebene Sammlung ändern, z. B. um eine Teilmenge von Elementen zurückzugeben, um größere Traversierungen zu reduzieren, oder um Kind-Elemente aus einem anderen Kontext zurückzugeben (z. B. Schema-Ebene Sammlungen anstelle von Klausel-Ebene).

Attribut sqlalchemy.schema.Table.implicit_returning = False

geerbt von der TableClause.implicit_returning Attribut von TableClause

TableClause unterstützt keine Primärschlüssel oder Standardwerte auf Spaltenebene, daher ist implizites Zurückgeben nicht anwendbar.

Attribut sqlalchemy.schema.Table.indexes: Set[Index]

Eine Sammlung aller Index Objekte, die dieser Table zugeordnet sind.

Siehe auch

Inspector.get_indexes()

Attribut sqlalchemy.schema.Table.info

geerbt von der SchemaItem.info Attribut von SchemaItem

Info-Dictionary, das dem Objekt zugeordnet ist und es ermöglicht, benutzerdefinierte Daten diesem SchemaItem zuzuordnen.

Das Dictionary wird automatisch generiert, wenn es zum ersten Mal aufgerufen wird. Es kann auch im Konstruktor einiger Objekte, wie z. B. Table und Column, angegeben werden.

Attribut sqlalchemy.schema.Table.inherit_cache: bool | None = None

geerbt von dem HasCacheKey.inherit_cache Attribut von HasCacheKey

Gibt an, ob diese HasCacheKey-Instanz das Cache-Schlüsselgenerierungsschema ihrer unmittelbaren Oberklasse verwenden soll.

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

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

Siehe auch

Unterstützung für das Caching benutzerdefinierter Konstrukte aktivieren - Allgemeine Richtlinien für das Setzen des Attributs HasCacheKey.inherit_cache für Drittanbieter- oder benutzerdefinierte SQL-Konstrukte.

Methode sqlalchemy.schema.Table.insert() → Insert

geerbt von der TableClause.insert() Methode von TableClause

Generieren Sie eine Insert Konstruktion für diese TableClause.

Z. B.

table.insert().values(name="foo")

Siehe insert() für Argumente und Nutzungsinformationen.

Methode sqlalchemy.schema.Table.is_derived_from(fromclause: FromClause | None) → bool

geerbt von der FromClause.is_derived_from() Methode von FromClause

Gibt True zurück, wenn diese FromClause von der angegebenen FromClause abgeleitet ist.

Ein Beispiel wäre ein Alias einer Tabelle, der von dieser Tabelle abgeleitet ist.

Methode sqlalchemy.schema.Table.join(right: _FromClauseArgument, onclause: _ColumnExpressionArgument[bool] | None = None, isouter: bool = False, full: bool = False) → Join

geerbt von der FromClause.join() Methode von FromClause

Gibt eine Join von dieser FromClause zu einer anderen FromClause zurück.

Z. B.

from sqlalchemy import join

j = user_table.join(
    address_table, user_table.c.id == address_table.c.user_id
)
stmt = select(user_table).select_from(j)

würde SQL in der Art von ausgeben

SELECT user.id, user.name FROM user
JOIN address ON user.id = address.user_id

Parameter:

• right – die rechte Seite des Joins; dies ist jede FromClause Objekt wie ein Table Objekt und kann auch ein wählbares Objekt wie eine ORM-gemappte Klasse sein.

• onclause – ein SQL-Ausdruck, der die ON-Klausel des Joins darstellt. Wenn er auf None belassen wird, versucht FromClause.join(), die beiden Tabellen basierend auf einer Fremdschlüsselbeziehung zu verbinden.

• isouter – wenn True, rendert einen LEFT OUTER JOIN anstelle von JOIN.

• full – wenn True, rendert einen FULL OUTER JOIN anstelle von LEFT OUTER JOIN. Impliziert FromClause.join.isouter.

Siehe auch

join() - Standalone-Funktion

Join - der Typ des erzeugten Objekts

Attribut sqlalchemy.schema.Table.key

Gibt den "Schlüssel" für diese Table zurück.

Dieser Wert wird als Dictionary-Schlüssel in der MetaData.tables Sammlung verwendet. Er ist typischerweise derselbe wie Table.name für eine Tabelle ohne Table.schema; andernfalls hat er typischerweise das Format schemaname.tablename.

Attribut sqlalchemy.schema.Table.kwargs

geerbt von dem DialectKWArgs.kwargs Attribut von DialectKWArgs

Ein Synonym für DialectKWArgs.dialect_kwargs.

Methode sqlalchemy.schema.Table.lateral(name: str | None = None) → LateralFromClause

geerbt von der Selectable.lateral() Methode von Selectable

Gibt einen LATERAL-Alias dieser Selectable zurück.

Der Rückgabewert ist die Lateral Konstruktion, die auch von der Top-Level lateral() Funktion bereitgestellt wird.

Siehe auch

LATERAL-Korrelation - Überblick über die Verwendung.

Methode sqlalchemy.schema.Table.outerjoin(right: _FromClauseArgument, onclause: _ColumnExpressionArgument[bool] | None = None, full: bool = False) → Join

geerbt von der FromClause.outerjoin() Methode von FromClause

Gibt eine Join von dieser FromClause zu einer anderen FromClause zurück, wobei das Flag "isouter" auf True gesetzt ist.

Z. B.

from sqlalchemy import outerjoin

j = user_table.outerjoin(
    address_table, user_table.c.id == address_table.c.user_id
)

Das Obige ist äquivalent zu

j = user_table.join(
    address_table, user_table.c.id == address_table.c.user_id, isouter=True
)

Parameter:

• right – die rechte Seite des Joins; dies ist jede FromClause Objekt wie ein Table Objekt und kann auch ein wählbares Objekt wie eine ORM-gemappte Klasse sein.

• onclause – ein SQL-Ausdruck, der die ON-Klausel des Joins darstellt. Wenn er auf None belassen wird, versucht FromClause.join(), die beiden Tabellen basierend auf einer Fremdschlüsselbeziehung zu verbinden.

• full – wenn True, rendert einen FULL OUTER JOIN anstelle von LEFT OUTER JOIN.

Siehe auch

FromClause.join()

Join

Methode sqlalchemy.schema.Table.params(*optionaldict, **kwargs)

geerbt von der Immutable.params() Methode von Immutable

Gibt eine Kopie zurück, bei der bindparam() Elemente ersetzt wurden.

Gibt eine Kopie dieses ClauseElement zurück, bei der bindparam() Elemente durch Werte aus dem angegebenen Wörterbuch ersetzt wurden.

>>> clause = column("x") + bindparam("foo")
>>> print(clause.compile().params)
{'foo':None}
>>> print(clause.params({"foo": 7}).compile().params)
{'foo':7}

Attribut sqlalchemy.schema.Table.primary_key

geerbt von der FromClause.primary_key Attribut von FromClause

Gibt die iterative Sammlung von Column Objekten zurück, die den Primärschlüssel dieser _selectable.FromClause bilden.

Für ein Table Objekt wird diese Sammlung durch die PrimaryKeyConstraint repräsentiert, die selbst eine iterative Sammlung von Column Objekten ist.

Methode sqlalchemy.schema.Table.replace_selectable(old: FromClause, alias: Alias) → Self

geerbt von der Selectable.replace_selectable() Methode von Selectable

Ersetzt alle Vorkommen von FromClause 'old' durch das gegebene Alias Objekt und gibt eine Kopie dieser FromClause zurück.

Veraltet seit Version 1.4: Die Methode Selectable.replace_selectable() ist veraltet und wird in einer zukünftigen Version entfernt. Ähnliche Funktionalität ist über das Modul sqlalchemy.sql.visitors verfügbar.

Attribut sqlalchemy.schema.Table.schema: str | None = None

geerbt vom FromClause.schema Attribut von FromClause

Definiert das Attribut „schema“ für diese FromClause.

Dies ist normalerweise None für die meisten Objekte, außer für Table, wo es als Wert des Arguments Table.schema übernommen wird.

Methode sqlalchemy.schema.Table.select() → Select

geerbt von der FromClause.select() Methode von FromClause

Gibt eine SELECT-Anweisung für diese FromClause zurück.

z. B.

stmt = some_table.select().where(some_table.c.id == 5)

Siehe auch

select() - allgemeine Methode, die beliebige Spaltenlisten zulässt.

Methode sqlalchemy.schema.Table.self_group(against: OperatorType | None = None) → ClauseElement

geerbt von der ClauseElement.self_group() Methode von ClauseElement

Wendet eine "Gruppierung" auf dieses ClauseElement an.

Diese Methode wird von Unterklassen überschrieben, um ein "Gruppierungs"-Konstrukt zurückzugeben, d. h. Klammern. Insbesondere wird sie von "binären" Ausdrücken verwendet, um eine Gruppierung um sich herum zu schaffen, wenn sie in einen größeren Ausdruck eingefügt werden, sowie von select() Konstrukten, wenn sie in die FROM-Klausel eines anderen select() eingefügt werden. (Beachten Sie, dass Subabfragen normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen benannte verschachtelte SELECT-Anweisungen erfordern).

Da Ausdrücke zusammengesetzt werden, erfolgt die Anwendung von self_group() automatisch - der Endbenutzercode muss diese Methode niemals direkt verwenden. Beachten Sie, dass SQLALchemy-Klauselkonstrukte die Operatorrangfolge berücksichtigen - Klammern sind möglicherweise nicht erforderlich, z. B. in einem Ausdruck wie x OR (y AND z) - AND hat Vorrang vor OR.

Die Basis- self_group() Methode von ClauseElement gibt einfach sich selbst zurück.

Methode sqlalchemy.schema.Table.table_valued() → TableValuedColumn[Any]

geerbt von der NamedFromClause.table_valued() Methode von NamedFromClause

Gibt ein TableValuedColumn Objekt für diese FromClause zurück.

Ein TableValuedColumn ist ein ColumnElement, das eine vollständige Zeile in einer Tabelle darstellt. Die Unterstützung für diese Konstruktion ist Backend-abhängig und wird in verschiedenen Formen von Backends wie PostgreSQL, Oracle Database und SQL Server unterstützt.

Z. B.

>>> from sqlalchemy import select, column, func, table
>>> a = table("a", column("id"), column("x"), column("y"))
>>> stmt = select(func.row_to_json(a.table_valued()))
>>> print(stmt)
SELECT row_to_json(a) AS row_to_json_1
FROM a

Neu ab Version 1.4.0b2.

Siehe auch

Arbeiten mit SQL-Funktionen - im SQLAlchemy Unified Tutorial

Methode sqlalchemy.schema.Table.tablesample(sampling: float | Function[Any], name: str | None = None, seed: roles.ExpressionElementRole[Any] | None = None) → TableSample

geerbt von der FromClause.tablesample() Methode von FromClause

Gibt einen TABLESAMPLE-Alias für diese FromClause zurück.

Der Rückgabewert ist der TableSample-Konstrukt, das auch von der Top-Level-Funktion tablesample() bereitgestellt wird.

Siehe auch

tablesample() - Nutzungsrichtlinien und Parameter

Methode sqlalchemy.schema.Table.to_metadata(metadata: MetaData, schema: str | Literal[SchemaConst.RETAIN_SCHEMA] = SchemaConst.RETAIN_SCHEMA, referred_schema_fn: Callable[[Table, str | None, ForeignKeyConstraint, str | None], str | None] | None = None, name: str | None = None) → Table

Gibt eine Kopie dieser Table zurück, die mit einer anderen MetaData verknüpft ist.

Z. B.

m1 = MetaData()

user = Table("user", m1, Column("id", Integer, primary_key=True))

m2 = MetaData()
user_copy = user.to_metadata(m2)

Geändert in Version 1.4: Die Funktion Table.to_metadata() wurde von Table.tometadata() umbenannt.

Parameter:

• metadata – Ziel- MetaData-Objekt, in das das neue Table-Objekt erstellt wird.

• schema –

  Optionaler String-Name, der das Zielschema angibt. Standardmäßig ist dies das spezielle Symbol RETAIN_SCHEMA, was bedeutet, dass keine Änderung am Schemanamen im neuen Table vorgenommen werden soll. Wenn ein String-Name angegeben wird, hat das neue Table diesen neuen Namen als .schema. Wenn None angegeben wird, wird das Schema auf das Schema gesetzt, das auf der Ziel- MetaData gesetzt ist, was normalerweise ebenfalls None ist, es sei denn, es wurde explizit gesetzt.

  m2 = MetaData(schema="newschema")
  
  # user_copy_one will have "newschema" as the schema name
  user_copy_one = user.to_metadata(m2, schema=None)
  
  m3 = MetaData()  # schema defaults to None
  
  # user_copy_two will have None as the schema name
  user_copy_two = user.to_metadata(m3, schema=None)

• referred_schema_fn –

  Optionaler aufrufbarer Funktionskörper, der bereitgestellt werden kann, um den Schemanamen anzugeben, der der referenzierten Tabelle eines ForeignKeyConstraint zugewiesen werden soll. Der aufrufbare Funktionskörper akzeptiert diese übergeordnete Table, das Zielschema, zu dem wir wechseln, das ForeignKeyConstraint-Objekt und das vorhandene „Zielschema“ dieser Einschränkung. Die Funktion sollte den String-Schemanamen zurückgeben, der angewendet werden soll. Um das Schema auf „leer“ zurückzusetzen, geben Sie das Symbol BLANK_SCHEMA zurück. Um keine Änderung zu bewirken, geben Sie None oder RETAIN_SCHEMA zurück.

  Geändert in Version 1.4.33: Die Funktion referred_schema_fn kann die Symbole BLANK_SCHEMA oder RETAIN_SCHEMA zurückgeben.

  Z. B.

  def referred_schema_fn(table, to_schema, constraint, referred_schema):
      if referred_schema == "base_tables":
          return referred_schema
      else:
          return to_schema
  
  
  new_table = table.to_metadata(
      m2, schema="alt_schema", referred_schema_fn=referred_schema_fn
  )

• name – Optionaler String-Name, der den Zieltabellennamen angibt. Wenn nicht angegeben oder None, wird der Tabellenname beibehalten. Dies ermöglicht das Kopieren einer Table in dieselbe MetaData-Zieladresse mit einem neuen Namen.

Methode sqlalchemy.schema.Table.tometadata(metadata: MetaData, schema: str | Literal[SchemaConst.RETAIN_SCHEMA] = SchemaConst.RETAIN_SCHEMA, referred_schema_fn: Callable[[Table, str | None, ForeignKeyConstraint, str | None], str | None] | None = None, name: str | None = None) → Table

Gibt eine Kopie dieser Table zurück, die mit einer anderen MetaData verknüpft ist.

Veraltet seit Version 1.4: Table.tometadata() wird in Table.to_metadata() umbenannt.

Siehe Table.to_metadata() für eine vollständige Beschreibung.

Methode sqlalchemy.schema.Table.unique_params(*optionaldict, **kwargs)

geerbt von der Immutable.unique_params() Methode von Immutable

Gibt eine Kopie zurück, bei der bindparam() Elemente ersetzt wurden.

Gleiche Funktionalität wie ClauseElement.params(), fügt jedoch unique=True zu betroffenen Bindparametern hinzu, damit mehrere Anweisungen verwendet werden können.

Methode sqlalchemy.schema.Table.update() → Update

geerbt von der TableClause.update() Methode von TableClause

Generiert ein update()-Konstrukt für diese TableClause.

Z. B.

table.update().where(table.c.id == 7).values(name="foo")

Siehe update() für Argument- und Nutzungsinformationen.