Column INSERT/UPDATE Defaults

Column INSERT- und UPDATE-Defaults beziehen sich auf Funktionen, die einen **Standardwert** für eine bestimmte Spalte einer Zeile erstellen, während ein INSERT- oder UPDATE-Statement gegen diese Zeile ausgeführt wird, falls **kein Wert für diese Spalte im INSERT- oder UPDATE-Statement angegeben wurde**. Das heißt, wenn eine Tabelle eine Spalte namens „timestamp“ hat und ein INSERT-Statement ausgeführt wird, das keinen Wert für diese Spalte enthält, würde ein INSERT-Standardwert einen neuen Wert erstellen, wie z. B. die aktuelle Zeit, der als Wert für die Spalte „timestamp“ eingefügt wird. Wenn das Statement einen Wert für diese Spalte *enthält*, findet der Standardwert *nicht* statt.

Spaltenstandards können serverseitige Funktionen oder konstante Werte sein, die zusammen mit dem Schema in der Datenbank in DDL definiert werden, oder SQL-Ausdrücke, die direkt in ein von SQLAlchemy ausgegebenes INSERT- oder UPDATE-Statement gerendert werden; sie können auch clientseitige Python-Funktionen oder konstante Werte sein, die von SQLAlchemy aufgerufen werden, bevor Daten an die Datenbank übergeben werden.

Hinweis

Ein Spaltendefault-Handler sollte nicht mit einer Konstruktion verwechselt werden, die eingehende Werte für INSERT- und UPDATE-Statements abfängt und modifiziert, die dem Statement bei seinem Aufruf *mitgegeben werden*. Dies wird als Data Marshalling bezeichnet, bei dem ein Spaltenwert von der Anwendung auf irgendeine Weise modifiziert wird, bevor er an die Datenbank gesendet wird. SQLAlchemy bietet hierfür einige Möglichkeiten, darunter die Verwendung von benutzerdefinierten Datentypen, SQL-Ausführungsereignissen und im ORM benutzerdefinierte Validatoren sowie Attributereignissen. Spaltendefaults werden nur aufgerufen, wenn **kein Wert vorhanden** ist für eine Spalte in einem SQL DML-Statement.

SQLAlchemy bietet eine Reihe von Funktionen zur Erzeugung von Standardwerten für nicht vorhandene Werte während INSERT- und UPDATE-Statements. Die Optionen umfassen

• Skalare Werte, die als Standardwerte bei INSERT- und UPDATE-Operationen verwendet werden

• Python-Funktionen, die bei INSERT- und UPDATE-Operationen ausgeführt werden

• SQL-Ausdrücke, die in INSERT-Statements eingebettet sind (oder in einigen Fällen vorher ausgeführt werden)

• SQL-Ausdrücke, die in UPDATE-Statements eingebettet sind

• Serverseitige Standardwerte, die während INSERT verwendet werden

• Marker für serverseitige Trigger, die während UPDATE verwendet werden

Die allgemeine Regel für alle INSERT/UPDATE-Defaults ist, dass sie nur dann wirksam werden, wenn kein Wert für eine bestimmte Spalte als execute()-Parameter übergeben wird; andernfalls wird der angegebene Wert verwendet.

Skalare Standardwerte

Die einfachste Art von Standardwert ist ein skalarer Wert, der als Standardwert einer Spalte verwendet wird

Table("mytable", metadata_obj, Column("somecolumn", Integer, default=12))

Oben wird der Wert „12“ als Spaltenwert während eines INSERTs gebunden, wenn kein anderer Wert angegeben wird.

Ein skalarer Wert kann auch mit einem UPDATE-Statement verknüpft werden, obwohl dies nicht sehr üblich ist (da UPDATE-Statements normalerweise nach dynamischen Standardwerten suchen).

Table("mytable", metadata_obj, Column("somecolumn", Integer, onupdate=25))

Von Python ausgeführte Funktionen

Die Schlüsselwörter Column.default und Column.onupdate akzeptieren auch Python-Funktionen. Diese Funktionen werden zum Zeitpunkt des Einfügens oder Aktualisierens aufgerufen, wenn kein anderer Wert für diese Spalte angegeben wird, und der zurückgegebene Wert wird für den Wert der Spalte verwendet. Das Folgende veranschaulicht eine grobe „Sequenz“, die einem Primärschlüssel eine inkrementierende Zählervariable zuweist

# a function which counts upwards
i = 0


def mydefault():
    global i
    i += 1
    return i


t = Table(
    "mytable",
    metadata_obj,
    Column("id", Integer, primary_key=True, default=mydefault),
)

Es ist zu beachten, dass für echtes „inkrementierendes Sequenz“-Verhalten normalerweise die integrierten Funktionen der Datenbank verwendet werden sollten, die Sequenzobjekte oder andere automatische Inkrementierungsfunktionen umfassen können. Für Primärschlüsselspalten verwendet SQLAlchemy in den meisten Fällen diese Funktionen automatisch. Siehe die API-Dokumentation für Column einschließlich des Flags Column.autoincrement sowie des Abschnitts über Sequence später in diesem Kapitel für Hintergrundinformationen zu Standardtechniken zur Primärschlüsselerzeugung.

Um `onupdate` zu veranschaulichen, weisen wir der Attribut Column.onupdate die Python-Funktion datetime now zu

import datetime

t = Table(
    "mytable",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    # define 'last_updated' to be populated with datetime.now()
    Column("last_updated", DateTime, onupdate=datetime.datetime.now),
)

Wenn ein Update-Statement ausgeführt wird und kein Wert für last_updated übergeben wird, wird die Python-Funktion datetime.datetime.now() ausgeführt und ihr Rückgabewert als Wert für last_updated verwendet. Beachten Sie, dass wir now als die Funktion selbst übergeben, ohne sie aufzurufen (d. h. es gibt keine Klammern danach) – SQLAlchemy wird die Funktion zum Zeitpunkt der Ausführung des Statements ausführen.

Kontextsensitive Standardfunktionen

Die von Column.default und Column.onupdate verwendeten Python-Funktionen können auch den aktuellen Kontext des Statements nutzen, um einen Wert zu bestimmen. Der Kontext eines Statements ist ein internes SQLAlchemy-Objekt, das alle Informationen über das ausgeführte Statement enthält, einschließlich seines Quellausdrucks, der damit verbundenen Parameter und des Cursors. Der typische Anwendungsfall für diesen Kontext im Hinblick auf die Standardgenerierung ist der Zugriff auf die anderen Werte, die in der Zeile eingefügt oder aktualisiert werden. Um auf den Kontext zuzugreifen, stellen Sie eine Funktion bereit, die ein einzelnes context-Argument akzeptiert

def mydefault(context):
    return context.get_current_parameters()["counter"] + 12


t = Table(
    "mytable",
    metadata_obj,
    Column("counter", Integer),
    Column("counter_plus_twelve", Integer, default=mydefault, onupdate=mydefault),
)

