Anpassen von DDL

In den vorherigen Abschnitten haben wir eine Vielzahl von Schemakonstrukten wie Table, ForeignKeyConstraint, CheckConstraint und Sequence besprochen. Durchweg haben wir uns auf die Methoden create() und create_all() von Table und MetaData verlassen, um datendefinitionssprachliche (DDL) Befehle für alle Konstrukte auszugeben. Wenn diese ausgegeben werden, wird eine vordefinierte Reihenfolge von Operationen aufgerufen, und DDL zum Erstellen jeder Tabelle wird bedingungslos erstellt, einschließlich aller damit verbundenen Constraints und anderer Objekte. Für komplexere Szenarien, bei denen datenbankspezifisches DDL erforderlich ist, bietet SQLAlchemy zwei Techniken, mit denen jedes DDL basierend auf jeder Bedingung hinzugefügt werden kann, entweder begleitend zur Standardgenerierung von Tabellen oder für sich allein.

Benutzerdefiniertes DDL

Benutzerdefinierte DDL-Phrasen werden am einfachsten mit dem DDL-Konstrukt erreicht. Dieses Konstrukt funktioniert wie alle anderen DDL-Elemente, außer dass es einen String akzeptiert, der den auszugebenden Text darstellt

event.listen(
    metadata,
    "after_create",
    DDL(
        "ALTER TABLE users ADD CONSTRAINT "
        "cst_user_name_length "
        " CHECK (length(user_name) >= 8)"
    ),
)

Eine umfassendere Methode zum Erstellen von Bibliotheken von DDL-Konstrukten ist die Verwendung benutzerdefinierter Kompilierung - siehe Benutzerdefinierte SQL-Konstrukte und Kompilierungserweiterung für Details.

Steuerung von DDL-Sequenzen

Das zuvor eingeführte DDL-Konstrukt kann auch bedingt basierend auf der Inspektion der Datenbank aufgerufen werden. Diese Funktion ist über die Methode ExecutableDDLElement.execute_if() verfügbar. Wenn wir beispielsweise einen Trigger erstellen möchten, aber nur auf dem PostgreSQL-Backend, könnten wir dies wie folgt aufrufen

mytable = Table(
    "mytable",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("data", String(50)),
)

func = DDL(
    "CREATE FUNCTION my_func() "
    "RETURNS TRIGGER AS $$ "
    "BEGIN "
    "NEW.data := 'ins'; "
    "RETURN NEW; "
    "END; $$ LANGUAGE PLPGSQL"
)

trigger = DDL(
    "CREATE TRIGGER dt_ins BEFORE INSERT ON mytable "
    "FOR EACH ROW EXECUTE PROCEDURE my_func();"
)

event.listen(mytable, "after_create", func.execute_if(dialect="postgresql"))

event.listen(mytable, "after_create", trigger.execute_if(dialect="postgresql"))

Das Schlüsselwort ExecutableDDLElement.execute_if.dialect akzeptiert auch ein Tupel aus String-Dialektnamen

event.listen(
    mytable, "after_create", trigger.execute_if(dialect=("postgresql", "mysql"))
)
event.listen(
    mytable, "before_drop", trigger.execute_if(dialect=("postgresql", "mysql"))
)

Die Methode ExecutableDDLElement.execute_if() kann auch gegen eine aufrufbare Funktion arbeiten, die die verwendete Datenbankverbindung erhält. Im folgenden Beispiel verwenden wir dies, um bedingt einen CHECK-Constraint zu erstellen, indem wir zunächst die PostgreSQL-Kataloge durchsuchen, um zu sehen, ob er existiert

def should_create(ddl, target, connection, **kw):
    row = connection.execute(
        "select conname from pg_constraint where conname='%s'" % ddl.element.name
    ).scalar()
    return not bool(row)


def should_drop(ddl, target, connection, **kw):
    return not should_create(ddl, target, connection, **kw)


event.listen(
    users,
    "after_create",
    DDL(
        "ALTER TABLE users ADD CONSTRAINT "
        "cst_user_name_length CHECK (length(user_name) >= 8)"
    ).execute_if(callable_=should_create),
)
event.listen(
    users,
    "before_drop",
    DDL("ALTER TABLE users DROP CONSTRAINT cst_user_name_length").execute_if(
        callable_=should_drop
    ),
)

users.create(engine)
CREATE TABLE users (
    user_id SERIAL NOT NULL,
    user_name VARCHAR(40) NOT NULL,
    PRIMARY KEY (user_id)
)

SELECT conname FROM pg_constraint WHERE conname='cst_user_name_length'
ALTER TABLE users ADD CONSTRAINT cst_user_name_length  CHECK (length(user_name) >= 8)
users.drop(engine)
SELECT conname FROM pg_constraint WHERE conname='cst_user_name_length'
ALTER TABLE users DROP CONSTRAINT cst_user_name_length
DROP TABLE users

Verwenden der integrierten DDLElement-Klassen

Das Paket sqlalchemy.schema enthält SQL-Ausdruckskonstrukte, die DDL-Ausdrücke bereitstellen, die alle von der gemeinsamen Basisklasse ExecutableDDLElement erben. Um beispielsweise eine CREATE TABLE-Anweisung zu erzeugen, kann das CreateTable-Konstrukt verwendet werden

from sqlalchemy.schema import CreateTable

with engine.connect() as conn:
    conn.execute(CreateTable(mytable))
CREATE TABLE mytable (
    col1 INTEGER,
    col2 INTEGER,
    col3 INTEGER,
    col4 INTEGER,
    col5 INTEGER,
    col6 INTEGER
)

Oben funktioniert das CreateTable-Konstrukt wie jedes andere Ausdruckskonstrukt (wie select(), table.insert() usw.). Alle DDL-orientierten Konstrukte von SQLAlchemy sind Unterklassen der Basisklasse ExecutableDDLElement. Dies ist die Basis aller Objekte, die CREATE und DROP sowie ALTER entsprechen, nicht nur in SQLAlchemy, sondern auch in Alembic Migrations. Eine vollständige Referenz der verfügbaren Konstrukte finden Sie in DDL-Ausdruckskonstrukte API.

Benutzerdefinierte DDL-Konstrukte können auch als Unterklassen von ExecutableDDLElement selbst erstellt werden. Die Dokumentation unter Benutzerdefinierte SQL-Konstrukte und Kompilierungserweiterung enthält mehrere Beispiele hierfür.

Steuerung der DDL-Generierung von Constraints und Indizes

Neu in Version 2.0.

Während die zuvor erwähnte Methode ExecutableDDLElement.execute_if() für benutzerdefinierte DDL-Klassen nützlich ist, die bedingt aufgerufen werden müssen, gibt es auch einen häufigen Bedarf für Elemente, die typischerweise mit einer bestimmten Table verbunden sind, nämlich Constraints und Indizes, um ebenfalls "bedingten" Regeln zu unterliegen, wie z. B. einem Index, der Funktionen enthält, die für ein bestimmtes Backend wie PostgreSQL oder SQL Server spezifisch sind. Für diesen Anwendungsfall können die Methoden Constraint.ddl_if() und Index.ddl_if() gegen Konstrukte wie CheckConstraint, UniqueConstraint und Index verwendet werden. Sie akzeptieren dieselben Argumente wie die Methode ExecutableDDLElement.execute_if(), um zu steuern, ob ihre DDL-Befehle im Hinblick auf ihr übergeordnetes Table-Objekt ausgegeben werden. Diese Methoden können Inline beim Erstellen der Definition für eine Table (oder ähnlich bei Verwendung der __table_args__-Sammlung in einem ORM-Deklarationsmapping) verwendet werden, wie z. B.

from sqlalchemy import CheckConstraint, Index
from sqlalchemy import MetaData, Table, Column
from sqlalchemy import Integer, String

meta = MetaData()

my_table = Table(
    "my_table",
    meta,
    Column("id", Integer, primary_key=True),
    Column("num", Integer),
    Column("data", String),
    Index("my_pg_index", "data").ddl_if(dialect="postgresql"),
    CheckConstraint("num > 5").ddl_if(dialect="postgresql"),
)

Im obigen Beispiel bezieht sich das Table-Konstrukt sowohl auf ein Index- als auch auf ein CheckConstraint-Konstrukt, die beide .ddl_if(dialect="postgresql") angeben, was bedeutet, dass diese Elemente nur bei der PostgreSQL-Dialekt bei der CREATE TABLE-Sequenz enthalten sind. Wenn wir beispielsweise meta.create_all() gegen die SQLite-Dialekt ausführen, werden keine der beiden Konstrukte einbezogen

>>> from sqlalchemy import create_engine
>>> sqlite_engine = create_engine("sqlite+pysqlite://", echo=True)
>>> meta.create_all(sqlite_engine)
BEGIN (implicit)
PRAGMA main.table_info("my_table")
[raw sql] ()
PRAGMA temp.table_info("my_table")
[raw sql] ()

CREATE TABLE my_table (
    id INTEGER NOT NULL,
    num INTEGER,
    data VARCHAR,
    PRIMARY KEY (id)
)