Die obige Standardgenerierungsfunktion wird so angewendet, dass sie für alle INSERT- und UPDATE-Statements ausgeführt wird, bei denen kein Wert für die Spalte counter_plus_twelve anderweitig angegeben wurde, und der Wert derjenige ist, der im Ausführungskontext für die Spalte counter vorhanden ist, plus die Zahl 12.

Für ein einzelnes Statement, das im „executemany“-Stil ausgeführt wird, z. B. mit mehreren Parametersätzen, die an Connection.execute() übergeben werden, wird die benutzerdefinierte Funktion einmal für jeden Parametersatz aufgerufen. Für den Anwendungsfall eines mehrwertigen Insert-Konstrukts (z. B. mit mehr als einer per Insert.values() eingerichteten VALUES-Klausel) wird die benutzerdefinierte Funktion ebenfalls einmal für jeden Parametersatz aufgerufen.

Wenn die Funktion aufgerufen wird, ist die spezielle Methode DefaultExecutionContext.get_current_parameters() aus dem Kontextobjekt (einer Unterklasse von DefaultExecutionContext) verfügbar. Diese Methode gibt ein Wörterbuch von Spaltenschlüssel zu Werten zurück, das die vollständige Menge der Werte für das INSERT- oder UPDATE-Statement darstellt. Im Falle eines mehrwertigen INSERT-Konstrukts wird die Teilmenge der Parameter, die der einzelnen VALUES-Klausel entspricht, aus dem vollständigen Parameterwörterbuch isoliert und allein zurückgegeben.

Neu in Version 1.2: Methode DefaultExecutionContext.get_current_parameters() hinzugefügt, die das immer noch vorhandene Attribut DefaultExecutionContext.current_parameters durch das Angebot, mehrere VALUES-Klauseln in einzelne Parameterwörterbücher zu organisieren, verbessert.

Clientseitig aufgerufene SQL-Ausdrücke

Den Schlüsselwörtern Column.default und Column.onupdate können auch SQL-Ausdrücke übergeben werden, die in den meisten Fällen inline innerhalb des INSERT- oder UPDATE-Statements gerendert werden.

t = Table(
    "mytable",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    # define 'create_date' to default to now()
    Column("create_date", DateTime, default=func.now()),
    # define 'key' to pull its default from the 'keyvalues' table
    Column(
        "key",
        String(20),
        default=select(keyvalues.c.key).where(keyvalues.c.type="type1"),
    ),
    # define 'last_modified' to use the current_timestamp SQL function on update
    Column("last_modified", DateTime, onupdate=func.utc_timestamp()),
)

Oben wird die Spalte create_date mit dem Ergebnis der SQL-Funktion now() (die je nach Backend in den meisten Fällen zu NOW() oder CURRENT_TIMESTAMP kompiliert) während eines INSERT-Statements gefüllt, und die Spalte key mit dem Ergebnis einer SELECT-Subabfrage aus einer anderen Tabelle. Die Spalte last_modified wird mit dem Wert der MySQL-SQL-Funktion UTC_TIMESTAMP() gefüllt, wenn für diese Tabelle ein UPDATE-Statement ausgegeben wird.

Hinweis

Bei der Verwendung von SQL-Funktionen mit dem Konstrukt func „rufen“ wir die benannte Funktion auf, z. B. mit Klammern wie in func.now(). Dies unterscheidet sich von der Angabe eines Python-Aufrufs als Standard, wie z. B. datetime.datetime, wo wir die Funktion selbst übergeben, sie aber nicht selbst aufrufen. Im Falle einer SQL-Funktion gibt der Aufruf von func.now() das SQL-Ausdrucksobjekt zurück, das die „NOW“-Funktion in das ausgegebene SQL rendert.

Standard- und Update-SQL-Ausdrücke, die von Column.default und Column.onupdate angegeben werden, werden von SQLAlchemy explizit aufgerufen, wenn ein INSERT- oder UPDATE-Statement stattfindet, typischerweise inline in das DML-Statement gerendert, außer in bestimmten unten aufgeführten Fällen. Dies unterscheidet sich von einem „serverseitigen“ Standardwert, der Teil der Tabellendefinition in DDL ist, z. B. Teil der „CREATE TABLE“-Anweisung, die wahrscheinlich häufiger vorkommen. Serverseitige Standardwerte finden Sie im nächsten Abschnitt Serverseitig aufgerufene DDL-explizite Standardausdrücke.

Wenn ein SQL-Ausdruck, der von Column.default angegeben wird, mit Primärschlüsselspalten verwendet wird, gibt es Fälle, in denen SQLAlchemy die SQL-Funktion zur Standardgenerierung „vorab ausführen“ muss, d. h. sie wird in einer separaten SELECT-Anweisung aufgerufen und der resultierende Wert wird als Parameter an das INSERT übergeben. Dies geschieht nur für Primärschlüsselspalten für ein INSERT-Statement, das aufgefordert wird, diesen Primärschlüsselwert zurückzugeben, wobei RETURNING oder cursor.lastrowid nicht verwendet werden kann. Ein Insert-Konstrukt, das das Flag insert.inline angibt, wird Standardausdrücke immer inline rendern.

Wenn das Statement mit einem einzigen Parametersatz ausgeführt wird (d. h. es ist keine Ausführung im „executemany“-Stil), enthält das zurückgegebene CursorResult eine Sammlung, die über CursorResult.postfetch_cols() zugänglich ist und eine Liste aller Column-Objekte enthält, die einen inline ausgeführten Standardwert hatten. Ebenso sind alle an das Statement gebundenen Parameter, einschließlich aller vorab ausgeführten Python- und SQL-Ausdrücke, in den Sammlungen CursorResult.last_inserted_params() oder CursorResult.last_updated_params() auf CursorResult vorhanden. Die Sammlung CursorResult.inserted_primary_key enthält eine Liste von Primärschlüsselwerten für die eingefügte Zeile (eine Liste, damit einspaltige und mehrspaltige Primärschlüssel im gleichen Format dargestellt werden).

Serverseitig aufgerufene DDL-explizite Standardausdrücke

Eine Variante des SQL-Ausdrucksstandards ist Column.server_default, der in die CREATE TABLE-Anweisung während eines Table.create()-Vorgangs eingefügt wird.

t = Table(
    "test",
    metadata_obj,
    Column("abc", String(20), server_default="abc"),
    Column("created_at", DateTime, server_default=func.sysdate()),
    Column("index_value", Integer, server_default=text("0")),
)

Ein Erstellungsaufruf für die obige Tabelle erzeugt

CREATE TABLE test (
    abc varchar(20) default 'abc',
    created_at datetime default sysdate,
    index_value integer default 0
)