Wenn wir jedoch dieselben Befehle gegen eine PostgreSQL-Datenbank ausführen, sehen wir Inline-DDL für den CHECK-Constraint sowie eine separate CREATE-Anweisung für den Index

>>> from sqlalchemy import create_engine
>>> postgresql_engine = create_engine(
...     "postgresql+psycopg2://scott:tiger@localhost/test", echo=True
... )
>>> meta.create_all(postgresql_engine)
BEGIN (implicit)
select relname from pg_class c join pg_namespace n on n.oid=c.relnamespace where pg_catalog.pg_table_is_visible(c.oid) and relname=%(name)s
[generated in 0.00009s] {'name': 'my_table'}

CREATE TABLE my_table (
    id SERIAL NOT NULL,
    num INTEGER,
    data VARCHAR,
    PRIMARY KEY (id),
    CHECK (num > 5)
)
[no key 0.00007s] {}
CREATE INDEX my_pg_index ON my_table (data)
[no key 0.00013s] {}
COMMIT

Die Methoden Constraint.ddl_if() und Index.ddl_if() erstellen einen Event-Hook, der nicht nur zur DDL-Ausführungszeit wie bei ExecutableDDLElement.execute_if() abgefragt werden kann, sondern auch während der SQL-Kompilierungsphase des CreateTable-Objekts, das für das Rendern des CHECK (num > 5) DDL Inline in die CREATE TABLE-Anweisung verantwortlich ist. Daher verfügt der Event-Hook, der vom Parameter ddl_if.callable_() empfangen wird, über einen reichhaltigeren Satz von Argumenten, einschließlich des Schlüsselwortarguments dialect sowie einer Instanz von DDLCompiler über das Schlüsselwortargument compiler für den "Inline-Rendering"-Teil der Sequenz. Das Argument bind ist **nicht** vorhanden, wenn das Ereignis innerhalb der DDLCompiler-Sequenz ausgelöst wird. Ein moderner Event-Hook, der die Datenbankspezifikationsinformationen inspizieren möchte, würde am besten das gegebene Dialect-Objekt verwenden, z. B. um die PostgreSQL-Spezifikationsinformationen zu testen.

def only_pg_14(ddl_element, target, bind, dialect, **kw):
    return dialect.name == "postgresql" and dialect.server_version_info >= (14,)


my_table = Table(
    "my_table",
    meta,
    Column("id", Integer, primary_key=True),
    Column("num", Integer),
    Column("data", String),
    Index("my_pg_index", "data").ddl_if(callable_=only_pg_14),
)

Siehe auch

Constraint.ddl_if()

Index.ddl_if()

DDL-Ausdruckskonstrukte API

Objektname	Beschreibung
_CreateDropBase	Basisklasse für DDL-Konstrukte, die CREATE und DROP oder Entsprechungen darstellen.
AddConstraint	Repräsentiert eine ALTER TABLE ADD CONSTRAINT-Anweisung.
BaseDDLElement	Die Wurzel der DDL-Konstrukte, einschließlich derjenigen, die Unterelemente innerhalb des "CREATE TABLE"- und anderer Prozesse sind.
CreateColumn	Stellt eine Column dar, wie sie in einer CREATE TABLE-Anweisung über das CreateTable-Konstrukt gerendert wird.
CreateIndex	Stellt eine CREATE INDEX-Anweisung dar.
CreateSchema	Stellt eine CREATE SCHEMA-Anweisung dar.
CreateSequence	Stellt eine CREATE SEQUENCE-Anweisung dar.
CreateTable	Stellt eine CREATE TABLE-Anweisung dar.
DDL	Eine wörtliche DDL-Anweisung.
DropConstraint	Repräsentiert eine ALTER TABLE DROP CONSTRAINT-Anweisung.
DropIndex	Stellt eine DROP INDEX-Anweisung dar.
DropSchema	Stellt eine DROP SCHEMA-Anweisung dar.
DropSequence	Stellt eine DROP SEQUENCE-Anweisung dar.
DropTable	Stellt eine DROP TABLE-Anweisung dar.
ExecutableDDLElement	Basisklasse für eigenständige ausführbare DDL-Ausdruckskonstrukte.
sort_tables(tables[, skip_fn, extra_dependencies])	Sortiert eine Sammlung von Table-Objekten basierend auf Abhängigkeiten.
sort_tables_and_constraints(tables[, filter_fn, extra_dependencies, _warn_for_cycles])	Sortiert eine Sammlung von Table / ForeignKeyConstraint-Objekten.

function sqlalchemy.schema.sort_tables(tables: Iterable[TableClause], skip_fn: Callable[[ForeignKeyConstraint], bool] | None = None, extra_dependencies: typing_Sequence[Tuple[TableClause, TableClause]] | None = None) → List[Table]

Sortiert eine Sammlung von Table-Objekten basierend auf Abhängigkeiten.

Dies ist eine abhängigkeitsgeordnete Sortierung, die Table-Objekte so ausgibt, dass sie ihren abhängigen Table-Objekten folgen. Tabellen sind voneinander abhängig aufgrund der Anwesenheit von ForeignKeyConstraint-Objekten sowie expliziten Abhängigkeiten, die durch Table.add_is_dependent_on() hinzugefügt wurden.

Warnung

Die Funktion sort_tables() kann nicht allein die automatische Auflösung von Abhängigkeitszyklen zwischen Tabellen unterstützen, die normalerweise durch gegenseitig abhängige Fremdschlüssel-Constraints verursacht werden. Wenn diese Zyklen erkannt werden, werden die Fremdschlüssel dieser Tabellen von der Berücksichtigung in der Sortierung ausgeschlossen. Es wird eine Warnung ausgegeben, wenn diese Bedingung auftritt, die in einer zukünftigen Version eine Ausnahme auslösen 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 Constraints angewendet werden, die einen Zyklus erzeugen. Alternativ gibt die Funktion sort_tables_and_constraints() Fremdschlüssel-Constraints bei erkannter Zyklen automatisch in einer separaten Sammlung zurück, sodass sie separat auf ein Schema angewendet werden können.

Geändert in Version 1.3.17: - Es wird eine Warnung ausgegeben, wenn sort_tables() aufgrund von zyklischen 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, die nicht am Zyklus beteiligt sind, in Abhängigkeitsreihenfolge zurückgeben, was vorher nicht der Fall war.

Parameter:

• tables – eine Sequenz von Table-Objekten.

• skip_fn – optionaler aufrufbarer Parameter, der ein ForeignKeyConstraint-Objekt erhält; wenn er True zurückgibt, wird dieses Constraint nicht als Abhängigkeit berücksichtigt. Beachten Sie, dass dies **anders** ist als beim gleichnamigen Parameter in sort_tables_and_constraints(), das stattdessen das besitzende ForeignKeyConstraint-Objekt erhält.

• extra_dependencies – eine Sequenz von 2-Tupeln von Tabellen, die ebenfalls als voneinander abhängig betrachtet werden.

Siehe auch

sort_tables_and_constraints()

MetaData.sorted_tables - verwendet diese Funktion zum Sortieren

function sqlalchemy.schema.sort_tables_and_constraints(tables, filter_fn=None, extra_dependencies=None, _warn_for_cycles=False)

Sortiert eine Sammlung von Table / ForeignKeyConstraint-Objekten.

Dies ist eine abhängigkeitsgeordnete Sortierung, die Tupel von (Table, [ForeignKeyConstraint, ...]) ausgibt, sodass jede Table ihren abhängigen Table-Objekten folgt. Verbleibende ForeignKeyConstraint-Objekte, die aufgrund von Abhängigkeitsregeln, die von der Sortierung nicht erfüllt werden, getrennt sind, werden anschließend als (None, [ForeignKeyConstraint ...]) ausgegeben.

Tabellen sind voneinander abhängig aufgrund der Anwesenheit von ForeignKeyConstraint-Objekten, expliziten Abhängigkeiten, die durch Table.add_is_dependent_on() hinzugefügt wurden, sowie Abhängigkeiten, die hier mit den Parametern sort_tables_and_constraints.skip_fn und/oder sort_tables_and_constraints.extra_dependencies angegeben sind.

Parameter:

• tables – eine Sequenz von Table-Objekten.

• filter_fn – optionaler aufrufbarer Parameter, der ein ForeignKeyConstraint-Objekt erhält und einen Wert zurückgibt, der angibt, ob dieses Constraint definitiv als Inline-Constraint einbezogen oder ausgeschlossen werden soll, oder keines von beiden. Wenn es False zurückgibt, wird das Constraint definitiv als Abhängigkeit einbezogen, die nicht durch ALTER geändert werden kann; wenn es True zurückgibt, wird es **nur** als ALTER-Ergebnis am Ende einbezogen. Wenn None zurückgegeben wird, bedeutet dies, dass das Constraint im tabellenbasierten Ergebnis enthalten ist, es sei denn, es wird als Teil eines Abhängigkeitszyklus erkannt.

• extra_dependencies – eine Sequenz von 2-Tupeln von Tabellen, die ebenfalls als voneinander abhängig betrachtet werden.

Siehe auch

sort_tables()

class sqlalchemy.schema.BaseDDLElement

Die Wurzel der DDL-Konstrukte, einschließlich derjenigen, die Unterelemente innerhalb des "CREATE TABLE"- und anderer Prozesse sind.