Das obige Beispiel veranschaulicht die beiden typischen Anwendungsfälle für Column.server_default, nämlich die SQL-Funktion (im obigen Beispiel SYSDATE) sowie einen serverseitigen konstanten Wert (im obigen Beispiel die Ganzzahl „0“). Es ist ratsam, den Konstrukt text() für beliebige literale SQL-Werte zu verwenden, anstatt den Rohwert zu übergeben, da SQLAlchemy in der Regel keine Anführungszeichen oder Maskierung für diese Werte durchführt.

Wie clientseitig generierte Ausdrücke kann auch Column.server_default SQL-Ausdrücke im Allgemeinen verarbeiten, es wird jedoch erwartet, dass dies in der Regel einfache Funktionen und Ausdrücke sind und nicht komplexere Fälle wie eingebettete SELECTs.

Markieren von implizit generierten Werten, Zeitstempeln und ausgelösten Spalten

Spalten, die bei INSERT oder UPDATE basierend auf anderen serverseitigen Datenbankmechanismen einen neuen Wert generieren, wie z. B. datenbankspezifische Auto-Generierungsverhalten, wie sie bei TIMESTAMP-Spalten auf einigen Plattformen vorkommen, sowie benutzerdefinierte Trigger, die bei INSERT oder UPDATE ausgelöst werden, um einen neuen Wert zu generieren, können mit FetchedValue als Marker gekennzeichnet werden.

from sqlalchemy.schema import FetchedValue

t = Table(
    "test",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("abc", TIMESTAMP, server_default=FetchedValue()),
    Column("def", String(20), server_onupdate=FetchedValue()),
)

Der FetchedValue-Indikator beeinflusst nicht das gerenderte DDL für die CREATE TABLE-Anweisung. Stattdessen markiert er die Spalte als eine, die während der Ausführung eines INSERT- oder UPDATE-Statements einen neuen Wert von der Datenbank erhält, und kann für unterstützte Datenbanken verwendet werden, um anzugeben, dass die Spalte Teil einer RETURNING- oder OUTPUT-Klausel für die Anweisung sein sollte. Tools wie das SQLAlchemy ORM nutzen diesen Marker, um zu wissen, wie sie nach einer solchen Operation auf den Wert der Spalte zugreifen können. Insbesondere die Methode ValuesBase.return_defaults() kann mit einem Insert- oder Update-Konstrukt verwendet werden, um anzuzeigen, dass diese Werte zurückgegeben werden sollen.

Details zur Verwendung von FetchedValue mit dem ORM finden Sie unter Abrufen serverseitig generierter Standardwerte.

Warnung

Die Direktive Column.server_onupdate erzeugt **derzeit nicht** die MySQL-Klausel „ON UPDATE CURRENT_TIMESTAMP()“. Siehe Rendern von ON UPDATE CURRENT TIMESTAMP für MySQL / MariaDBs explicit_defaults_for_timestamp für Hintergrundinformationen, wie diese Klausel erstellt wird.

Siehe auch

Abrufen von serverseitigen Standardwerten

Definieren von Sequenzen

SQLAlchemy stellt Datenbanksequenzen über das Sequence-Objekt dar, das als Sonderfall eines „Spaltendefaults“ gilt. Es hat nur Auswirkungen auf Datenbanken, die explizite Unterstützung für Sequenzen haben, was unter den von SQLAlchemy mitgelieferten Dialekten PostgreSQL, Oracle Database, MS SQL Server und MariaDB einschließt. Das Sequence-Objekt wird andernfalls ignoriert.

Tipp

In neueren Datenbank-Engines sollte für die Generierung von ganzzahligen Primärschlüsselwerten wahrscheinlich die Konstruktion Identity anstelle von Sequence bevorzugt werden. Siehe den Abschnitt Identitätsspalten (GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY) für Hintergrundinformationen zu dieser Konstruktion.

Die Sequence kann als „Default“-Generator auf jeder Spalte für INSERT-Operationen platziert werden und kann auch so konfiguriert werden, dass sie bei Bedarf während UPDATE-Operationen ausgelöst wird. Sie wird am häufigsten in Verbindung mit einer einzelnen ganzzahligen Primärschlüsselspalte verwendet.

table = Table(
    "cartitems",
    metadata_obj,
    Column(
        "cart_id",
        Integer,
        Sequence("cart_id_seq", start=1),
        primary_key=True,
    ),
    Column("description", String(40)),
    Column("createdate", DateTime()),
)

Wo oben, ist die Tabelle cartitems mit einer Sequenz namens cart_id_seq verknüpft. Das Ausgeben von MetaData.create_all() für die obige Tabelle beinhaltet

CREATE SEQUENCE cart_id_seq START WITH 1

CREATE TABLE cartitems (
  cart_id INTEGER NOT NULL,
  description VARCHAR(40),
  createdate TIMESTAMP WITHOUT TIME ZONE,
  PRIMARY KEY (cart_id)
)

Tipp

Bei Verwendung von Tabellen mit expliziten Schemanamen (detailliert unter Festlegen des Schemanamens) wird das konfigurierte Schema der Table von einer eingebetteten Sequence **nicht** automatisch übernommen; stattdessen geben Sie Sequence.schema an.

Sequence("cart_id_seq", start=1, schema="some_schema")

Die Sequence kann auch automatisch die MetaData.schema-Einstellung der verwendeten MetaData nutzen; siehe Abschnitt Verknüpfen einer Sequenz mit den MetaData für Hintergrundinformationen.

Wenn Insert DML-Konstrukte gegen die Tabelle cartitems aufgerufen werden, ohne dass ein expliziter Wert für die Spalte cart_id übergeben wird, wird die Sequenz cart_id_seq verwendet, um auf unterstützten Backends einen Wert zu generieren. Typischerweise wird die Sequenzfunktion in das INSERT-Statement eingebettet, das mit RETURNING kombiniert wird, so dass der neu generierte Wert an den Python-Prozess zurückgegeben werden kann.

INSERT INTO cartitems (cart_id, description, createdate)
VALUES (next_val(cart_id_seq), 'some description', '2015-10-15 12:00:15')
RETURNING cart_id

Wenn Connection.execute() verwendet wird, um ein Insert-Konstrukt aufzurufen, sind neu generierte Primärschlüssel-Identifikatoren, einschließlich, aber nicht beschränkt auf die mit Sequence generierten, über die CursorResult-Konstruktion über das Attribut CursorResult.inserted_primary_key verfügbar.

Wenn die Sequence als **Python-seitiger** Standardgenerator mit einer Column verknüpft ist, unterliegt die Sequence auch „CREATE SEQUENCE“- und „DROP SEQUENCE“-DDL, wenn ähnliche DDL für die besitzende Table ausgegeben wird, z. B. bei Verwendung von MetaData.create_all() zur Generierung von DDL für eine Reihe von Tabellen.