Neu in Version 2.0.

Klassensignatur

class sqlalchemy.schema.BaseDDLElement (sqlalchemy.sql.expression.ClauseElement)

class sqlalchemy.schema.ExecutableDDLElement

Basisklasse für eigenständige ausführbare DDL-Ausdruckskonstrukte.

Diese Klasse ist die Basis für die allgemeine Klasse DDL sowie für die verschiedenen CREATE/DROP-Klausel-Konstrukte wie CreateTable, DropTable, AddConstraint usw.

Geändert in Version 2.0: ExecutableDDLElement wurde von DDLElement umbenannt, das für Abwärtskompatibilität weiterhin existiert.

ExecutableDDLElement integriert sich eng mit SQLAlchemy-Ereignissen, die in Events eingeführt wurden. Eine Instanz davon ist selbst ein Ereignis-empfangendes aufrufbares Objekt

event.listen(
    users,
    "after_create",
    AddConstraint(constraint).execute_if(dialect="postgresql"),
)

Siehe auch

DDL

DDLEvents

Events

Steuern von DDL-Sequenzen

Mitglieder

__call__(), against(), execute_if()

Klassensignatur

class sqlalchemy.schema.ExecutableDDLElement (sqlalchemy.sql.roles.DDLRole, sqlalchemy.sql.expression.Executable, sqlalchemy.schema.BaseDDLElement)

method sqlalchemy.schema.ExecutableDDLElement.__call__(target, bind, **kw)

Führt das DDL als ddl_listener aus.

method sqlalchemy.schema.ExecutableDDLElement.against(target: SchemaItem) → Self

Gibt eine Kopie dieses ExecutableDDLElement zurück, die das angegebene Ziel enthält.

Dies wendet im Wesentlichen das gegebene Element auf das Attribut .target des zurückgegebenen ExecutableDDLElement Objekts an. Dieses Ziel kann dann von Ereignishandlern und Kompilierungsroutinen verwendet werden, um Dienste wie die Tokenisierung eines DDL-Strings im Hinblick auf eine bestimmte Table bereitzustellen.

Wenn ein ExecutableDDLElement Objekt als Ereignishandler für die Ereignisse DDLEvents.before_create() oder DDLEvents.after_create() eingerichtet wird und das Ereignis dann für ein bestimmtes Ziel wie eine Constraint oder Table eintritt, wird dieses Ziel mit einer Kopie des ExecutableDDLElement Objekts über diese Methode eingerichtet, die dann zur Methode ExecutableDDLElement.execute() übergeht, um die tatsächliche DDL-Anweisung aufzurufen.

Parameter:

target – ein SchemaItem, das das Ziel einer DDL-Operation sein wird.

Gibt zurück:

eine Kopie dieses ExecutableDDLElement mit dem Attribut .target, das dem gegebenen SchemaItem zugewiesen ist.

Siehe auch

DDL - verwendet Tokenisierung gegen das „target“ bei der Verarbeitung des DDL-Strings.

method sqlalchemy.schema.ExecutableDDLElement.execute_if(dialect: str | None = None, callable_: DDLIfCallable | None = None, state: Any | None = None) → Self

Gibt eine aufrufbare Funktion zurück, die dieses ExecutableDDLElement bedingt innerhalb eines Ereignishandlers ausführt.

Wird verwendet, um einen Wrapper für die Ereignisverfolgung bereitzustellen

event.listen(
    metadata,
    "before_create",
    DDL("my_ddl").execute_if(dialect="postgresql"),
)

Parameter:

• dialect –

  Kann eine Zeichenkette oder ein Tupel von Zeichenketten sein. Wenn es eine Zeichenkette ist, wird sie mit dem Namen des ausführenden Datenbankdialekts verglichen.

  DDL("something").execute_if(dialect="postgresql")

  Wenn es ein Tupel ist, werden mehrere Dialektnamen angegeben.

  DDL("something").execute_if(dialect=("postgresql", "mysql"))

• callable_ –

  Eine aufrufbare Funktion, die mit drei Positionsargumenten sowie optionalen Schlüsselwortargumenten aufgerufen wird.

  ddl:

  Dieses DDL-Element.

  target:

  Das Table oder MetaData Objekt, das das Ziel dieses Ereignisses ist. Kann None sein, wenn das DDL explizit ausgeführt wird.

  bind:

  Die Connection, die für die DDL-Ausführung verwendet wird. Kann None sein, wenn diese Konstruktion inline innerhalb einer Tabelle erstellt wird, in welchem Fall compiler vorhanden sein wird.

  tables:

  Optionales Schlüsselwortargument - eine Liste von Table-Objekten, die innerhalb eines MetaData.create_all() oder drop_all() Methodenaufrufs erstellt/gelöscht werden sollen.

  dialect:

  Schlüsselwortargument, aber immer vorhanden - der Dialect, der an der Operation beteiligt ist.

  compiler:

  Schlüsselwortargument. Ist None für einen DDL-Aufruf auf Engine-Ebene, aber verweist auf einen DDLCompiler, wenn dieses DDL-Element inline innerhalb einer Tabelle erstellt wird.

  state:

  Optionales Schlüsselwortargument - ist der Wert, der dem Argument `state` dieses Funktionsaufrufs übergeben wurde.

  checkfirst:

  Schlüsselwortargument, ist True, wenn das Flag 'checkfirst' während des Aufrufs von create(), create_all(), drop(), drop_all() gesetzt wurde.

  Wenn die aufrufbare Funktion einen True-Wert zurückgibt, wird die DDL-Anweisung ausgeführt.

• state – jeder Wert, der als Schlüsselwortargument state an die aufrufbare Funktion übergeben wird.

Siehe auch

SchemaItem.ddl_if()

DDLEvents

Events

class sqlalchemy.schema.DDL

Eine wörtliche DDL-Anweisung.

Definiert wörtliche SQL DDL-Anweisungen, die von der Datenbank ausgeführt werden sollen. DDL-Objekte fungieren als DDL-Ereignis-Listener und können über die in DDLEvents aufgeführten Ereignisse abonniert werden, wobei entweder Table oder MetaData Objekte als Ziele verwendet werden. Grundlegende Vorlagenunterstützung ermöglicht es einer einzelnen DDL-Instanz, repetitive Aufgaben für mehrere Tabellen zu handhaben.

Beispiele

from sqlalchemy import event, DDL

tbl = Table("users", metadata, Column("uid", Integer))
event.listen(tbl, "before_create", DDL("DROP TRIGGER users_trigger"))

spow = DDL("ALTER TABLE %(table)s SET secretpowers TRUE")
event.listen(tbl, "after_create", spow.execute_if(dialect="somedb"))

drop_spow = DDL("ALTER TABLE users SET secretpowers FALSE")
connection.execute(drop_spow)

Bei der Verarbeitung von Tabellenereignissen sind die folgenden Ersetzungen für die Zeichenkette statement verfügbar

%(table)s  - the Table name, with any required quoting applied
%(schema)s - the schema name, with any required quoting applied
%(fullname)s - the Table name including schema, quoted if needed

Der „Kontext“ des DDL wird mit den oben genannten Standardersetzungen kombiniert. Schlüssel, die im Kontext vorhanden sind, überschreiben die Standardersetzungen.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.schema.DDL (sqlalchemy.schema.ExecutableDDLElement)

method sqlalchemy.schema.DDL.__init__(statement, context=None)

Erstellt eine DDL-Anweisung.

Parameter:

• statement –

  Eine Zeichenkette oder Unicode-Zeichenkette, die ausgeführt werden soll. Anweisungen werden mit dem String-Formatierungsoperator von Python verarbeitet, wobei eine feste Menge von Zeichenkettenersetzungen sowie zusätzliche Ersetzungen verwendet werden, die durch den optionalen Parameter DDL.context bereitgestellt werden.

  Ein wörtliches '%' in einer Anweisung muss als '%%' maskiert werden.

  SQL-Bindungsparameter sind in DDL-Anweisungen nicht verfügbar.

• context – Optionales Wörterbuch, Standardwert ist None. Diese Werte stehen für Zeichenkettenersetzungen in der DDL-Anweisung zur Verfügung.

Siehe auch

DDLEvents

Events

class sqlalchemy.schema._CreateDropBase

Basisklasse für DDL-Konstrukte, die CREATE und DROP oder Entsprechungen darstellen.

Das gemeinsame Merkmal von _CreateDropBase ist ein einzelnes Attribut element, das sich auf das zu erstellende oder zu löschende Element bezieht.

Klassensignatur

class sqlalchemy.schema._CreateDropBase (sqlalchemy.schema.ExecutableDDLElement)

class sqlalchemy.schema.CreateTable

Stellt eine CREATE TABLE-Anweisung dar.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.schema.CreateTable (sqlalchemy.schema._CreateBase)

method sqlalchemy.schema.CreateTable.__init__(element: Table, include_foreign_key_constraints: typing_Sequence[ForeignKeyConstraint] | None = None, if_not_exists: bool = False)

Erstellt eine CreateTable-Konstruktion.

Parameter:

• element – eine Table, die das Thema von CREATE ist.