Die Sequence kann auch direkt mit einem MetaData-Konstrukt verknüpft werden. Dies ermöglicht die gleichzeitige Verwendung der Sequence in mehr als einer Table und ermöglicht es auch, dass der Parameter MetaData.schema vererbt wird. Siehe Abschnitt Verknüpfen einer Sequenz mit den MetaData für Hintergrundinformationen.

Verknüpfen einer Sequenz mit einer SERIAL-Spalte

PostgreSQLs SERIAL-Datentyp ist ein automatisch inkrementierender Typ, der die implizite Erstellung einer PostgreSQL-Sequenz bei der Ausgabe von CREATE TABLE impliziert. Die Sequence-Konstruktion kann, wenn sie für eine Column angegeben wird, angeben, dass sie in diesem speziellen Fall nicht verwendet werden soll, indem für den Parameter Sequence.optional der Wert True angegeben wird. Dies ermöglicht, dass die gegebene Sequence für Backends verwendet wird, die kein alternatives Primärschlüsselerzeugungssystem haben, sie aber für Backends wie PostgreSQL ignoriert, die automatisch eine Sequenz für eine bestimmte Spalte generieren.

table = Table(
    "cartitems",
    metadata_obj,
    Column(
        "cart_id",
        Integer,
        # use an explicit Sequence where available, but not on
        # PostgreSQL where SERIAL will be used
        Sequence("cart_id_seq", start=1, optional=True),
        primary_key=True,
    ),
    Column("description", String(40)),
    Column("createdate", DateTime()),
)

Im obigen Beispiel verwendet CREATE TABLE für PostgreSQL den Datentyp SERIAL für die Spalte cart_id, und die Sequenz cart_id_seq wird ignoriert. Auf Oracle Database wird die Sequenz cart_id_seq jedoch explizit erstellt.

Tipp

Diese spezifische Interaktion von SERIAL und SEQUENCE ist ziemlich veraltet, und wie in anderen Fällen vereinfacht die Verwendung von Identity stattdessen den Vorgang, auf allen unterstützten Backends einfach IDENTITY zu verwenden.

Ausführen einer Sequenz eigenständig

Eine SEQUENZ ist ein First-Class-Schemaobjekt in SQL und kann verwendet werden, um Werte unabhängig in der Datenbank zu generieren. Wenn Sie ein Sequence-Objekt haben, kann es mit seinem „nächster Wert“-Befehl aufgerufen werden, indem es direkt an eine SQL-Ausführungsmethode übergeben wird.

with my_engine.connect() as conn:
    seq = Sequence("some_sequence", start=1)
    nextid = conn.execute(seq)

Um die „next value“-Funktion einer Sequence in eine SQL-Anweisung wie SELECT oder INSERT einzubetten, verwenden Sie die Methode Sequence.next_value(), die zur Kompilierungszeit der Anweisung eine für das Ziel-Backend geeignete SQL-Funktion rendert.

>>> my_seq = Sequence("some_sequence", start=1)
>>> stmt = select(my_seq.next_value())
>>> print(stmt.compile(dialect=postgresql.dialect()))
SELECT nextval('some_sequence') AS next_value_1

Verknüpfen einer Sequenz mit den MetaData

Für eine Sequence, die mit beliebigen Table-Objekten verknüpft werden soll, kann die Sequence mit einer bestimmten MetaData verknüpft werden, indem der Parameter Sequence.metadata verwendet wird.

seq = Sequence("my_general_seq", metadata=metadata_obj, start=1)

Eine solche Sequenz kann dann wie gewohnt mit Spalten verknüpft werden.

table = Table(
    "cartitems",
    metadata_obj,
    seq,
    Column("description", String(40)),
    Column("createdate", DateTime()),
)

Im obigen Beispiel wird das Sequence-Objekt als unabhängiges Schema-Konstrukt behandelt, das eigenständig existieren oder von mehreren Tabellen gemeinsam genutzt werden kann.

Die explizite Verknüpfung der Sequence mit MetaData ermöglicht die folgenden Verhaltensweisen:

• Die Sequence erbt den für die Ziel-MetaData angegebenen Parameter MetaData.schema, was die Erzeugung von CREATE / DROP DDL sowie die Wiedergabe der Funktion Sequence.next_value() in SQL-Anweisungen beeinflusst.

• Die Methoden MetaData.create_all() und MetaData.drop_all() geben CREATE / DROP für diese Sequence aus, auch wenn die Sequence nicht mit einer Table / Column verknüpft ist, die Mitglied dieser MetaData ist.

Verknüpfen einer Sequenz als Server-seitiger Standardwert

Hinweis

Die folgende Technik funktioniert bekanntermaßen nur mit der PostgreSQL-Datenbank. Sie funktioniert nicht mit Oracle Database.

Die vorherigen Abschnitte zeigen, wie eine Sequence mit einer Column als **Python-seitiger Standardwertgenerator** verknüpft wird.

Column(
    "cart_id",
    Integer,
    Sequence("cart_id_seq", metadata=metadata_obj, start=1),
    primary_key=True,
)

In diesem Fall unterliegt die Sequence automatisch dem CREATE SEQUENCE / DROP SEQUENCE DDL, wenn die zugehörige Table CREATE / DROP unterliegt. Die Sequenz ist jedoch **nicht** als server-seitiger Standardwert für die Spalte vorhanden, wenn CREATE TABLE ausgegeben wird.

Wenn wir möchten, dass die Sequenz als server-seitiger Standardwert verwendet wird, d. h. sie auch dann greift, wenn wir INSERT-Befehle von der SQL-Kommandozeile an die Tabelle senden, können wir den Parameter Column.server_default in Verbindung mit der Wertgenerierungsfunktion der Sequenz, verfügbar über die Methode Sequence.next_value(), verwenden. Unten illustrieren wir dieselbe Sequence, die sowohl als Python-seitiger Standardwertgenerator als auch als server-seitiger Standardwertgenerator mit der Column verknüpft ist.

cart_id_seq = Sequence("cart_id_seq", metadata=metadata_obj, start=1)
table = Table(
    "cartitems",
    metadata_obj,
    Column(
        "cart_id",
        Integer,
        cart_id_seq,
        server_default=cart_id_seq.next_value(),
        primary_key=True,
    ),
    Column("description", String(40)),
    Column("createdate", DateTime()),
)

oder mit der ORM

class CartItem(Base):
    __tablename__ = "cartitems"

    cart_id_seq = Sequence("cart_id_seq", metadata=Base.metadata, start=1)
    cart_id = Column(
        Integer, cart_id_seq, server_default=cart_id_seq.next_value(), primary_key=True
    )
    description = Column(String(40))
    createdate = Column(DateTime)

Wenn die Anweisung "CREATE TABLE" ausgegeben wird, sieht sie unter PostgreSQL so aus:

CREATE TABLE cartitems (
    cart_id INTEGER DEFAULT nextval('cart_id_seq') NOT NULL,
    description VARCHAR(40),
    createdate TIMESTAMP WITHOUT TIME ZONE,
    PRIMARY KEY (cart_id)
)