• on – Siehe die Beschreibung für 'on' in DDL.

• include_foreign_key_constraints – optionale Sequenz von ForeignKeyConstraint Objekten, die inline innerhalb der CREATE-Konstruktion enthalten sein werden; wenn weggelassen, werden alle Fremdschlüssel-Constraints enthalten, die nicht use_alter=True angeben.

• if_not_exists –

  wenn True, wird ein IF NOT EXISTS Operator auf die Konstruktion angewendet.

  Neu ab Version 1.4.0b2.

class sqlalchemy.schema.DropTable

Stellt eine DROP TABLE-Anweisung dar.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.schema.DropTable (sqlalchemy.schema._DropBase)

method sqlalchemy.schema.DropTable.__init__(element: Table, if_exists: bool = False)

Erstellt eine DropTable-Konstruktion.

Parameter:

• element – eine Table, die das Thema von DROP ist.

• on – Siehe die Beschreibung für 'on' in DDL.

• if_exists –

  wenn True, wird ein IF EXISTS Operator auf die Konstruktion angewendet.

  Neu ab Version 1.4.0b2.

class sqlalchemy.schema.CreateColumn

Stellt eine Column dar, wie sie in einer CREATE TABLE-Anweisung über das CreateTable-Konstrukt gerendert wird.

Dies dient zur Unterstützung benutzerdefinierter Spalten-DDLs bei der Generierung von CREATE TABLE-Anweisungen, indem die in Custom SQL Constructs and Compilation Extension dokumentierte Compiler-Erweiterung verwendet wird, um CreateColumn zu erweitern.

Die typische Integration besteht darin, das eingehende Column-Objekt zu untersuchen und die Kompilierung umzuleiten, wenn ein bestimmtes Flag oder eine Bedingung gefunden wird.

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


@compiles(schema.CreateColumn)
def compile(element, compiler, **kw):
    column = element.element

    if "special" not in column.info:
        return compiler.visit_create_column(element, **kw)

    text = "%s SPECIAL DIRECTIVE %s" % (
        column.name,
        compiler.type_compiler.process(column.type),
    )
    default = compiler.get_column_default_string(column)
    if default is not None:
        text += " DEFAULT " + default

    if not column.nullable:
        text += " NOT NULL"

    if column.constraints:
        text += " ".join(
            compiler.process(const) for const in column.constraints
        )
    return text

Die obige Konstruktion kann wie folgt auf eine Table angewendet werden

from sqlalchemy import Table, Metadata, Column, Integer, String
from sqlalchemy import schema

metadata = MetaData()

table = Table(
    "mytable",
    MetaData(),
    Column("x", Integer, info={"special": True}, primary_key=True),
    Column("y", String(50)),
    Column("z", String(20), info={"special": True}),
)

metadata.create_all(conn)

Oben werden die Direktiven, die wir der Column.info-Sammlung hinzugefügt haben, von unserem benutzerdefinierten Kompilierungsschema erkannt.

CREATE TABLE mytable (
        x SPECIAL DIRECTIVE INTEGER NOT NULL,
        y VARCHAR(50),
        z SPECIAL DIRECTIVE VARCHAR(20),
    PRIMARY KEY (x)
)

Die CreateColumn-Konstruktion kann auch verwendet werden, um bestimmte Spalten beim Erzeugen einer CREATE TABLE-Anweisung zu überspringen. Dies wird erreicht, indem eine Kompilierungsregel erstellt wird, die bedingt None zurückgibt. Dies ist im Wesentlichen, wie man denselben Effekt erzielt, als ob man das Argument system=True auf Column verwendet, das eine Spalte als implizit vorhandene "Systemspalte" kennzeichnet.

Angenommen, wir möchten eine Table erzeugen, die das Rendern der PostgreSQL xmin-Spalte auf dem PostgreSQL-Backend überspringt, aber auf anderen Backends sie rendert, in Erwartung einer getriggerten Regel. Eine bedingte Kompilierungsregel könnte diesen Namen nur auf PostgreSQL überspringen.

from sqlalchemy.schema import CreateColumn


@compiles(CreateColumn, "postgresql")
def skip_xmin(element, compiler, **kw):
    if element.element.name == "xmin":
        return None
    else:
        return compiler.visit_create_column(element, **kw)


my_table = Table(
    "mytable",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("xmin", Integer),
)

Oben erzeugt eine CreateTable-Konstruktion ein CREATE TABLE, das nur die Spalte id in der Zeichenkette enthält; die Spalte xmin wird weggelassen, aber nur gegen das PostgreSQL-Backend.

Klassensignatur

class sqlalchemy.schema.CreateColumn (sqlalchemy.schema.BaseDDLElement)

class sqlalchemy.schema.CreateSequence

Stellt eine CREATE SEQUENCE-Anweisung dar.

Klassensignatur

class sqlalchemy.schema.CreateSequence (sqlalchemy.schema._CreateBase)

class sqlalchemy.schema.DropSequence

Stellt eine DROP SEQUENCE-Anweisung dar.

Klassensignatur

class sqlalchemy.schema.DropSequence (sqlalchemy.schema._DropBase)

class sqlalchemy.schema.CreateIndex

Stellt eine CREATE INDEX-Anweisung dar.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.schema.CreateIndex (sqlalchemy.schema._CreateBase)

method sqlalchemy.schema.CreateIndex.__init__(element, if_not_exists=False)

Erstellt eine Createindex-Konstruktion.

Parameter:

• element – ein Index, der das Thema von CREATE ist.

• if_not_exists –

  wenn True, wird ein IF NOT EXISTS Operator auf die Konstruktion angewendet.

  Neu ab Version 1.4.0b2.

class sqlalchemy.schema.DropIndex

Stellt eine DROP INDEX-Anweisung dar.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.schema.DropIndex (sqlalchemy.schema._DropBase)

method sqlalchemy.schema.DropIndex.__init__(element, if_exists=False)

Erstellt eine DropIndex-Konstruktion.

Parameter:

• element – ein Index, der das Thema von DROP ist.

• if_exists –

  wenn True, wird ein IF EXISTS Operator auf die Konstruktion angewendet.

  Neu ab Version 1.4.0b2.

class sqlalchemy.schema.AddConstraint

Repräsentiert eine ALTER TABLE ADD CONSTRAINT-Anweisung.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.schema.AddConstraint (sqlalchemy.schema._CreateBase)

method sqlalchemy.schema.AddConstraint.__init__(element: Constraint, *, isolate_from_table: bool = True)

Erstellt eine neue AddConstraint-Konstruktion.

Parameter:

• element – ein Constraint-Objekt.

• isolate_from_table –

  optionales boolesches Argument, Standardwert ist True. Hat zur Folge, dass der eingehende Constraint von der Aufnahme in eine CREATE TABLE-Sequenz isoliert wird, wenn er mit einer Table assoziiert ist.

  Neu ab Version 2.0.39: - hinzugefügt AddConstraint.isolate_from_table, Standardwert ist True. Zuvor war das Verhalten dieses Parameters implizit in allen Fällen eingeschaltet.

class sqlalchemy.schema.DropConstraint

Repräsentiert eine ALTER TABLE DROP CONSTRAINT-Anweisung.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.schema.DropConstraint (sqlalchemy.schema._DropBase)

method sqlalchemy.schema.DropConstraint.__init__(element: Constraint, *, cascade: bool = False, if_exists: bool = False, isolate_from_table: bool = True, **kw: Any)

Erstellt eine neue DropConstraint-Konstruktion.

Parameter:

• element – ein Constraint-Objekt.

• cascade – optional boolean, gibt an, ob die Backend-spezifische Direktive “CASCADE CONSTRAINT” gerendert werden soll, falls verfügbar

• if_exists – optional boolean, gibt an, ob die Backend-spezifische Direktive “IF EXISTS” gerendert werden soll, falls verfügbar

• isolate_from_table –

  optionales boolesches Argument, Standardwert ist True. Hat zur Folge, dass der eingehende Constraint von der Aufnahme in eine CREATE TABLE-Sequenz isoliert wird, wenn er mit einer Table assoziiert ist.

  Neu in Version 2.0.39: - hinzugefügt DropConstraint.isolate_from_table, Standardwert ist True. Zuvor war das Verhalten dieses Parameters implizit in allen Fällen aktiviert.

class sqlalchemy.schema.CreateSchema

Stellt eine CREATE SCHEMA-Anweisung dar.

Das hier übergebene Argument ist der String-Name des Schemas.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.schema.CreateSchema (sqlalchemy.schema._CreateBase)

method sqlalchemy.schema.CreateSchema.__init__(name: str, if_not_exists: bool = False)

Erstellt ein neues CreateSchema Konstrukt.

class sqlalchemy.schema.DropSchema

Stellt eine DROP SCHEMA-Anweisung dar.

Das hier übergebene Argument ist der String-Name des Schemas.

Mitglieder

__init__()

Klassensignatur

class sqlalchemy.schema.DropSchema (sqlalchemy.schema._DropBase)

method sqlalchemy.schema.DropSchema.__init__(name: str, cascade: bool = False, if_exists: bool = False)

Erstellt ein neues DropSchema Konstrukt.