Die Platzierung der Sequence sowohl im Python-seitigen als auch im Server-seitigen Standardwertkontext stellt sicher, dass die "Primary Key Fetch"-Logik in allen Fällen funktioniert. Typischerweise unterstützen sequenzaktivierte Datenbanken auch RETURNING für INSERT-Anweisungen, was von SQLAlchemy automatisch verwendet wird, wenn diese Anweisung ausgegeben wird. Wenn RETURNING jedoch für einen bestimmten INSERT nicht verwendet wird, würde SQLAlchemy "pre-execute" der Sequenz außerhalb der INSERT-Anweisung selbst bevorzugen, was nur funktioniert, wenn die Sequenz als Python-seitiger Standardwertfunktionsgenerator enthalten ist.

Das Beispiel verknüpft die Sequence auch direkt mit der umschließenden MetaData, was wiederum sicherstellt, dass die Sequence vollständig mit den Parametern der MetaData-Sammlung verknüpft ist, einschließlich des Standard-Schemas, falls vorhanden.

Siehe auch

Sequenzen/SERIAL/IDENTITY – in der Dokumentation des PostgreSQL-Dialekts.

RETURNING-Unterstützung – in der Dokumentation des Oracle Database-Dialekts.

Berechnete Spalten (GENERATED ALWAYS AS)

Neu ab Version 1.3.11.

Das Konstrukt Computed ermöglicht es, eine Column in DDL als "GENERATED ALWAYS AS"-Spalte zu deklarieren, d. h. eine Spalte, deren Wert vom Datenbankserver berechnet wird. Das Konstrukt akzeptiert einen SQL-Ausdruck, der typischerweise textuell mithilfe eines Strings oder des text()-Konstrukts deklariert wird, ähnlich wie bei CheckConstraint. Der SQL-Ausdruck wird dann vom Datenbankserver interpretiert, um den Wert für die Spalte innerhalb einer Zeile zu bestimmen.

Beispiel

from sqlalchemy import Table, Column, MetaData, Integer, Computed

metadata_obj = MetaData()

square = Table(
    "square",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("side", Integer),
    Column("area", Integer, Computed("side * side")),
    Column("perimeter", Integer, Computed("4 * side")),
)

Das DDL für die Tabelle square, wenn es auf einem PostgreSQL 12 Backend ausgeführt wird, sieht folgendermaßen aus:

CREATE TABLE square (
    id SERIAL NOT NULL,
    side INTEGER,
    area INTEGER GENERATED ALWAYS AS (side * side) STORED,
    perimeter INTEGER GENERATED ALWAYS AS (4 * side) STORED,
    PRIMARY KEY (id)
)

Ob der Wert bei INSERT und UPDATE persistent gespeichert wird oder ob er beim Abrufen berechnet wird, ist ein Implementierungsdetail der Datenbank; erstere wird als "stored" und letztere als "virtual" bezeichnet. Einige Datenbankimplementierungen unterstützen beides, andere nur eines von beiden. Das optionale Flag Computed.persisted kann als True oder False angegeben werden, um anzuzeigen, ob das Schlüsselwort "STORED" oder "VIRTUAL" im DDL gerendert werden soll. Dies führt jedoch zu einem Fehler, wenn das Schlüsselwort vom Zielbackend nicht unterstützt wird. Das Weglassen führt zu einem funktionierenden Standardwert für das Zielbackend.

Das Konstrukt Computed ist eine Unterklasse des FetchedValue-Objekts und konfiguriert sich selbst als "server default" und "server onupdate" Generator für die Ziel-Column. Das bedeutet, dass es als Standardwert-generierende Spalte behandelt wird, wenn INSERT- und UPDATE-Anweisungen generiert werden, und dass es als generierende Spalte abgerufen wird, wenn die ORM verwendet wird. Dies schließt ein, dass es Teil der RETURNING-Klausel der Datenbank ist, für Datenbanken, die RETURNING unterstützen und die generierten Werte eifrig abgerufen werden sollen.

Hinweis

Eine Column, die mit dem Konstrukt Computed definiert ist, darf keinen anderen Wert speichern als den, den der Server ihr zuweist. Das Verhalten von SQLAlchemy, wenn ein Wert für eine solche Spalte für das Schreiben in INSERT- oder UPDATE-Anweisungen übergeben wird, ist derzeit, dass der Wert ignoriert wird.

"GENERATED ALWAYS AS" wird derzeit unterstützt von

• MySQL ab Version 5.7

• MariaDB ab der Serie 10.x

• PostgreSQL ab Version 12

• Oracle Database – mit der Einschränkung, dass RETURNING bei UPDATE nicht korrekt funktioniert (eine entsprechende Warnung wird ausgegeben, wenn das UPDATE..RETURNING mit einer berechneten Spalte gerendert wird).

• Microsoft SQL Server

• SQLite ab Version 3.31

Wenn Computed mit einem nicht unterstützten Backend verwendet wird, wird ein CompileError ausgelöst, wenn versucht wird, das Konstrukt zu rendern. Andernfalls, wenn der Dialekt es unterstützt, die verwendete Datenbankserverversion jedoch nicht, wird eine Unterklasse von DBAPIError, normalerweise OperationalError, ausgelöst, wenn das DDL an die Datenbank ausgegeben wird.

Siehe auch

Computed

Identitätsspalten (GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY)

Neu in Version 1.4.

Das Konstrukt Identity ermöglicht es, eine Column als Identitätsspalte zu deklarieren und im DDL als "GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY" zu rendern. Eine Identitätsspalte erhält ihren Wert automatisch von der Datenbank, indem sie eine inkrementierende (oder dekrementierende) Sequenz verwendet. Das Konstrukt teilt die meisten seiner Optionen zur Steuerung des Datenbankverhaltens mit Sequence.

Beispiel

from sqlalchemy import Table, Column, MetaData, Integer, Identity, String

metadata_obj = MetaData()

data = Table(
    "data",
    metadata_obj,
    Column("id", Integer, Identity(start=42, cycle=True), primary_key=True),
    Column("data", String),
)

Das DDL für die Tabelle data, wenn es auf einem PostgreSQL 12 Backend ausgeführt wird, sieht folgendermaßen aus:

CREATE TABLE data (
    id INTEGER GENERATED BY DEFAULT AS IDENTITY (START WITH 42 CYCLE) NOT NULL,
    data VARCHAR,
    PRIMARY KEY (id)
)

Die Datenbank generiert einen Wert für die Spalte id bei einem INSERT, beginnend mit 42, falls die Anweisung nicht bereits einen Wert für die Spalte id enthielt. Eine Identitätsspalte kann auch verlangen, dass die Datenbank den Wert der Spalte generiert und den Wert, der mit der Anweisung übergeben wurde, ignoriert oder je nach Backend einen Fehler auslöst. Um diesen Modus zu aktivieren, setzen Sie den Parameter Identity.always im Konstrukt Identity auf True. Das Aktualisieren des vorherigen Beispiels, um diesen Parameter einzuschließen, generiert das folgende DDL:

CREATE TABLE data (
    id INTEGER GENERATED ALWAYS AS IDENTITY (START WITH 42 CYCLE) NOT NULL,
    data VARCHAR,
    PRIMARY KEY (id)
)

Das Konstrukt Identity ist eine Unterklasse des FetchedValue-Objekts und konfiguriert sich selbst als "server default" Generator für die Ziel-Column. Das bedeutet, dass es als Standardwert-generierende Spalte behandelt wird, wenn INSERT-Anweisungen generiert werden, und dass es als generierende Spalte abgerufen wird, wenn die ORM verwendet wird. Dies schließt ein, dass es Teil der RETURNING-Klausel der Datenbank ist, für Datenbanken, die RETURNING unterstützen und die generierten Werte eifrig abgerufen werden sollen.

Das Konstrukt Identity wird derzeit unterstützt von:

• PostgreSQL ab Version 10.

• Oracle Database ab Version 12. Es unterstützt auch die Übergabe von always=None, um den Standard-Generierungsmodus zu aktivieren, und den Parameter on_null=True, um "ON NULL" in Verbindung mit einer "BY DEFAULT" Identitätsspalte anzugeben.

• Microsoft SQL Server. MSSQL verwendet eine benutzerdefinierte Syntax, die nur die Parameter start und increment unterstützt und alle anderen ignoriert.

Wenn Identity mit einem nicht unterstützten Backend verwendet wird, wird es ignoriert, und die Standardlogik von SQLAlchemy für Autoincrement-Spalten wird verwendet.

Ein Fehler wird ausgelöst, wenn eine Column sowohl eine Identity angibt als auch Column.autoincrement auf False setzt.

Siehe auch

Identity

Default Objects API

Objektname	Beschreibung
ColumnDefault	Ein einfacher Standardwert für eine Spalte.
Computed	Definiert eine generierte Spalte, d. h. die Syntax "GENERATED ALWAYS AS".
DefaultClause	Ein DDL-spezifizierter DEFAULT-Spaltenwert.
DefaultGenerator	Basisklasse für Spalten-Standardwerte.
FetchedValue	Ein Marker für einen transparenten, datenbankseitigen Standardwert.
Identity	Definiert eine Identitätsspalte, d. h. die Syntax "GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY".
Sequence	Stellt eine benannte Datenbanksequenz dar.

class sqlalchemy.schema.Computed

Definiert eine generierte Spalte, d. h. die Syntax "GENERATED ALWAYS AS".

Das Konstrukt Computed ist ein Inline-Konstrukt, das der Argumentliste eines Column-Objekts hinzugefügt wird.

from sqlalchemy import Computed

Table(
    "square",
    metadata_obj,
    Column("side", Float, nullable=False),
    Column("area", Float, Computed("side * side")),
)

Vollständige Details finden Sie in der verknüpften Dokumentation unten.

Neu ab Version 1.3.11.

Siehe auch

Berechnete Spalten (GENERATED ALWAYS AS)

Mitglieder

__init__(), copy()

Klassensignatur

class sqlalchemy.schema.Computed (sqlalchemy.schema.FetchedValue, sqlalchemy.schema.SchemaItem)

method sqlalchemy.schema.Computed.__init__(sqltext: _DDLColumnArgument, persisted: bool | None = None) → None

Konstruiert eine GENERATED ALWAYS AS DDL-Konstruktion, die eine Column begleitet.

Parameter:

• sqltext –

  Ein String, der den Spaltengenerierungsausdruck enthält und unverändert verwendet wird, oder ein SQL-Ausdruckskonstrukt wie ein text()-Objekt. Wenn als String übergeben, wird das Objekt in ein text()-Objekt konvertiert.

  Warnung

  Das Argument Computed.sqltext für Computed kann als Python-String-Argument übergeben werden, das als **vertrauenswürdiger SQL-Text** behandelt und wie angegeben gerendert wird. **ÜBERGEBEN SIE KEINE NICHT VERTRAUENSWÜRDIGE EINGABE AN DIESEN PARAMETER**.

• persisted –

  Optional, steuert, wie diese Spalte von der Datenbank persistent gespeichert werden soll. Mögliche Werte sind:

  • None, der Standardwert, verwendet die vom Datenbankstandard definierte Persistenz.

  • True rendert GENERATED ALWAYS AS ... STORED oder das Äquivalent für die Ziel-Datenbank, falls unterstützt.

  • False rendert GENERATED ALWAYS AS ... VIRTUAL oder das Äquivalent für die Ziel-Datenbank, falls unterstützt.

  Die Angabe von True oder False kann beim Ausgeben des DDL an die Zieldatenbank einen Fehler verursachen, wenn die Datenbank diese Persistenzoption nicht unterstützt. Das Belassen dieses Parameters bei seinem Standardwert None garantiert den Erfolg für alle Datenbanken, die GENERATED ALWAYS AS unterstützen.

method sqlalchemy.schema.Computed.copy(*, target_table: Table | None = None, **kw: Any) → Computed

Veraltet seit Version 1.4: Die Methode Computed.copy() ist veraltet und wird in einer zukünftigen Version entfernt.

class sqlalchemy.schema.ColumnDefault

Ein einfacher Standardwert für eine Spalte.

Dies kann einem konstanten Wert, einer aufrufbaren Funktion oder einer SQL-Klausel entsprechen.

ColumnDefault wird automatisch generiert, wenn die Argumente default, onupdate von Column verwendet werden. Eine ColumnDefault kann auch positionell übergeben werden.

Zum Beispiel, das Folgende

Column("foo", Integer, default=50)

Ist äquivalent zu

Column("foo", Integer, ColumnDefault(50))

Klassensignatur

class sqlalchemy.schema.ColumnDefault (sqlalchemy.schema.DefaultGenerator, abc.ABC)

class sqlalchemy.schema.DefaultClause

Ein DDL-spezifizierter DEFAULT-Spaltenwert.

DefaultClause ist ein FetchedValue, der beim Ausgeben von "CREATE TABLE" auch eine "DEFAULT"-Klausel generiert.

DefaultClause wird automatisch generiert, wenn die Argumente server_default, server_onupdate von Column verwendet werden. Eine DefaultClause kann auch positionell übergeben werden.

Zum Beispiel, das Folgende

Column("foo", Integer, server_default="50")

Ist äquivalent zu

Column("foo", Integer, DefaultClause("50"))

Klassensignatur

class sqlalchemy.schema.DefaultClause (sqlalchemy.schema.FetchedValue)

class sqlalchemy.schema.DefaultGenerator

Basisklasse für Spalten-Standardwerte.

Dieses Objekt ist nur auf column.default oder column.onupdate vorhanden. Es ist nicht gültig als Server-Standardwert.

Klassensignatur

class sqlalchemy.schema.DefaultGenerator (sqlalchemy.sql.expression.Executable, sqlalchemy.schema.SchemaItem)

class sqlalchemy.schema.FetchedValue

Ein Marker für einen transparenten, datenbankseitigen Standardwert.

Verwenden Sie FetchedValue, wenn die Datenbank so konfiguriert ist, dass sie einen automatischen Standardwert für eine Spalte bereitstellt.

Z. B.

Column("foo", Integer, FetchedValue())

Würde darauf hindeuten, dass ein Trigger oder ein Standardgenerator während eines INSERT einen neuen Wert für die Spalte foo erstellt.

Siehe auch

Markieren von implizit generierten Werten, Zeitstempeln und getriggerten Spalten

Klassensignatur

class sqlalchemy.schema.FetchedValue (sqlalchemy.sql.expression.SchemaEventTarget)

class sqlalchemy.schema.Sequence

Stellt eine benannte Datenbanksequenz dar.

Das Sequence-Objekt repräsentiert den Namen und die Konfigurationsparameter einer Datenbanksequenz. Es repräsentiert auch ein Konstrukt, das von einer SQLAlchemy Engine oder Connection „ausgeführt“ werden kann, um die entsprechende Funktion „nächster Wert“ für die Ziel-Datenbank zu rendern und ein Ergebnis zurückzugeben.

Die Sequence wird typischerweise mit einer Primärschlüsselspalte assoziiert.

some_table = Table(
    "some_table",
    metadata,
    Column(
        "id",
        Integer,
        Sequence("some_table_seq", start=1),
        primary_key=True,
    ),
)

Wenn CREATE TABLE für die obige Table emittiert wird, wird, wenn die Zielplattform Sequenzen unterstützt, auch eine CREATE SEQUENCE-Anweisung emittiert. Für Plattformen, die keine Sequenzen unterstützen, wird das Sequence-Konstrukt ignoriert.

Siehe auch

Sequenzen definieren

CreateSequence

DropSequence

Mitglieder

__init__(), create(), drop(), next_value()

Klassensignatur

class sqlalchemy.schema.Sequence (sqlalchemy.schema.HasSchemaAttr, sqlalchemy.schema.IdentityOptions, sqlalchemy.schema.DefaultGenerator)

method sqlalchemy.schema.Sequence.__init__(name: str, start: int | None = None, increment: int | None = None, minvalue: int | None = None, maxvalue: int | None = None, nominvalue: bool | None = None, nomaxvalue: bool | None = None, cycle: bool | None = None, schema: str | Literal[SchemaConst.BLANK_SCHEMA] | None = None, cache: int | None = None, order: bool | None = None, data_type: _TypeEngineArgument[int] | None = None, optional: bool = False, quote: bool | None = None, metadata: MetaData | None = None, quote_schema: bool | None = None, for_update: bool = False) → None

Konstruiert ein Sequence-Objekt.

Parameter:

• name – der Name der Sequenz.

• start –

  der Startindex der Sequenz. Dieser Wert wird verwendet, wenn der CREATE SEQUENCE-Befehl an die Datenbank als Wert der Klausel „START WITH“ emittiert wird. Wenn None, wird die Klausel weggelassen, was auf den meisten Plattformen einen Startwert von 1 bedeutet.

  Geändert in Version 2.0: Der Parameter Sequence.start ist erforderlich, damit DDL „START WITH“ emittiert. Dies ist eine Umkehrung einer Änderung in Version 1.4, die implizit „START WITH 1“ gerendert hätte, wenn Sequence.start nicht enthalten war. Siehe Das Sequence-Konstrukt kehrt zur keinen expliziten Standard-„start“-Wert zurück; beeinflusst MS SQL Server für weitere Details.

• increment – der Inkrementwert der Sequenz. Dieser Wert wird verwendet, wenn der CREATE SEQUENCE-Befehl an die Datenbank als Wert der Klausel „INCREMENT BY“ emittiert wird. Wenn None, wird die Klausel weggelassen, was auf den meisten Plattformen eine Inkrementierung von 1 bedeutet.

• minvalue – der Minimalwert der Sequenz. Dieser Wert wird verwendet, wenn der CREATE SEQUENCE-Befehl an die Datenbank als Wert der Klausel „MINVALUE“ emittiert wird. Wenn None, wird die Klausel weggelassen, was auf den meisten Plattformen einen Minvalue von 1 und -2^63-1 für aufsteigende und absteigende Sequenzen bedeutet.

• maxvalue – der Maximalwert der Sequenz. Dieser Wert wird verwendet, wenn der CREATE SEQUENCE-Befehl an die Datenbank als Wert der Klausel „MAXVALUE“ emittiert wird. Wenn None, wird die Klausel weggelassen, was auf den meisten Plattformen einen Maxvalue von 2^63-1 und -1 für aufsteigende und absteigende Sequenzen bedeutet.

• nominvalue – kein Minimalwert der Sequenz. Dieser Wert wird verwendet, wenn der CREATE SEQUENCE-Befehl an die Datenbank als Wert der Klausel „NO MINVALUE“ emittiert wird. Wenn None, wird die Klausel weggelassen, was auf den meisten Plattformen einen Minvalue von 1 und -2^63-1 für aufsteigende und absteigende Sequenzen bedeutet.

• nomaxvalue – kein Maximalwert der Sequenz. Dieser Wert wird verwendet, wenn der CREATE SEQUENCE-Befehl an die Datenbank als Wert der Klausel „NO MAXVALUE“ emittiert wird. Wenn None, wird die Klausel weggelassen, was auf den meisten Plattformen einen Maxvalue von 2^63-1 und -1 für aufsteigende und absteigende Sequenzen bedeutet.

• cycle – erlaubt der Sequenz, zurückzuspringen, wenn der Maxvalue oder Minvalue von einer aufsteigenden bzw. absteigenden Sequenz erreicht wurde. Dieser Wert wird verwendet, wenn der CREATE SEQUENCE-Befehl an die Datenbank als Klausel „CYCLE“ emittiert wird. Wenn das Limit erreicht ist, ist die nächste generierte Zahl die minvalue oder maxvalue. Wenn cycle=False (Standard) geben alle Aufrufe von nextval nach Erreichen des Maximalwerts der Sequenz einen Fehler zurück.

• schema – optionaler Schemaname für die Sequenz, wenn sie sich in einem anderen Schema als dem Standard befindet. Die Regeln für die Auswahl des Schemanamens, wenn eine MetaData ebenfalls vorhanden ist, sind dieselben wie bei Table.schema.

• cache – optionaler ganzzahliger Wert; Anzahl der zukünftigen Werte in der Sequenz, die im Voraus berechnet werden. Rendert das CACHE-Schlüsselwort, das von Oracle Database und PostgreSQL verstanden wird.

• order – optionaler boolescher Wert; wenn True, rendert das ORDER-Schlüsselwort, das von Oracle Database verstanden wird und angibt, dass die Sequenz eindeutig geordnet ist. Kann notwendig sein, um eine deterministische Reihenfolge mit Oracle RAC bereitzustellen.

• data_type –

  Der Typ, der von der Sequenz zurückgegeben werden soll, für Dialekte, die es uns erlauben, zwischen INTEGER, BIGINT usw. zu wählen (z. B. mssql).

  Neu in Version 1.4.0.

• optional – boolescher Wert, wenn True, gibt an, dass dieses Sequence-Objekt nur auf Backends, die keine andere Möglichkeit zur Generierung von Primärschlüsselidentifikatoren bieten, explizit generiert werden muss. Derzeit bedeutet dies im Wesentlichen: „Erstellen Sie diese Sequenz nicht auf dem PostgreSQL-Backend, wo das SERIAL-Schlüsselwort automatisch eine Sequenz für uns erstellt.“

• quote – boolescher Wert, wenn True oder False, erzwingt explizit das Zitieren des Sequence.name ein- oder auszuschalten. Wenn es beim Standardwert None belassen wird, finden normale Zitationsregeln basierend auf Groß-/Kleinschreibung und reservierten Wörtern statt.

• quote_schema – Legt die Zitationspräferenzen für den Namen des schema fest.

• metadata –

  optionales MetaData-Objekt, mit dem diese Sequence assoziiert wird. Eine Sequence, die mit einer MetaData assoziiert ist, erhält folgende Fähigkeiten:

  • Die Sequence erbt den Parameter MetaData.schema, der für die Ziel-MetaData angegeben wurde, was die Erstellung von CREATE/DROP DDL beeinflusst, falls vorhanden.

  • Die Methoden Sequence.create() und Sequence.drop() verwenden automatisch die Engine, die an das MetaData-Objekt gebunden ist, falls vorhanden.

  • Die Methoden MetaData.create_all() und MetaData.drop_all() geben CREATE / DROP für diese Sequence aus, auch wenn die Sequence nicht mit einer Table / Column verknüpft ist, die Mitglied dieser MetaData ist.

  Die obigen Verhaltensweisen können nur auftreten, wenn die Sequence explizit über diesen Parameter mit der MetaData assoziiert wird.

  Siehe auch

  Assoziieren einer Sequenz mit der MetaData - vollständige Erörterung des Parameters Sequence.metadata.

• for_update – Gibt an, dass diese Sequence, wenn sie mit einer Column assoziiert ist, für UPDATE-Anweisungen dieser Spalte aufgerufen werden soll, anstatt für INSERT-Anweisungen, wenn für diese Spalte in der Anweisung kein Wert vorhanden ist.

method sqlalchemy.schema.Sequence.create(bind: _CreateDropBind, checkfirst: bool = True) → None

Erstellt diese Sequenz in der Datenbank.

method sqlalchemy.schema.Sequence.drop(bind: _CreateDropBind, checkfirst: bool = True) → None

Löscht diese Sequenz aus der Datenbank.

method sqlalchemy.schema.Sequence.next_value() → Function[int]

Gibt ein next_value-Funktionselement zurück, das die entsprechende Inkrementierungsfunktion für diese Sequence innerhalb jedes SQL-Ausdrucks rendert.

class sqlalchemy.schema.Identity

Definiert eine Identitätsspalte, d. h. die Syntax "GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY".

Das Identity-Konstrukt ist ein Inline-Konstrukt, das der Argumentliste eines Column-Objekts hinzugefügt wird.

from sqlalchemy import Identity

Table(
    "foo",
    metadata_obj,
    Column("id", Integer, Identity()),
    Column("description", Text),
)

Vollständige Details finden Sie in der verknüpften Dokumentation unten.

Neu in Version 1.4.

Siehe auch

Identitätsspalten (GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY)

Mitglieder

__init__(), copy()

Klassensignatur

class sqlalchemy.schema.Identity (sqlalchemy.schema.IdentityOptions, sqlalchemy.schema.FetchedValue, sqlalchemy.schema.SchemaItem)

method sqlalchemy.schema.Identity.__init__(always: bool = False, on_null: bool | None = None, start: int | None = None, increment: int | None = None, minvalue: int | None = None, maxvalue: int | None = None, nominvalue: bool | None = None, nomaxvalue: bool | None = None, cycle: bool | None = None, cache: int | None = None, order: bool | None = None) → None

Konstruiert ein GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY DDL-Konstrukt, das eine Column begleitet.

Siehe die Dokumentation zu Sequence für eine vollständige Beschreibung der meisten Parameter.

Hinweis

MSSQL unterstützt diese Konstruktion als bevorzugte Alternative zur Generierung eines IDENTITY für eine Spalte, verwendet jedoch eine nicht standardmäßige Syntax, die nur Identity.start und Identity.increment unterstützt. Alle anderen Parameter werden ignoriert.

Parameter:

• always – Ein Boolean, der den Typ der Identitätsspalte angibt. Wenn False angegeben wird, dem Standardwert, dann hat der vom Benutzer angegebene Wert Vorrang. Wenn True angegeben wird, wird ein vom Benutzer angegebener Wert nicht akzeptiert (auf einigen Backends, wie PostgreSQL, OVERRIDING SYSTEM VALUE oder ähnliches, kann in einem INSERT angegeben werden, um den Sequenzwert zu überschreiben). Einige Backends haben auch einen Standardwert für diesen Parameter, None kann verwendet werden, um das Rendern dieses Teils in DDL wegzulassen. Er wird als False behandelt, wenn ein Backend keinen Standardwert hat.

• on_null – Setzen Sie auf True, um ON NULL in Verbindung mit einer always=False Identitätsspalte anzugeben. Diese Option wird nur von einigen Backends wie Oracle Database unterstützt.

• start – der Startwert der Sequenz.

• increment – der Inkrementwert der Sequenz.

• minvalue – der Mindestwert der Sequenz.

• maxvalue – der Maximalwert der Sequenz.

• nominvalue – kein Mindestwert der Sequenz.

• nomaxvalue – kein Maximalwert der Sequenz.

• cycle – ermöglicht es der Sequenz, bei Erreichen von maxvalue oder minvalue wieder von vorne zu beginnen.

• cache – optionaler Ganzzahlwert; Anzahl der zukünftigen Werte in der Sequenz, die im Voraus berechnet werden.

• order – optionaler Boolescher Wert; wenn wahr, wird das Schlüsselwort ORDER gerendert.

method sqlalchemy.schema.Identity.copy(**kw: Any) → Identity

Veraltet seit Version 1.4: Die Methode Identity.copy() ist veraltet und wird in einer zukünftigen Version entfernt.