SQLAlchemy 2.0 Dokumentation

ORM Ausführungsoptionen - Dokumentation zu allen ORM-spezifischen Ausführungsoptionen

methode sqlalchemy.sql.expression.CompoundSelect.exists() → Exists¶

geerbt von der SelectBase.exists() Methode von SelectBase

Gibt eine Exists-Repräsentation dieses Selektierbaren zurück, die als Spaltenausdruck verwendet werden kann.

Das zurückgegebene Objekt ist eine Instanz von Exists.

Siehe auch

EXISTS-Unterabfragen – im 2.0-Stil-Tutorial.

Neu in Version 1.4.

attribut sqlalchemy.sql.expression.CompoundSelect.exported_columns¶

geerbt von dem SelectBase.exported_columns Attribut von SelectBase

Eine ColumnCollection, die die „exportierten“ Spalten dieses Selectable darstellt, ohne TextClause-Konstrukte.

Die „exportierten“ Spalten für ein SelectBase-Objekt sind gleichbedeutend mit der SelectBase.selected_columns-Sammlung.

Neu in Version 1.4.

Siehe auch

methode sqlalchemy.sql.expression.CompoundSelect.fetch(count: _LimitOffsetType, with_ties: bool = False, percent: bool = False) → Self¶

geerbt von der GenerativeSelect.fetch() Methode von GenerativeSelect

Gibt einen neuen Selektierbaren mit dem angegebenen FETCH FIRST-Kriterium zurück.

Dies ist ein numerischer Wert, der normalerweise als FETCH {FIRST | NEXT} [ count ] {ROW | ROWS} {ONLY | WITH TIES} Ausdruck in der resultierenden SELECT-Anweisung gerendert wird. Diese Funktionalität ist derzeit für Oracle Database, PostgreSQL, MSSQL implementiert.

Verwenden Sie GenerativeSelect.offset(), um den Offset anzugeben.

Hinweis

Die Methode GenerativeSelect.fetch() ersetzt jede mit GenerativeSelect.limit() angewendete Klausel.

Neu in Version 1.4.

Parameter:

count¶ – ein ganzzahliger COUNT-Parameter oder ein SQL-Ausdruck, der ein ganzzahliges Ergebnis liefert. Wenn percent=True ist, stellt dies den Prozentsatz der zurückzugebenden Zeilen dar, nicht den absoluten Wert. Übergeben Sie None, um ihn zurückzusetzen.
with_ties¶ – Wenn True, wird die WITH TIES-Option verwendet, um zusätzliche Zeilen zurückzugeben, die im Ergebnis-Set gemäß der ORDER BY-Klausel den letzten Platz belegen. Die ORDER BY-Klausel kann in diesem Fall obligatorisch sein. Standardmäßig ist dies False
percent¶ – Wenn True, repräsentiert count den Prozentsatz der Gesamtzahl der ausgewählten Zeilen, die zurückgegeben werden sollen. Standardmäßig ist dies False

Siehe auch

Aggregatfunktionen mit GROUP BY / HAVING - im SQLAlchemy Unified Tutorial

methode sqlalchemy.sql.expression.CompoundSelect.get_execution_options() → _ExecuteOptions¶: geerbt von der Executable.get_execution_options() Methode von Executable

Ruft die nicht-SQL-Optionen ab, die während der Ausführung wirksam werden.

Neu in Version 1.3.

Siehe auch

Executable.execution_options()

methode sqlalchemy.sql.expression.CompoundSelect.get_label_style() → SelectLabelStyle¶: geerbt von der GenerativeSelect.get_label_style() Methode von GenerativeSelect

Ruft den aktuellen Label-Stil ab.

Neu in Version 1.4.

methode sqlalchemy.sql.expression.CompoundSelect.group_by(_GenerativeSelect__first: Literal[None, _NoArg.NO_ARG] | _ColumnExpressionOrStrLabelArgument[Any] = _NoArg.NO_ARG, *clauses: _ColumnExpressionOrStrLabelArgument[Any]) → Self¶

geerbt von der GenerativeSelect.group_by() Methode von GenerativeSelect

Gibt einen neuen Selektierbaren mit der angegebenen Liste von GROUP BY-Kriterien zurück.

Alle vorhandenen GROUP BY-Einstellungen können unterdrückt werden, indem None übergeben wird.

z. B.

stmt = select(table.c.name, func.max(table.c.stat)).group_by(table.c.name)

Parameter:: *clauses¶ – eine Reihe von ColumnElement-Konstrukten, die zur Erzeugung einer GROUP BY-Klausel verwendet werden.

Siehe auch

Sortierung oder Gruppierung nach einem Label - im SQLAlchemy Unified Tutorial

methode sqlalchemy.sql.expression.CompoundSelect.is_derived_from(fromclause: FromClause | None) → bool¶

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

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

methode sqlalchemy.sql.expression.CompoundSelect.label(name: str | None) → Label[Any]¶: geerbt von der SelectBase.label() Methode von SelectBase

Gibt eine „skalare“ Repräsentation dieses Selektierbaren zurück, eingebettet als Unterabfrage mit einem Label.

Siehe auch

SelectBase.scalar_subquery().

methode sqlalchemy.sql.expression.CompoundSelect.lateral(name: str | None = None) → LateralFromClause¶

geerbt von der SelectBase.lateral() Methode von SelectBase

Gibt einen LATERAL-Alias dieses Selectable zurück.

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

Siehe auch

LATERAL Korrelation - Überblick über die Nutzung.

methode sqlalchemy.sql.expression.CompoundSelect.limit(limit: _LimitOffsetType) → Self¶

geerbt von der GenerativeSelect.limit() Methode von GenerativeSelect

Gibt ein neues auswählbares Objekt mit dem angegebenen LIMIT-Kriterium zurück.

Dies ist ein numerischer Wert, der normalerweise als LIMIT-Ausdruck in der resultierenden Auswahl gerendert wird. Backends, die LIMIT nicht unterstützen, werden versuchen, eine ähnliche Funktionalität bereitzustellen.

Hinweis

Die Methode GenerativeSelect.limit() ersetzt jede mit GenerativeSelect.fetch() angewendete Klausel.

Parameter:: limit¶ – Ein numerischer LIMIT-Parameter oder ein SQL-Ausdruck, der ein numerisches Ergebnis liefert. Übergeben Sie None, um ihn zurückzusetzen.

Siehe auch

methode sqlalchemy.sql.expression.CompoundSelect.offset(offset: _LimitOffsetType) → Self¶

geerbt von der GenerativeSelect.offset() Methode von GenerativeSelect

Gibt ein neues auswählbares Objekt mit dem angegebenen OFFSET-Kriterium zurück.

Dies ist ein numerischer Wert, der normalerweise als OFFSET-Ausdruck in der resultierenden Auswahl gerendert wird. Backends, die OFFSET nicht unterstützen, werden versuchen, eine ähnliche Funktionalität bereitzustellen.

Parameter:: offset¶ – Ein numerischer OFFSET-Parameter oder ein SQL-Ausdruck, der ein numerisches Ergebnis liefert. Übergeben Sie None, um ihn zurückzusetzen.

Siehe auch

Sortierung oder Gruppierung nach einem Label - im SQLAlchemy Unified Tutorial

methode sqlalchemy.sql.expression.CompoundSelect.options(*options: ExecutableOption) → Self¶

geerbt von der Executable.options() Methode von Executable

Wendet Optionen auf diese Anweisung an.

Im Allgemeinen sind Optionen beliebige Python-Objekte, die vom SQL-Compiler für die Anweisung interpretiert werden können. Diese Optionen können von bestimmten Dialekten oder bestimmten Arten von Compilern verarbeitet werden.

Die bekanntesten Arten von Optionen sind die ORM-Level-Optionen, die "eager load" und andere Lademechanismen auf eine ORM-Abfrage anwenden. Optionen können jedoch theoretisch für viele andere Zwecke verwendet werden.

Informationen zu spezifischen Optionsarten für spezifische Anweisungsarten finden Sie in der Dokumentation zu diesen Options-Objekten.

Geändert in Version 1.4: - hinzugefügt Executable.options() zu Core-Anweisungsobjekten mit dem Ziel, vereinheitlichte Core- / ORM-Abfragefähigkeiten zu ermöglichen.

Siehe auch

Optionen zum Laden von Spalten - bezieht sich auf Optionen, die spezifisch für die Verwendung von ORM-Abfragen sind

Laden von Beziehungen mit Ladeoptionen - bezieht sich auf Optionen, die spezifisch für die Verwendung von ORM-Abfragen sind

methode sqlalchemy.sql.expression.CompoundSelect.order_by(_GenerativeSelect__first: Literal[None, _NoArg.NO_ARG] | _ColumnExpressionOrStrLabelArgument[Any], *clauses: _ColumnExpressionOrStrLabelArgument[Any]) → Self¶

geerbt von der GenerativeSelect.order_by() Methode von GenerativeSelect

Gibt ein neues auswählbares Objekt mit der angegebenen Liste von ORDER BY-Kriterien zurück.

z. B.

stmt = select(table).order_by(table.c.id, table.c.name)

Das mehrmalige Aufrufen dieser Methode ist gleichbedeutend mit dem einmaligen Aufruf mit allen verketteten Klauseln. Alle vorhandenen ORDER BY-Kriterien können durch Übergabe von None als alleinstehendem Argument abgebrochen werden. Neue ORDER BY-Kriterien können dann durch erneutes Aufrufen von Query.order_by() hinzugefügt werden, z. B.

# will erase all ORDER BY and ORDER BY new_col alone
stmt = stmt.order_by(None).order_by(new_col)

Parameter:: *clauses¶ – Eine Reihe von ColumnElement-Konstrukten, die zur Erzeugung einer ORDER BY-Klausel verwendet werden.

Siehe auch

ORDER BY - im SQLAlchemy Unified Tutorial

methode sqlalchemy.sql.expression.CompoundSelect.replace_selectable(old: FromClause, alias: Alias) → Self¶: geerbt von der Selectable.replace_selectable() Methode von Selectable

Ersetzt alle Vorkommen von FromClause 'old' durch das angegebene Alias-Objekt und gibt eine Kopie dieses 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.

methode sqlalchemy.sql.expression.CompoundSelect.scalar_subquery() → ScalarSelect[Any]¶

geerbt von der SelectBase.scalar_subquery() Methode von SelectBase

Gibt eine "skalare" Darstellung dieses auswählbaren Objekts zurück, die als Spaltenausdruck verwendet werden kann.

Das zurückgegebene Objekt ist eine Instanz von ScalarSelect.

Typischerweise ist eine SELECT-Anweisung mit nur einer Spalte in ihrer Spaltenklausel als skalarer Ausdruck qualifiziert. Die skalare Unterabfrage kann dann in der WHERE-Klausel oder der Spaltenklausel einer umschließenden SELECT-Anweisung verwendet werden.

Beachten Sie, dass sich die skalare Unterabfrage von der Unterabfrage auf FROM-Ebene unterscheidet, die mit der Methode SelectBase.subquery() erzeugt werden kann.

Siehe auch

Skalare und korrelierte Unterabfragen - im 2.0 Tutorial

methode sqlalchemy.sql.expression.CompoundSelect.select(*arg: Any, **kw: Any) → Select¶: geerbt von der SelectBase.select() Methode von SelectBase

Veraltet seit Version 1.4: Die Methode SelectBase.select() ist veraltet und wird in einer zukünftigen Version entfernt; diese Methode erstellt implizit eine Unterabfrage, die explizit sein sollte. Bitte rufen Sie zuerst SelectBase.subquery() auf, um eine Unterabfrage zu erstellen, die dann ausgewählt werden kann.

attribut sqlalchemy.sql.expression.CompoundSelect.selected_columns¶

Eine ColumnCollection, die die Spalten darstellt, die diese SELECT-Anweisung oder ein ähnliches Konstrukt in ihrem Ergebnissatz zurückgibt, einschließlich TextClause-Konstrukten.

Für ein CompoundSelect gibt das Attribut CompoundSelect.selected_columns die ausgewählten Spalten der ersten SELECT-Anweisung zurück, die in der Reihe von Anweisungen innerhalb der Mengenoperation enthalten ist.

Siehe auch

Select.selected_columns

Neu in Version 1.4.

methode sqlalchemy.sql.expression.CompoundSelect.self_group(against: OperatorType | None = None) → GroupedElement¶

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 selbst bereitzustellen, wenn sie in einen größeren Ausdruck platziert werden, sowie von select()-Konstrukten, wenn sie in die FROM-Klausel eines anderen select() platziert werden. (Beachten Sie, dass Unterabfragen normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen verschachtelte SELECT-Anweisungen benennen müssen).

Wenn Ausdrücke zusammengesetzt werden, erfolgt 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 - Klammern sind möglicherweise nicht erforderlich, z. B. in einem Ausdruck wie x OR (y AND z) - AND hat Vorrang vor OR.

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

methode sqlalchemy.sql.expression.CompoundSelect.set_label_style(style: SelectLabelStyle) → Self¶

Gibt ein neues auswählbares Objekt mit dem angegebenen Beschriftungsstil zurück.

Es stehen drei "Beschriftungsstile" zur Verfügung: SelectLabelStyle.LABEL_STYLE_DISAMBIGUATE_ONLY, SelectLabelStyle.LABEL_STYLE_TABLENAME_PLUS_COL und SelectLabelStyle.LABEL_STYLE_NONE. Der Standardstil ist SelectLabelStyle.LABEL_STYLE_DISAMBIGUATE_ONLY.

Im modernen SQLAlchemy ist es im Allgemeinen nicht erforderlich, den Beschriftungsstil zu ändern, da per Ausdruck zugewiesene Beschriftungen effektiver durch die Verwendung der Methode ColumnElement.label() verwendet werden. In früheren Versionen wurde LABEL_STYLE_TABLENAME_PLUS_COL verwendet, um gleichnamige Spalten aus verschiedenen Tabellen, Aliasen oder Unterabfragen zu disambiguieren; das neuere LABEL_STYLE_DISAMBIGUATE_ONLY wendet nun Beschriftungen nur auf Namen an, die mit einem vorhandenen Namen in Konflikt stehen, so dass die Auswirkungen dieser Beschriftung minimal sind.

Der Grund für die Disambiguierung liegt hauptsächlich darin, dass alle Spaltenausdrücke aus einer gegebenen FromClause.c-Sammlung verfügbar sind, wenn eine Unterabfrage erstellt wird.

Neu in Version 1.4: - die Methode GenerativeSelect.set_label_style() ersetzt die vorherige Kombination der Methoden und/oder Parameter .apply_labels(), .with_labels() und use_labels=True.

Siehe auch

LABEL_STYLE_DISAMBIGUATE_ONLY

LABEL_STYLE_TABLENAME_PLUS_COL

LABEL_STYLE_NONE

LABEL_STYLE_DEFAULT

methode sqlalchemy.sql.expression.CompoundSelect.slice(start: int, stop: int) → Self¶

geerbt von der GenerativeSelect.slice() Methode von GenerativeSelect

Wendet LIMIT / OFFSET auf diese Anweisung basierend auf einem Slice an.

Die Start- und Stoppindizes verhalten sich wie die Argumente für die eingebaute Funktion range() von Python. Diese Methode bietet eine Alternative zur Verwendung von LIMIT/OFFSET, um einen Slice der Abfrage zu erhalten.

Zum Beispiel,

stmt = select(User).order_by(User.id).slice(1, 3)

gerendert als

SELECT users.id AS users_id,
       users.name AS users_name
FROM users ORDER BY users.id
LIMIT ? OFFSET ?
(2, 1)

Hinweis

Die Methode GenerativeSelect.slice() ersetzt jede mit GenerativeSelect.fetch() angewendete Klausel.

Neu in Version 1.4: Hinzugefügt die Methode GenerativeSelect.slice(), die von der ORM verallgemeinert wurde.

Siehe auch

methode sqlalchemy.sql.expression.CompoundSelect.subquery(name: str | None = None) → Subquery¶

geerbt von der SelectBase.subquery() Methode von SelectBase

Gibt eine Unterabfrage dieses SelectBase zurück.

Eine Unterabfrage ist aus SQL-Sicht ein in Klammern gesetztes, benanntes Konstrukt, das in der FROM-Klausel einer anderen SELECT-Anweisung platziert werden kann.

Gegeben eine SELECT-Anweisung wie

stmt = select(table.c.id, table.c.name)

Die obige Anweisung könnte so aussehen

SELECT table.id, table.name FROM table

Die Unterabfrageform selbst wird auf die gleiche Weise gerendert, aber wenn sie in die FROM-Klausel einer anderen SELECT-Anweisung eingebettet wird, wird sie zu einem benannten Unterelement

subq = stmt.subquery()
new_stmt = select(subq)

Die obige Anweisung wird gerendert als

SELECT anon_1.id, anon_1.name
FROM (SELECT table.id, table.name FROM table) AS anon_1

Historisch gesehen ist SelectBase.subquery() äquivalent zum Aufruf der Methode FromClause.alias() für ein FROM-Objekt; da ein SelectBase-Objekt jedoch kein direktes FROM-Objekt ist, bietet die Methode SelectBase.subquery() klarere Semantik.

Neu in Version 1.4.

methode sqlalchemy.sql.expression.CompoundSelect.with_for_update(*, nowait: bool = False, read: bool = False, of: _ForUpdateOfArgument | None = None, skip_locked: bool = False, key_share: bool = False) → Self¶

geerbt von der GenerativeSelect.with_for_update() Methode von GenerativeSelect

Gibt eine FOR UPDATE-Klausel für dieses GenerativeSelect an.

Z. B.

stmt = select(table).with_for_update(nowait=True)

Auf einer Datenbank wie PostgreSQL oder Oracle Database würde das Obige eine Anweisung rendern wie

SELECT table.a, table.b FROM table FOR UPDATE NOWAIT

Auf anderen Backends wird die Option nowait ignoriert und stattdessen würde dies produziert werden

SELECT table.a, table.b FROM table FOR UPDATE

Wenn ohne Argumente aufgerufen, wird die Anweisung mit dem Suffix FOR UPDATE gerendert. Zusätzliche Argumente können dann bereitgestellt werden, die gängige datenbankspezifische Varianten ermöglichen.

Parameter:

nowait¶ – boolean; rendert FOR UPDATE NOWAIT auf Oracle Database und PostgreSQL-Dialekten.
read¶ – boolean; rendert LOCK IN SHARE MODE auf MySQL, FOR SHARE auf PostgreSQL. Auf PostgreSQL wird in Kombination mit nowait FOR SHARE NOWAIT gerendert.
of¶ – SQL-Ausdruck oder Liste von SQL-Ausdruckselementen (typischerweise Column-Objekte oder ein kompatibler Ausdruck, für einige Backends auch ein Tabellenausdruck) die in eine FOR UPDATE OF-Klausel gerendert werden; unterstützt von PostgreSQL, Oracle Database, einigen MySQL-Versionen und möglicherweise anderen. Kann je nach Backend als Tabelle oder als Spalte gerendert werden.
skip_locked¶ – boolean, wird für Oracle Database und PostgreSQL-Dialekte als FOR UPDATE SKIP LOCKED oder FOR SHARE SKIP LOCKED gerendert, wenn auch read=True angegeben ist.
key_share¶ – boolean, wird für den PostgreSQL-Dialekt als FOR NO KEY UPDATE oder, wenn mit read=True kombiniert, als FOR KEY SHARE gerendert.

class sqlalchemy.sql.expression.CTE¶

Repräsentiert eine Common Table Expression.

Das CTE-Objekt wird über die Methode SelectBase.cte() von jeder SELECT-Anweisung erhalten. Eine seltener verfügbare Syntax erlaubt auch die Verwendung der Methode HasCTE.cte(), die auf DML-Konstrukten wie Insert, Update und Delete vorhanden ist. Einzelheiten zur Verwendung von CTEs finden Sie in der Methode HasCTE.cte().

Siehe auch

Subqueries und CTEs - im 2.0 Tutorial

HasCTE.cte() - Beispiele für Aufrufstile

Mitglieder

alias(), union(), union_all()

Klassensignatur

class sqlalchemy.sql.expression.CTE (sqlalchemy.sql.roles.DMLTableRole, sqlalchemy.sql.roles.IsCTERole, sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.HasPrefixes, sqlalchemy.sql.expression.HasSuffixes, sqlalchemy.sql.expression.AliasedReturnsRows)

method sqlalchemy.sql.expression.CTE.alias(name: str | None = None, flat: bool = False) → CTE¶

Gibt einen Alias dieser CTE zurück.

Diese Methode ist eine CTE-spezifische Spezialisierung der Methode FromClause.alias().

Siehe auch

execution_options(), get_execution_options(), options()

method sqlalchemy.sql.expression.CTE.union(*other: _SelectStatementForCompoundArgument[Any]) → CTE¶

Gibt eine neue CTE mit einer SQL UNION der ursprünglichen CTE gegen die als Positionsargumente übergebenen Selektierbaren zurück.

Parameter:

*other¶ –

ein oder mehrere Elemente, aus denen eine UNION erstellt werden soll.

Geändert in Version 1.4.28: Mehrere Elemente werden jetzt akzeptiert.

Siehe auch

HasCTE.cte() - Beispiele für Aufrufstile

method sqlalchemy.sql.expression.CTE.union_all(*other: _SelectStatementForCompoundArgument[Any]) → CTE¶

Gibt eine neue CTE mit einer SQL UNION ALL der ursprünglichen CTE gegen die als Positionsargumente übergebenen Selektierbaren zurück.

Parameter:

*other¶ –

ein oder mehrere Elemente, aus denen eine UNION erstellt werden soll.

Geändert in Version 1.4.28: Mehrere Elemente werden jetzt akzeptiert.

Siehe auch

HasCTE.cte() - Beispiele für Aufrufstile

class sqlalchemy.sql.expression.Executable¶

Markiert ein ClauseElement als ausführbar.

Executable ist eine Oberklasse für alle "Statement"-Typen von Objekten, einschließlich select(), delete(), update(), insert(), text().

Mitglieder

Klassensignatur

class sqlalchemy.sql.expression.Executable (sqlalchemy.sql.roles.StatementRole)

method sqlalchemy.sql.expression.Executable.execution_options(**kw: Any) → Self¶

Setzt Nicht-SQL-Optionen für die Anweisung, die während der Ausführung wirksam werden.

Ausführungsoptionen können auf verschiedenen Ebenen gesetzt werden, einschließlich pro Anweisung, pro Verbindung oder pro Ausführung, unter Verwendung von Methoden wie Connection.execution_options() und Parametern, die ein Dictionary von Optionen akzeptieren, wie z.B. Connection.execute.execution_options und Session.execute.execution_options.

Das Hauptmerkmal einer Ausführungsoption, im Gegensatz zu anderen Arten von Optionen wie ORM-Laderoptionen, ist, dass **Ausführungsoptionen niemals die kompilierte SQL einer Abfrage beeinflussen, sondern nur Dinge, die beeinflussen, wie die SQL-Anweisung selbst aufgerufen wird oder wie Ergebnisse abgerufen werden**. Das heißt, Ausführungsoptionen sind kein Teil dessen, was durch die SQL-Kompilierung abgedeckt wird, noch gelten sie als Teil des Cache-Zustands einer Anweisung.

Die Methode Executable.execution_options() ist generativ, wie auch die Methode, die auf die Engine und Query Objekte angewendet wird, was bedeutet, dass beim Aufruf der Methode eine Kopie des Objekts zurückgegeben wird, die die gegebenen Parameter auf diese neue Kopie anwendet, aber das Original unverändert lässt

statement = select(table.c.x, table.c.y)
new_statement = statement.execution_options(my_option=True)

Eine Ausnahme von diesem Verhalten ist das Connection-Objekt, bei dem die Methode Connection.execution_options() ausdrücklich **nicht** generativ ist.

Die Arten von Optionen, die an Executable.execution_options() und andere verwandte Methoden und Parameter-Dictionaries übergeben werden können, umfassen Parameter, die explizit von SQLAlchemy Core oder ORM konsumiert werden, sowie beliebige Schlüsselwortargumente, die nicht von SQLAlchemy definiert sind. Dies bedeutet, dass die Methoden und/oder Parameter-Dictionaries für benutzerdefinierte Parameter verwendet werden können, die mit benutzerdefiniertem Code interagieren, der auf die Parameter über Methoden wie Executable.get_execution_options() und Connection.get_execution_options() zugreifen kann, oder innerhalb ausgewählter Event-Hooks unter Verwendung eines dedizierten execution_options-Event-Parameters wie ConnectionEvents.before_execute.execution_options oder ORMExecuteState.execution_options, z. B.

from sqlalchemy import event


@event.listens_for(some_engine, "before_execute")
def _process_opt(conn, statement, multiparams, params, execution_options):
    "run a SQL function before invoking a statement"

    if execution_options.get("do_special_thing", False):
        conn.exec_driver_sql("run_special_function()")

Innerhalb des Bereichs von Optionen, die von SQLAlchemy explizit erkannt werden, gelten die meisten für bestimmte Klassen von Objekten und nicht für andere. Die gängigsten Ausführungsoptionen sind

Connection.execution_options.isolation_level - setzt die Isolationsebene für eine Verbindung oder eine Klasse von Verbindungen über eine Engine. Diese Option wird nur von Connection oder Engine akzeptiert.
Connection.execution_options.stream_results - gibt an, dass Ergebnisse mit einem serverseitigen Cursor abgerufen werden sollen; diese Option wird von Connection, vom Parameter Connection.execute.execution_options auf Connection.execute() und zusätzlich von Executable.execution_options() auf einem SQL-Anweisungsobjekt sowie von ORM-Konstrukten wie Session.execute() akzeptiert.
Connection.execution_options.compiled_cache - gibt ein Dictionary an, das als SQL-Kompilierungs-Cache für eine Connection oder Engine sowie für ORM-Methoden wie Session.execute() dient. Kann als None übergeben werden, um das Caching für Anweisungen zu deaktivieren. Diese Option wird nicht von Executable.execution_options() akzeptiert, da es nicht ratsam ist, einen Kompilierungs-Cache mit einem Anweisungsobjekt mitzuführen.
Connection.execution_options.schema_translate_map - eine Zuordnung von Schemanamen, die von der Schema Translate Map-Funktion verwendet wird, akzeptiert von Connection, Engine, Executable, sowie von ORM-Konstrukten wie Session.execute().

Siehe auch

ORM Ausführungsoptionen - Dokumentation zu allen ORM-spezifischen Ausführungsoptionen

method sqlalchemy.sql.expression.Executable.get_execution_options() → _ExecuteOptions¶: Ruft die nicht-SQL-Optionen ab, die während der Ausführung wirksam werden.

Neu in Version 1.3.

Siehe auch

Executable.execution_options()

method sqlalchemy.sql.expression.Executable.options(*options: ExecutableOption) → Self¶

Wendet Optionen auf diese Anweisung an.

Im Allgemeinen sind Optionen beliebige Python-Objekte, die vom SQL-Compiler für die Anweisung interpretiert werden können. Diese Optionen können von bestimmten Dialekten oder bestimmten Arten von Compilern verarbeitet werden.

Die bekanntesten Arten von Optionen sind die ORM-Level-Optionen, die "eager load" und andere Lademechanismen auf eine ORM-Abfrage anwenden. Optionen können jedoch theoretisch für viele andere Zwecke verwendet werden.

Informationen zu spezifischen Optionsarten für spezifische Anweisungsarten finden Sie in der Dokumentation zu diesen Options-Objekten.

Geändert in Version 1.4: - hinzugefügt Executable.options() zu Core-Anweisungsobjekten mit dem Ziel, vereinheitlichte Core- / ORM-Abfragefähigkeiten zu ermöglichen.

Siehe auch

Optionen zum Laden von Spalten - bezieht sich auf Optionen, die spezifisch für die Verwendung von ORM-Abfragen sind

Laden von Beziehungen mit Ladeoptionen - bezieht sich auf Optionen, die spezifisch für die Verwendung von ORM-Abfragen sind

class sqlalchemy.sql.expression.Exists¶

Repräsentiert eine EXISTS Klausel.

Siehe exists() für eine Beschreibung der Verwendung.

Eine EXISTS-Klausel kann auch aus einer select()-Instanz durch Aufruf von SelectBase.exists() konstruiert werden.

Mitglieder

correlate(), correlate_except(), inherit_cache, select(), select_from(), where()

Klassensignatur

class sqlalchemy.sql.expression.Exists (sqlalchemy.sql.expression.UnaryExpression)

method sqlalchemy.sql.expression.Exists.correlate(*fromclauses: Literal[None, False] | _FromClauseArgument) → Self¶: Korrelation auf die durch diese Exists-Anweisung bezeichnete Unterabfrage anwenden.

Siehe auch

ScalarSelect.correlate()

method sqlalchemy.sql.expression.Exists.correlate_except(*fromclauses: Literal[None, False] | _FromClauseArgument) → Self¶: Korrelation auf die durch diese Exists-Anweisung bezeichnete Unterabfrage anwenden.

Siehe auch

ScalarSelect.correlate_except()

attribute sqlalchemy.sql.expression.Exists.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.

method sqlalchemy.sql.expression.Exists.select() → Select¶

Gibt eine SELECT-Anweisung dieser Exists-Anweisung zurück.

z. B.

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

Dies erzeugt eine Anweisung ähnlich

SELECT EXISTS (SELECT id FROM some_table WHERE some_table = :param) AS anon_1

Siehe auch

select() - allgemeine Methode, die beliebige Spaltenlisten ermöglicht.

method sqlalchemy.sql.expression.Exists.select_from(*froms: _FromClauseArgument) → Self¶: Gibt ein neues Exists-Konstrukt zurück, indem der angegebene Ausdruck auf die Methode Select.select_from() der enthaltenen SELECT-Anweisung angewendet wird.

Hinweis

Es ist typischerweise vorzuziehen, zuerst eine Select-Anweisung zu erstellen, einschließlich der gewünschten WHERE-Klausel, und dann die Methode SelectBase.exists() zu verwenden, um auf einmal ein Exists-Objekt zu erzeugen.

method sqlalchemy.sql.expression.Exists.where(*clause: _ColumnExpressionArgument[bool]) → Self¶: Gibt ein neues exists()-Konstrukt zurück, wobei der angegebene Ausdruck zur WHERE-Klausel hinzugefügt wird, verbunden mit der bestehenden Klausel über AND, falls vorhanden.

Hinweis

Es ist typischerweise vorzuziehen, zuerst eine Select-Anweisung zu erstellen, einschließlich der gewünschten WHERE-Klausel, und dann die Methode SelectBase.exists() zu verwenden, um auf einmal ein Exists-Objekt zu erzeugen.

class sqlalchemy.sql.expression.FromClause¶

Repräsentiert ein Element, das innerhalb der FROM Klausel einer SELECT Anweisung verwendet werden kann.

Die häufigsten Formen von FromClause sind Table und die select()-Konstrukte. Wichtige Merkmale, die allen FromClause-Objekten gemeinsam sind:

eine c-Sammlung, die namensbasierten Zugriff auf eine Sammlung von ColumnElement-Objekten bietet.
ein primary_key-Attribut, das eine Sammlung aller ColumnElement-Objekte ist, die das Flag primary_key kennzeichnen.
Methoden zum Generieren verschiedener Ableitungen einer "from"-Klausel, einschließlich FromClause.alias(), FromClause.join(), FromClause.select().

Mitglieder

alias(), c, columns, description, entity_namespace, exported_columns, foreign_keys, is_derived_from(), join(), outerjoin(), primary_key, schema, select(), tablesample()

Klassensignatur

class sqlalchemy.sql.expression.FromClause (sqlalchemy.sql.roles.AnonymizedFromClauseRole, sqlalchemy.sql.expression.Selectable)

method sqlalchemy.sql.expression.FromClause.alias(name: str | None = None, flat: bool = False) → NamedFromClause¶

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

attribute sqlalchemy.sql.expression.FromClause.c¶

Ein Synonym für FromClause.columns

Gibt zurück:: eine ColumnCollection

attribute sqlalchemy.sql.expression.FromClause.columns¶

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

Die columns oder die c-Sammlung ist das Tor zur Konstruktion von SQL-Ausdrücken unter Verwendung tabellen- oder selektierbar gebundener Spalten.

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

Gibt zurück:: ein ColumnCollection-Objekt.

attribute sqlalchemy.sql.expression.FromClause.description¶

Eine kurze Beschreibung dieser FromClause.

Wird hauptsächlich für die Formatierung von Fehlermeldungen verwendet.

Attribut sqlalchemy.sql.expression.FromClause.entity_namespace¶

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.

stmt.filter_by(address="some address")

Standardmäßig ist dies die „.c“-Sammlung. Intern kann sie jedoch durch die Annotation „entity_namespace“ überschrieben werden, um alternative Ergebnisse zu liefern.

Attribut sqlalchemy.sql.expression.FromClause.exported_columns¶

Eine ColumnCollection, die die „exportierten“ Spalten dieses Selectable darstellt.

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

Neu in Version 1.4.

Siehe auch

Table.foreign_key_constraints

Attribut sqlalchemy.sql.expression.FromClause.foreign_keys¶

Gibt die Sammlung der ForeignKey-Markierungsobjekte zurück, auf die sich diese FromClause bezieht.

Jede ForeignKey ist Mitglied einer ForeignKeyConstraint auf Tabellenebene.

Siehe auch

Methode sqlalchemy.sql.expression.FromClause.is_derived_from(fromclause: FromClause | None) → bool¶

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

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

Methode sqlalchemy.sql.expression.FromClause.join(right: _FromClauseArgument, onclause: _ColumnExpressionArgument[bool] | None = None, isouter: bool = False, full: bool = False) → Join¶

Gibt einen Join von diesem FromClause zu einem 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 etwa so 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 jedes FromClause-Objekt wie ein Table-Objekt und kann auch ein auswählbares Objekt sein, z. B. eine ORM-zugeordnete Klasse.
onclause¶ – ein SQL-Ausdruck, der die ON-Klausel des Joins darstellt. Wenn dieser auf None belassen wird, versucht FromClause.join(), die beiden Tabellen basierend auf einer Fremdschlüsselbeziehung zu verbinden.
isouter¶ – Wenn True, wird ein LEFT OUTER JOIN anstelle von JOIN gerendert.
full¶ – Wenn True, wird ein FULL OUTER JOIN anstelle von LEFT OUTER JOIN gerendert. Dies impliziert FromClause.join.isouter.

Siehe auch

join() - eigenständige Funktion

Join - der Typ des erzeugten Objekts

Methode sqlalchemy.sql.expression.FromClause.outerjoin(right: _FromClauseArgument, onclause: _ColumnExpressionArgument[bool] | None = None, full: bool = False) → Join¶

Gibt einen Join von diesem FromClause zu einem anderen FromClause zurück, mit dem „isouter“-Flag auf True gesetzt.

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 jedes FromClause-Objekt wie ein Table-Objekt und kann auch ein auswählbares Objekt sein, z. B. eine ORM-zugeordnete Klasse.
onclause¶ – ein SQL-Ausdruck, der die ON-Klausel des Joins darstellt. Wenn dieser auf None belassen wird, versucht FromClause.join(), die beiden Tabellen basierend auf einer Fremdschlüsselbeziehung zu verbinden.
full¶ – Wenn True, wird ein FULL OUTER JOIN anstelle von LEFT OUTER JOIN gerendert.

Siehe auch

FromClause.join()

Join

Attribut sqlalchemy.sql.expression.FromClause.primary_key¶

Gibt die iterierbare 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 iterierbare Sammlung von Column-Objekten ist.

Attribut sqlalchemy.sql.expression.FromClause.schema: str | None = None¶

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

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

Methode sqlalchemy.sql.expression.FromClause.select() → Select¶

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 ermöglicht.

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

Gibt ein TABLESAMPLE-Alias dieser FromClause zurück.

Der Rückgabewert ist die TableSample-Konstruktion, die ebenfalls von der übergeordneten Funktion tablesample() bereitgestellt wird.

Siehe auch

tablesample() - Nutzungsrichtlinien und Parameter

Klasse sqlalchemy.sql.expression.GenerativeSelect¶

Basisklasse für SELECT-Anweisungen, denen zusätzliche Elemente hinzugefügt werden können.

Dies dient als Basis für Select und CompoundSelect, bei denen Elemente wie ORDER BY, GROUP BY hinzugefügt und die Spaltenrendering gesteuert werden kann. Vergleichen Sie dies mit TextualSelect, das, obwohl es SelectBase unterteilt und ebenfalls eine SELECT-Konstruktion ist, eine feste Textzeichenkette darstellt, die auf dieser Ebene nicht geändert werden kann, sondern nur als Unterabfrage verpackt wird.

Mitglieder

fetch(), get_label_style(), group_by(), limit(), offset(), order_by(), set_label_style(), slice(), with_for_update()

Klassensignatur

class sqlalchemy.sql.expression.GenerativeSelect (sqlalchemy.sql.expression.SelectBase, sqlalchemy.sql.expression.Generative)

Methode sqlalchemy.sql.expression.GenerativeSelect.fetch(count: _LimitOffsetType, with_ties: bool = False, percent: bool = False) → Self¶

Gibt einen neuen Selektierbaren mit dem angegebenen FETCH FIRST-Kriterium zurück.

Dies ist ein numerischer Wert, der normalerweise als FETCH {FIRST | NEXT} [ count ] {ROW | ROWS} {ONLY | WITH TIES} Ausdruck in der resultierenden SELECT-Anweisung gerendert wird. Diese Funktionalität ist derzeit für Oracle Database, PostgreSQL, MSSQL implementiert.

Verwenden Sie GenerativeSelect.offset(), um den Offset anzugeben.

Hinweis

Die Methode GenerativeSelect.fetch() ersetzt jede mit GenerativeSelect.limit() angewendete Klausel.

Neu in Version 1.4.

Parameter:

count¶ – ein ganzzahliger COUNT-Parameter oder ein SQL-Ausdruck, der ein ganzzahliges Ergebnis liefert. Wenn percent=True ist, stellt dies den Prozentsatz der zurückzugebenden Zeilen dar, nicht den absoluten Wert. Übergeben Sie None, um ihn zurückzusetzen.
with_ties¶ – Wenn True, wird die Option WITH TIES verwendet, um zusätzliche Zeilen zurückzugeben, die gemäß der Klausel ORDER BY den letzten Platz im Ergebnis-Set belegen. Die ORDER BY kann in diesem Fall zwingend erforderlich sein. Standardmäßig ist False.
percent¶ – Wenn True, repräsentiert count den Prozentsatz der Gesamtzahl der ausgewählten Zeilen, die zurückgegeben werden sollen. Standardmäßig ist False.

Siehe auch

Aggregatfunktionen mit GROUP BY / HAVING - im SQLAlchemy Unified Tutorial

Methode sqlalchemy.sql.expression.GenerativeSelect.get_label_style() → SelectLabelStyle¶: Ruft den aktuellen Label-Stil ab.

Neu in Version 1.4.

Methode sqlalchemy.sql.expression.GenerativeSelect.group_by(_GenerativeSelect__first: Literal[None, _NoArg.NO_ARG] | _ColumnExpressionOrStrLabelArgument[Any] = _NoArg.NO_ARG, *clauses: _ColumnExpressionOrStrLabelArgument[Any]) → Self¶

Gibt einen neuen Selektierbaren mit der angegebenen Liste von GROUP BY-Kriterien zurück.

Alle vorhandenen GROUP BY-Einstellungen können unterdrückt werden, indem None übergeben wird.

z. B.

stmt = select(table.c.name, func.max(table.c.stat)).group_by(table.c.name)

Parameter:: *clauses¶ – eine Reihe von ColumnElement-Konstrukten, die zur Erzeugung einer GROUP BY-Klausel verwendet werden.

Siehe auch

Sortierung oder Gruppierung nach einem Label - im SQLAlchemy Unified Tutorial

Methode sqlalchemy.sql.expression.GenerativeSelect.limit(limit: _LimitOffsetType) → Self¶

Gibt ein neues auswählbares Objekt mit dem angegebenen LIMIT-Kriterium zurück.

Dies ist ein numerischer Wert, der normalerweise als LIMIT-Ausdruck in der resultierenden Auswahl gerendert wird. Backends, die LIMIT nicht unterstützen, werden versuchen, eine ähnliche Funktionalität bereitzustellen.

Hinweis

Die Methode GenerativeSelect.limit() ersetzt jede mit GenerativeSelect.fetch() angewendete Klausel.

Parameter:: limit¶ – ein ganzzahliger LIMIT-Parameter oder ein SQL-Ausdruck, der ein ganzzahliges Ergebnis liefert. Übergeben Sie None, um ihn zurückzusetzen.

Siehe auch

Methode sqlalchemy.sql.expression.GenerativeSelect.offset(offset: _LimitOffsetType) → Self¶

Gibt ein neues auswählbares Objekt mit dem angegebenen OFFSET-Kriterium zurück.

Dies ist ein numerischer Wert, der normalerweise als OFFSET-Ausdruck in der resultierenden Auswahl gerendert wird. Backends, die OFFSET nicht unterstützen, werden versuchen, eine ähnliche Funktionalität bereitzustellen.

Parameter:: offset¶ – ein ganzzahliger OFFSET-Parameter oder ein SQL-Ausdruck, der ein ganzzahliges Ergebnis liefert. Übergeben Sie None, um ihn zurückzusetzen.

Siehe auch

Sortierung oder Gruppierung nach einem Label - im SQLAlchemy Unified Tutorial

Methode sqlalchemy.sql.expression.GenerativeSelect.order_by(_GenerativeSelect__first: Literal[None, _NoArg.NO_ARG] | _ColumnExpressionOrStrLabelArgument[Any] = _NoArg.NO_ARG, *clauses: _ColumnExpressionOrStrLabelArgument[Any]) → Self¶

Gibt ein neues auswählbares Objekt mit der angegebenen Liste von ORDER BY-Kriterien zurück.

z. B.

stmt = select(table).order_by(table.c.id, table.c.name)

Das mehrmalige Aufrufen dieser Methode ist gleichbedeutend mit dem einmaligen Aufruf mit allen verketteten Klauseln. Alle vorhandenen ORDER BY-Kriterien können durch Übergabe von None als alleinstehendem Argument abgebrochen werden. Neue ORDER BY-Kriterien können dann durch erneutes Aufrufen von Query.order_by() hinzugefügt werden, z. B.

# will erase all ORDER BY and ORDER BY new_col alone
stmt = stmt.order_by(None).order_by(new_col)

Parameter:: *clauses¶ – eine Reihe von ColumnElement-Konstrukten, die zur Erzeugung einer ORDER BY-Klausel verwendet werden.

Siehe auch

ORDER BY - im SQLAlchemy Unified Tutorial

Methode sqlalchemy.sql.expression.GenerativeSelect.set_label_style(style: SelectLabelStyle) → Self¶

Gibt ein neues auswählbares Objekt mit dem angegebenen Beschriftungsstil zurück.

Es stehen drei "Beschriftungsstile" zur Verfügung: SelectLabelStyle.LABEL_STYLE_DISAMBIGUATE_ONLY, SelectLabelStyle.LABEL_STYLE_TABLENAME_PLUS_COL und SelectLabelStyle.LABEL_STYLE_NONE. Der Standardstil ist SelectLabelStyle.LABEL_STYLE_DISAMBIGUATE_ONLY.

Im modernen SQLAlchemy ist es im Allgemeinen nicht erforderlich, den Beschriftungsstil zu ändern, da per Ausdruck zugewiesene Beschriftungen effektiver durch die Verwendung der Methode ColumnElement.label() verwendet werden. In früheren Versionen wurde LABEL_STYLE_TABLENAME_PLUS_COL verwendet, um gleichnamige Spalten aus verschiedenen Tabellen, Aliasen oder Unterabfragen zu disambiguieren; das neuere LABEL_STYLE_DISAMBIGUATE_ONLY wendet nun Beschriftungen nur auf Namen an, die mit einem vorhandenen Namen in Konflikt stehen, so dass die Auswirkungen dieser Beschriftung minimal sind.

Der Grund für die Disambiguierung liegt hauptsächlich darin, dass alle Spaltenausdrücke aus einer gegebenen FromClause.c-Sammlung verfügbar sind, wenn eine Unterabfrage erstellt wird.

Neu in Version 1.4: - die Methode GenerativeSelect.set_label_style() ersetzt die vorherige Kombination der Methoden und/oder Parameter .apply_labels(), .with_labels() und use_labels=True.

Siehe auch

LABEL_STYLE_DISAMBIGUATE_ONLY

LABEL_STYLE_TABLENAME_PLUS_COL

LABEL_STYLE_NONE

LABEL_STYLE_DEFAULT

Methode sqlalchemy.sql.expression.GenerativeSelect.slice(start: int, stop: int) → Self¶

Wendet LIMIT / OFFSET auf diese Anweisung basierend auf einem Slice an.

Die Start- und Stoppindizes verhalten sich wie die Argumente für die eingebaute Funktion range() von Python. Diese Methode bietet eine Alternative zur Verwendung von LIMIT/OFFSET, um einen Slice der Abfrage zu erhalten.

Zum Beispiel,

stmt = select(User).order_by(User.id).slice(1, 3)

gerendert als

SELECT users.id AS users_id,
       users.name AS users_name
FROM users ORDER BY users.id
LIMIT ? OFFSET ?
(2, 1)

Hinweis

Die Methode GenerativeSelect.slice() ersetzt jede mit GenerativeSelect.fetch() angewendete Klausel.

Neu in Version 1.4: Hinzugefügt die Methode GenerativeSelect.slice(), die von der ORM verallgemeinert wurde.

Siehe auch

exported_columns, is_derived_from()

Methode sqlalchemy.sql.expression.GenerativeSelect.with_for_update(*, nowait: bool = False, read: bool = False, of: _ForUpdateOfArgument | None = None, skip_locked: bool = False, key_share: bool = False) → Self¶

Gibt eine FOR UPDATE-Klausel für dieses GenerativeSelect an.

Z. B.

stmt = select(table).with_for_update(nowait=True)

Auf einer Datenbank wie PostgreSQL oder Oracle Database würde das Obige eine Anweisung rendern wie

SELECT table.a, table.b FROM table FOR UPDATE NOWAIT

Auf anderen Backends wird die Option nowait ignoriert und stattdessen würde dies produziert werden

SELECT table.a, table.b FROM table FOR UPDATE

Wenn ohne Argumente aufgerufen, wird die Anweisung mit dem Suffix FOR UPDATE gerendert. Zusätzliche Argumente können dann bereitgestellt werden, die gängige datenbankspezifische Varianten ermöglichen.

Parameter:

nowait¶ – boolean; rendert FOR UPDATE NOWAIT für Oracle Database und PostgreSQL-Dialekte.
read¶ – boolean; wird auf MySQL als LOCK IN SHARE MODE, auf PostgreSQL als FOR SHARE gerendert. Auf PostgreSQL wird es in Kombination mit nowait als FOR SHARE NOWAIT gerendert.
of¶ – SQL-Ausdruck oder Liste von SQL-Ausdruckselementen (typischerweise Column-Objekte oder ein kompatibler Ausdruck, für einige Backends kann es auch ein Tabellenausdruck sein), die in eine FOR UPDATE OF-Klausel gerendert werden; unterstützt von PostgreSQL, Oracle Database, einigen MySQL-Versionen und möglicherweise anderen. Kann je nach Backend als Tabelle oder als Spalte gerendert werden.
skip_locked¶ – boolean, wird auf Oracle Database und PostgreSQL-Dialekten als FOR UPDATE SKIP LOCKED oder als FOR SHARE SKIP LOCKED gerendert, wenn auch read=True angegeben ist.
key_share¶ – boolean, wird auf dem PostgreSQL-Dialekt als FOR NO KEY UPDATE oder, wenn kombiniert mit read=True, als FOR KEY SHARE gerendert.

class sqlalchemy.sql.expression.HasCTE¶

Mixin, das deklariert, dass eine Klasse CTE-Unterstützung beinhaltet.

Mitglieder

add_cte(), cte()

Klassensignatur

class sqlalchemy.sql.expression.HasCTE (sqlalchemy.sql.roles.HasCTERole, sqlalchemy.sql.expression.SelectsRows)

method sqlalchemy.sql.expression.HasCTE.add_cte(*ctes: CTE, nest_here: bool = False) → Self¶

Fügt eine oder mehrere CTE Konstrukte zu dieser Anweisung hinzu.

Diese Methode ordnet die gegebenen CTE Konstrukte der übergeordneten Anweisung zu, sodass sie alle bedingungslos in der WITH-Klausel der endgültigen Anweisung gerendert werden, auch wenn sie woanders in der Anweisung oder in Unterabfragen nicht referenziert werden.

Der optionale Parameter HasCTE.add_cte.nest_here hat, wenn er auf True gesetzt ist, den Effekt, dass jede gegebene CTE in einer WITH-Klausel gerendert wird, die direkt mit dieser Anweisung gerendert wird, anstatt an den Anfang der endgültigen gerenderten Anweisung verschoben zu werden, auch wenn diese Anweisung als Unterabfrage innerhalb einer größeren Anweisung gerendert wird.

Diese Methode hat zwei allgemeine Anwendungsfälle. Einer ist das Einbetten von CTE-Anweisungen, die ohne explizite Referenzierung einen Zweck erfüllen, wie z. B. das Einbetten einer DML-Anweisung wie INSERT oder UPDATE als CTE inline mit einer Hauptanweisung, die indirekt aus ihren Ergebnissen schöpfen kann. Der andere ist die Steuerung der exakten Platzierung einer bestimmten Reihe von CTE-Konstrukten, die direkt in Bezug auf eine bestimmte Anweisung gerendert werden sollen, die in einer größeren Anweisung verschachtelt sein kann.

Z. B.

from sqlalchemy import table, column, select

t = table("t", column("c1"), column("c2"))

ins = t.insert().values({"c1": "x", "c2": "y"}).cte()

stmt = select(t).add_cte(ins)

Würde rendern

WITH anon_1 AS (
    INSERT INTO t (c1, c2) VALUES (:param_1, :param_2)
)
SELECT t.c1, t.c2
FROM t

Oben ist die CTE „anon_1“ nicht in der SELECT-Anweisung referenziert, erfüllt aber dennoch die Aufgabe, eine INSERT-Anweisung auszuführen.

Ähnlich in einem DML-bezogenen Kontext, unter Verwendung des PostgreSQL Insert Konstrukts zur Generierung eines „Upsert“.

from sqlalchemy import table, column
from sqlalchemy.dialects.postgresql import insert

t = table("t", column("c1"), column("c2"))

delete_statement_cte = t.delete().where(t.c.c1 < 1).cte("deletions")

insert_stmt = insert(t).values({"c1": 1, "c2": 2})
update_statement = insert_stmt.on_conflict_do_update(
    index_elements=[t.c.c1],
    set_={
        "c1": insert_stmt.excluded.c1,
        "c2": insert_stmt.excluded.c2,
    },
).add_cte(delete_statement_cte)

print(update_statement)

Die obige Anweisung wird gerendert als

WITH deletions AS (
    DELETE FROM t WHERE t.c1 < %(c1_1)s
)
INSERT INTO t (c1, c2) VALUES (%(c1)s, %(c2)s)
ON CONFLICT (c1) DO UPDATE SET c1 = excluded.c1, c2 = excluded.c2

Neu in Version 1.4.21.

Parameter:

*ctes¶ –
null oder mehr CTE Konstrukte.

Geändert in Version 2.0: Mehrere CTE-Instanzen werden akzeptiert
nest_here¶ –
Wenn True, werden die gegebenen CTEs so gerendert, als würden sie das Flag HasCTE.cte.nesting auf True setzen, wenn sie zu diesem HasCTE hinzugefügt wurden. Unter der Annahme, dass die gegebenen CTEs nicht auch in einer äußeren umgebenden Anweisung referenziert werden, sollten die gegebenen CTEs auf der Ebene dieser Anweisung gerendert werden, wenn dieses Flag gesetzt ist.

Neu in Version 2.0.

Siehe auch

HasCTE.cte.nesting

method sqlalchemy.sql.expression.HasCTE.cte(name: str | None = None, recursive: bool = False, nesting: bool = False) → CTE¶

Gibt eine neue CTE oder Common Table Expression Instanz zurück.

Gemeinsame Tabellenausdrücke sind ein SQL-Standard, bei dem SELECT-Anweisungen auf sekundäre Anweisungen zurückgreifen können, die zusammen mit der Hauptanweisung angegeben werden, und zwar mit einer Klausel namens „WITH“. Spezielle Semantiken bezüglich UNION können ebenfalls angewendet werden, um „rekursive“ Abfragen zu ermöglichen, bei denen eine SELECT-Anweisung auf die Zeilenmenge zurückgreifen kann, die zuvor ausgewählt wurden.

CTEs können auch auf DML-Konstrukte UPDATE, INSERT und DELETE auf einigen Datenbanken angewendet werden, sowohl als Quelle von CTE-Zeilen in Kombination mit RETURNING als auch als Konsument von CTE-Zeilen.

SQLAlchemy erkennt CTE Objekte, die ähnlich wie Alias Objekte behandelt werden, als spezielle Elemente, die sowohl der FROM-Klausel der Anweisung als auch einer WITH-Klausel am Anfang der Anweisung geliefert werden.

Für spezielle Präfixe wie PostgreSQL „MATERIALIZED“ und „NOT MATERIALIZED“ kann die Methode CTE.prefix_with() verwendet werden, um diese zu etablieren.

Geändert in Version 1.3.13: Unterstützung für Präfixe hinzugefügt. Insbesondere – MATERIALIZED und NOT MATERIALIZED.

Parameter:

name¶ – Name, der für die Common Table Expression vergeben wird. Ähnlich wie bei FromClause.alias() kann der Name als None belassen werden, in diesem Fall wird zur Zeit der Query-Kompilierung ein anonymer Symbol verwendet.
recursive¶ – wenn True, wird WITH RECURSIVE gerendert. Eine rekursive Common Table Expression ist dazu gedacht, in Verbindung mit UNION ALL verwendet zu werden, um Zeilen aus bereits ausgewählten Zeilen abzuleiten.
nesting¶ –
Wenn True, wird die CTE lokal für die Anweisung gerendert, in der sie referenziert wird. Für komplexere Szenarien kann die Methode HasCTE.add_cte() mit dem Parameter HasCTE.add_cte.nest_here verwendet werden, um die genaue Platzierung einer bestimmten CTE genauer zu steuern.

Neu in Version 1.4.24.

Siehe auch

HasCTE.add_cte()

Die folgenden Beispiele enthalten zwei aus der PostgreSQL-Dokumentation unter https://www.postgresql.org/docs/current/static/queries-with.html sowie zusätzliche Beispiele.

Beispiel 1, nicht rekursiv

from sqlalchemy import (
    Table,
    Column,
    String,
    Integer,
    MetaData,
    select,
    func,
)

metadata = MetaData()

orders = Table(
    "orders",
    metadata,
    Column("region", String),
    Column("amount", Integer),
    Column("product", String),
    Column("quantity", Integer),
)

regional_sales = (
    select(orders.c.region, func.sum(orders.c.amount).label("total_sales"))
    .group_by(orders.c.region)
    .cte("regional_sales")
)


top_regions = (
    select(regional_sales.c.region)
    .where(
        regional_sales.c.total_sales
        > select(func.sum(regional_sales.c.total_sales) / 10)
    )
    .cte("top_regions")
)

statement = (
    select(
        orders.c.region,
        orders.c.product,
        func.sum(orders.c.quantity).label("product_units"),
        func.sum(orders.c.amount).label("product_sales"),
    )
    .where(orders.c.region.in_(select(top_regions.c.region)))
    .group_by(orders.c.region, orders.c.product)
)

result = conn.execute(statement).fetchall()

Beispiel 2, WITH RECURSIVE

from sqlalchemy import (
    Table,
    Column,
    String,
    Integer,
    MetaData,
    select,
    func,
)

metadata = MetaData()

parts = Table(
    "parts",
    metadata,
    Column("part", String),
    Column("sub_part", String),
    Column("quantity", Integer),
)

included_parts = (
    select(parts.c.sub_part, parts.c.part, parts.c.quantity)
    .where(parts.c.part == "our part")
    .cte(recursive=True)
)


incl_alias = included_parts.alias()
parts_alias = parts.alias()
included_parts = included_parts.union_all(
    select(
        parts_alias.c.sub_part, parts_alias.c.part, parts_alias.c.quantity
    ).where(parts_alias.c.part == incl_alias.c.sub_part)
)

statement = select(
    included_parts.c.sub_part,
    func.sum(included_parts.c.quantity).label("total_quantity"),
).group_by(included_parts.c.sub_part)

result = conn.execute(statement).fetchall()

Beispiel 3, ein Upsert mit UPDATE und INSERT mit CTEs

from datetime import date
from sqlalchemy import (
    MetaData,
    Table,
    Column,
    Integer,
    Date,
    select,
    literal,
    and_,
    exists,
)

metadata = MetaData()

visitors = Table(
    "visitors",
    metadata,
    Column("product_id", Integer, primary_key=True),
    Column("date", Date, primary_key=True),
    Column("count", Integer),
)

# add 5 visitors for the product_id == 1
product_id = 1
day = date.today()
count = 5

update_cte = (
    visitors.update()
    .where(
        and_(visitors.c.product_id == product_id, visitors.c.date == day)
    )
    .values(count=visitors.c.count + count)
    .returning(literal(1))
    .cte("update_cte")
)

upsert = visitors.insert().from_select(
    [visitors.c.product_id, visitors.c.date, visitors.c.count],
    select(literal(product_id), literal(day), literal(count)).where(
        ~exists(update_cte.select())
    ),
)

connection.execute(upsert)

Beispiel 4, Verschachtelte CTE (SQLAlchemy 1.4.24 und neuer)

value_a = select(literal("root").label("n")).cte("value_a")

# A nested CTE with the same name as the root one
value_a_nested = select(literal("nesting").label("n")).cte(
    "value_a", nesting=True
)

# Nesting CTEs takes ascendency locally
# over the CTEs at a higher level
value_b = select(value_a_nested.c.n).cte("value_b")

value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

Die obige Abfrage rendert die zweite CTE verschachtelt in die erste, wie unten mit Inline-Parametern dargestellt:

WITH
    value_a AS
        (SELECT 'root' AS n),
    value_b AS
        (WITH value_a AS
            (SELECT 'nesting' AS n)
        SELECT value_a.n AS n FROM value_a)
SELECT value_a.n AS a, value_b.n AS b
FROM value_a, value_b

Die gleiche CTE kann auch mit der Methode HasCTE.add_cte() wie folgt eingerichtet werden (SQLAlchemy 2.0 und neuer)

value_a = select(literal("root").label("n")).cte("value_a")

# A nested CTE with the same name as the root one
value_a_nested = select(literal("nesting").label("n")).cte("value_a")

# Nesting CTEs takes ascendency locally
# over the CTEs at a higher level
value_b = (
    select(value_a_nested.c.n)
    .add_cte(value_a_nested, nest_here=True)
    .cte("value_b")
)

value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

Beispiel 5, Nicht-lineare CTE (SQLAlchemy 1.4.28 und neuer)

edge = Table(
    "edge",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("left", Integer),
    Column("right", Integer),
)

root_node = select(literal(1).label("node")).cte("nodes", recursive=True)

left_edge = select(edge.c.left).join(
    root_node, edge.c.right == root_node.c.node
)
right_edge = select(edge.c.right).join(
    root_node, edge.c.left == root_node.c.node
)

subgraph_cte = root_node.union(left_edge, right_edge)

subgraph = select(subgraph_cte)

Die obige Abfrage rendert 2 UNIONs innerhalb der rekursiven CTE

WITH RECURSIVE nodes(node) AS (
        SELECT 1 AS node
    UNION
        SELECT edge."left" AS "left"
        FROM edge JOIN nodes ON edge."right" = nodes.node
    UNION
        SELECT edge."right" AS "right"
        FROM edge JOIN nodes ON edge."left" = nodes.node
)
SELECT nodes.node FROM nodes

Siehe auch

Query.cte() - ORM-Version von HasCTE.cte().

class sqlalchemy.sql.expression.HasPrefixes¶

Mitglieder

prefix_with()

method sqlalchemy.sql.expression.HasPrefixes.prefix_with(*prefixes: _TextCoercedExpressionArgument[Any], dialect: str = '*') → Self¶

Fügt einen oder mehrere Ausdrücke nach dem Statement-Schlüsselwort, d.h. SELECT, INSERT, UPDATE oder DELETE, hinzu. Generativ.

Dies wird verwendet, um Backend-spezifische Präfix-Schlüsselwörter zu unterstützen, wie sie von MySQL bereitgestellt werden.

Z. B.

stmt = table.insert().prefix_with("LOW_PRIORITY", dialect="mysql")

# MySQL 5.7 optimizer hints
stmt = select(table).prefix_with("/*+ BKA(t1) */", dialect="mysql")

Mehrere Präfixe können durch mehrmaliges Aufrufen von HasPrefixes.prefix_with() angegeben werden.

Parameter:

*prefixes¶ – textlicher oder ClauseElement-Konstrukt, das nach dem INSERT-, UPDATE- oder DELETE-Schlüsselwort gerendert wird.
dialect¶ – optionaler String-Dialektname, der das Rendern dieses Präfixes auf diesen Dialekt beschränkt.

class sqlalchemy.sql.expression.HasSuffixes¶

Mitglieder

suffix_with()

method sqlalchemy.sql.expression.HasSuffixes.suffix_with(*suffixes: _TextCoercedExpressionArgument[Any], dialect: str = '*') → Self¶

Fügt einen oder mehrere Ausdrücke nach dem gesamten Statement hinzu.

Dies wird verwendet, um Backend-spezifische Suffix-Schlüsselwörter für bestimmte Konstrukte zu unterstützen.

Z. B.

stmt = (
    select(col1, col2)
    .cte()
    .suffix_with(
        "cycle empno set y_cycle to 1 default 0", dialect="oracle"
    )
)

Mehrere Suffixe können durch mehrmaliges Aufrufen von HasSuffixes.suffix_with() angegeben werden.

Parameter:

*suffixes¶ – textlicher oder ClauseElement-Konstrukt, das nach der Zielklausel gerendert wird.
dialect¶ – Optionaler String-Dialektname, der das Rendern dieses Suffixes auf diesen Dialekt beschränkt.

class sqlalchemy.sql.expression.Join¶

Repräsentiert eine JOIN Konstruktion zwischen zwei FromClause Elementen.

Die öffentliche Konstruktorfunktion für Join ist die Modul-Funktion join() sowie die Methode FromClause.join() jedes FromClause (z.B. einer Table).

Siehe auch

join()

FromClause.join()

Mitglieder

__init__(), description, is_derived_from(), select(), self_group()

Klassensignatur

class sqlalchemy.sql.expression.Join (sqlalchemy.sql.roles.DMLTableRole, sqlalchemy.sql.expression.FromClause)

method sqlalchemy.sql.expression.Join.__init__(left: _FromClauseArgument, right: _FromClauseArgument, onclause: _OnClauseArgument | None = None, isouter: bool = False, full: bool = False)¶

Erzeugt ein neues Join.

Der übliche Einstiegspunkt hier ist die Funktion join() oder die Methode FromClause.join() eines beliebigen FromClause-Objekts.

attribute sqlalchemy.sql.expression.Join.description¶

method sqlalchemy.sql.expression.Join.is_derived_from(fromclause: FromClause | None) → bool¶

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

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

method sqlalchemy.sql.expression.Join.select() → Select¶

Erstellt eine Select aus diesem Join.

Z. B.

stmt = table_a.join(table_b, table_a.c.id == table_b.c.a_id)

stmt = stmt.select()

Das obige erzeugt einen SQL-String, der ungefähr so aussieht:

SELECT table_a.id, table_a.col, table_b.id, table_b.a_id
FROM table_a JOIN table_b ON table_a.id = table_b.a_id

method sqlalchemy.sql.expression.Join.self_group(against: OperatorType | None = None) → FromGrouping¶

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 selbst bereitzustellen, wenn sie in einen größeren Ausdruck platziert werden, sowie von select()-Konstrukten, wenn sie in die FROM-Klausel eines anderen select() platziert werden. (Beachten Sie, dass Unterabfragen normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen verschachtelte SELECT-Anweisungen benennen müssen).

Während Ausdrücke miteinander komponiert werden, ist die Anwendung von self_group() automatisch – Endbenutzercode sollte diese Methode niemals direkt verwenden müssen. Beachten Sie, dass die Klauselkonstrukte von SQLAlchemy die Operatorrangfolge berücksichtigen – daher sind Klammern möglicherweise nicht erforderlich, zum Beispiel in einem Ausdruck wie x OR (y AND z) – AND hat Vorrang vor OR.

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

class sqlalchemy.sql.expression.Lateral¶

Repräsentiert eine LATERAL Unterabfrage.

Dieses Objekt wird aus der Modul-Funktion lateral() sowie der Methode FromClause.lateral() konstruiert, die auf allen Unterklassen von FromClause verfügbar ist.

Obwohl LATERAL Teil des SQL-Standards ist, bieten derzeit nur neuere PostgreSQL-Versionen Unterstützung für dieses Schlüsselwort.

Siehe auch

LATERAL Korrelation - Überblick über die Nutzung.

Mitglieder

inherit_cache

Klassensignatur

class sqlalchemy.sql.expression.Lateral (sqlalchemy.sql.expression.FromClauseAlias, sqlalchemy.sql.expression.LateralFromClause)

attribute sqlalchemy.sql.expression.Lateral.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.

class sqlalchemy.sql.expression.ReturnsRows¶

Die unterste Basisklasse für Core-Konstrukte, die eine gewisse Vorstellung von Spalten haben, die Zeilen darstellen können.

Während SELECT-Statements und TABLE die primären Dinge sind, die wir in dieser Kategorie betrachten, können DMLs wie INSERT, UPDATE und DELETE auch RETURNING spezifizieren, was bedeutet, dass sie in CTEs und anderen Formen verwendet werden können, und PostgreSQL hat auch Funktionen, die Zeilen zurückgeben.

Neu in Version 1.4.

Mitglieder

Klassensignatur

class sqlalchemy.sql.expression.ReturnsRows (sqlalchemy.sql.roles.ReturnsRowsRole, sqlalchemy.sql.expression.DQLDMLClauseElement)

attribute sqlalchemy.sql.expression.ReturnsRows.exported_columns¶

Eine ColumnCollection, die die „exportierten“ Spalten dieses ReturnsRows repräsentiert.

Die „exportierten“ Spalten repräsentieren die Sammlung von ColumnElement-Ausdrücken, die von diesem SQL-Konstrukt gerendert werden. Es gibt primäre Varianten, die die „FROM-Klausel-Spalten“ einer FROM-Klausel sind, wie eine Tabelle, ein Join oder eine Unterabfrage, die „ausgewählten Spalten“, die die Spalten in der „Spaltenklausel“ eines SELECT-Statements sind, und die RETURNING-Spalten in einem DML-Statement.

Neu in Version 1.4.

Siehe auch

SelectBase.scalar_subquery()

method sqlalchemy.sql.expression.ReturnsRows.is_derived_from(fromclause: FromClause | None) → bool¶

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

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

class sqlalchemy.sql.expression.ScalarSelect¶

Repräsentiert eine skalare Unterabfrage.

Ein ScalarSelect wird durch Aufrufen der Methode SelectBase.scalar_subquery() erstellt. Das Objekt nimmt dann an anderen SQL-Ausdrücken als SQL-Spaltenausdruck innerhalb der ColumnElement-Hierarchie teil.

Siehe auch

Skalare und korrelierte Unterabfragen - im 2.0 Tutorial

Mitglieder

correlate(), correlate_except(), inherit_cache, self_group(), where()

Klassensignatur

class sqlalchemy.sql.expression.ScalarSelect (sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.GroupedElement, sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.ScalarSelect.correlate(*fromclauses: Literal[None, False] | _FromClauseArgument) → Self¶

Gibt einen neuen ScalarSelect zurück, der die angegebenen FROM-Klauseln mit denen eines umschließenden Select korreliert.

Diese Methode wird von der Select.correlate() Methode der zugrundeliegenden Select gespiegelt. Die Methode wendet die :meth:_sql.Select.correlate` Methode an und gibt dann eine neue ScalarSelect für diese Anweisung zurück.

Neu in Version 1.4: Zuvor war die Methode ScalarSelect.correlate() nur von Select aus verfügbar.

Parameter:: *fromclauses¶ – eine Liste von einem oder mehreren FromClause Konstrukten oder anderen kompatiblen Konstrukten (d.h. ORM-gemappten Klassen), die Teil der korrelierten Sammlung werden sollen.

Siehe auch

ScalarSelect.correlate_except()

Skalare und korrelierte Unterabfragen - im 2.0 Tutorial

methode sqlalchemy.sql.expression.ScalarSelect.correlate_except(*fromclauses: Literal[None, False] | _FromClauseArgument) → Self¶

Gibt eine neue ScalarSelect zurück, die die angegebenen FROM-Klauseln vom automatischen Korrelationsprozess ausschließt.

Diese Methode wird von der Select.correlate_except() Methode der zugrundeliegenden Select gespiegelt. Die Methode wendet die :meth:_sql.Select.correlate_except` Methode an und gibt dann eine neue ScalarSelect für diese Anweisung zurück.

Neu in Version 1.4: Zuvor war die Methode ScalarSelect.correlate_except() nur von Select aus verfügbar.

Parameter:: *fromclauses¶ – eine Liste von einem oder mehreren FromClause Konstrukten oder anderen kompatiblen Konstrukten (d.h. ORM-gemappten Klassen), die Teil der Korrelations-Ausschluss-Sammlung werden sollen.

Siehe auch

ScalarSelect.correlate()

Skalare und korrelierte Unterabfragen - im 2.0 Tutorial

attribut sqlalchemy.sql.expression.ScalarSelect.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.sql.expression.ScalarSelect.self_group(against: OperatorType | None = None) → Self¶

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 selbst bereitzustellen, wenn sie in einen größeren Ausdruck platziert werden, sowie von select()-Konstrukten, wenn sie in die FROM-Klausel eines anderen select() platziert werden. (Beachten Sie, dass Unterabfragen normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen verschachtelte SELECT-Anweisungen benennen müssen).

Beim Zusammenfügen von Ausdrücken erfolgt die Anwendung von self_group() automatisch – der Endbenutzer muss diese Methode niemals direkt verwenden. Beachten Sie, dass die Klauselkonstrukte von SQLAlchemy die Operatorrangfolge berücksichtigen – Klammern sind daher möglicherweise nicht erforderlich, z.B. in einem Ausdruck wie x OR (y AND z) – AND hat Vorrang vor OR.

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

methode sqlalchemy.sql.expression.ScalarSelect.where(crit: _ColumnExpressionArgument[bool]) → Self¶: Wendet eine WHERE-Klausel auf die SELECT-Anweisung an, auf die sich diese ScalarSelect bezieht.

klasse sqlalchemy.sql.expression.Select¶

Repräsentiert eine SELECT Anweisung.

Das Objekt Select wird normalerweise mit der Funktion select() konstruiert. Details finden Sie in dieser Funktion.

Siehe auch

select()

Verwendung von SELECT-Anweisungen - im 2.0 Tutorial

Mitglieder

__init__(), add_columns(), add_cte(), alias(), as_scalar(), c, column(), column_descriptions, columns_clause_froms, correlate(), correlate_except(), corresponding_column(), cte(), distinct(), except_(), except_all(), execution_options(), exists(), exported_columns, fetch(), filter(), filter_by(), from_statement(), froms, get_children(), get_execution_options(), get_final_froms(), get_label_style(), group_by(), having(), inherit_cache, inner_columns, intersect(), intersect_all(), is_derived_from(), join(), join_from(), label(), lateral(), limit(), offset(), options(), order_by(), outerjoin(), outerjoin_from(), prefix_with(), reduce_columns(), replace_selectable(), scalar_subquery(), select(), select_from(), selected_columns, self_group(), set_label_style(), slice(), subquery(), suffix_with(), union(), union_all(), where(), whereclause, with_for_update(), with_hint(), with_only_columns(), with_statement_hint()

Klassensignatur

klasse sqlalchemy.sql.expression.Select (sqlalchemy.sql.expression.HasPrefixes, sqlalchemy.sql.expression.HasSuffixes, sqlalchemy.sql.expression.HasHints, sqlalchemy.sql.expression.HasCompileState, sqlalchemy.sql.expression._SelectFromElements, sqlalchemy.sql.expression.GenerativeSelect, sqlalchemy.sql.expression.TypedReturnsRows)

methode sqlalchemy.sql.expression.Select.__init__(*entities: _ColumnsClauseArgument[Any])¶

Konstruiert ein neues Select.

Der öffentliche Konstruktor für Select ist die Funktion select().

methode sqlalchemy.sql.expression.Select.add_columns(*entities: _ColumnsClauseArgument[Any]) → Select[Any]¶

Gibt einen neuen select() Konstrukt zurück, bei dem die angegebenen Entitäten an die Spaltenklausel angehängt werden.

Z. B.

my_select = my_select.add_columns(table.c.new_column)

Die ursprünglichen Ausdrücke in der Spaltenklausel bleiben erhalten. Um die ursprünglichen Ausdrücke durch neue zu ersetzen, siehe die Methode Select.with_only_columns().

Parameter:: *entities¶ – Spalten-, Tabellen- oder andere Entitätsausdrücke, die der Spaltenklausel hinzugefügt werden sollen

Siehe auch

Select.with_only_columns() - ersetzt bestehende Ausdrücke anstatt anzuhängen.

Gleichzeitige Auswahl mehrerer ORM-Entitäten - ORM-zentriertes Beispiel

methode sqlalchemy.sql.expression.Select.add_cte(*ctes: CTE, nest_here: bool = False) → Self¶

geerbt von der HasCTE.add_cte() Methode von HasCTE

Fügt eine oder mehrere CTE Konstrukte zu dieser Anweisung hinzu.

Diese Methode ordnet die gegebenen CTE Konstrukte der übergeordneten Anweisung zu, sodass sie alle bedingungslos in der WITH-Klausel der endgültigen Anweisung gerendert werden, auch wenn sie woanders in der Anweisung oder in Unterabfragen nicht referenziert werden.

Der optionale Parameter HasCTE.add_cte.nest_here hat, wenn er auf True gesetzt ist, den Effekt, dass jede gegebene CTE in einer WITH-Klausel gerendert wird, die direkt mit dieser Anweisung gerendert wird, anstatt an den Anfang der endgültigen gerenderten Anweisung verschoben zu werden, auch wenn diese Anweisung als Unterabfrage innerhalb einer größeren Anweisung gerendert wird.

Diese Methode hat zwei allgemeine Anwendungsfälle. Einer ist das Einbetten von CTE-Anweisungen, die ohne explizite Referenzierung einen Zweck erfüllen, wie z. B. das Einbetten einer DML-Anweisung wie INSERT oder UPDATE als CTE inline mit einer Hauptanweisung, die indirekt aus ihren Ergebnissen schöpfen kann. Der andere ist die Steuerung der exakten Platzierung einer bestimmten Reihe von CTE-Konstrukten, die direkt in Bezug auf eine bestimmte Anweisung gerendert werden sollen, die in einer größeren Anweisung verschachtelt sein kann.

Z. B.

from sqlalchemy import table, column, select

t = table("t", column("c1"), column("c2"))

ins = t.insert().values({"c1": "x", "c2": "y"}).cte()

stmt = select(t).add_cte(ins)

Würde rendern

WITH anon_1 AS (
    INSERT INTO t (c1, c2) VALUES (:param_1, :param_2)
)
SELECT t.c1, t.c2
FROM t

Oben ist die CTE „anon_1“ nicht in der SELECT-Anweisung referenziert, erfüllt aber dennoch die Aufgabe, eine INSERT-Anweisung auszuführen.

Ähnlich in einem DML-bezogenen Kontext, unter Verwendung des PostgreSQL Insert Konstrukts zur Generierung eines „Upsert“.

from sqlalchemy import table, column
from sqlalchemy.dialects.postgresql import insert

t = table("t", column("c1"), column("c2"))

delete_statement_cte = t.delete().where(t.c.c1 < 1).cte("deletions")

insert_stmt = insert(t).values({"c1": 1, "c2": 2})
update_statement = insert_stmt.on_conflict_do_update(
    index_elements=[t.c.c1],
    set_={
        "c1": insert_stmt.excluded.c1,
        "c2": insert_stmt.excluded.c2,
    },
).add_cte(delete_statement_cte)

print(update_statement)

Die obige Anweisung wird gerendert als

WITH deletions AS (
    DELETE FROM t WHERE t.c1 < %(c1_1)s
)
INSERT INTO t (c1, c2) VALUES (%(c1)s, %(c2)s)
ON CONFLICT (c1) DO UPDATE SET c1 = excluded.c1, c2 = excluded.c2

Neu in Version 1.4.21.

Parameter:

*ctes¶ –
null oder mehr CTE Konstrukte.

Geändert in Version 2.0: Mehrere CTE-Instanzen werden akzeptiert
nest_here¶ –
Wenn True, werden die gegebenen CTEs so gerendert, als würden sie das Flag HasCTE.cte.nesting auf True setzen, wenn sie zu diesem HasCTE hinzugefügt wurden. Unter der Annahme, dass die gegebenen CTEs nicht auch in einer äußeren umgebenden Anweisung referenziert werden, sollten die gegebenen CTEs auf der Ebene dieser Anweisung gerendert werden, wenn dieses Flag gesetzt ist.

Neu in Version 2.0.

Siehe auch

HasCTE.cte.nesting

methode sqlalchemy.sql.expression.Select.alias(name: str | None = None, flat: bool = False) → Subquery¶

geerbt von der SelectBase.alias() Methode von SelectBase

Gibt eine benannte Unterabfrage für diese SelectBase zurück.

Für eine SelectBase (im Gegensatz zu einer FromClause) gibt dies ein Subquery Objekt zurück, das sich größtenteils genauso verhält wie das Alias Objekt, das mit einer FromClause verwendet wird.

Geändert in Version 1.4: Die Methode SelectBase.alias() ist nun ein Synonym für die Methode SelectBase.subquery().

methode sqlalchemy.sql.expression.Select.as_scalar() → ScalarSelect[Any]¶: geerbt von der SelectBase.as_scalar() Methode von SelectBase

Veraltet seit Version 1.4: Die Methode SelectBase.as_scalar() ist veraltet und wird in einer zukünftigen Version entfernt. Bitte siehe SelectBase.scalar_subquery().

attribut sqlalchemy.sql.expression.Select.c¶: geerbt von der SelectBase.c Attribut von SelectBase

Veraltet seit Version 1.4: Die Attribute SelectBase.c und SelectBase.columns sind veraltet und werden in einer zukünftigen Version entfernt; diese Attribute erstellen implizit eine Unterabfrage, die explizit sein sollte. Bitte rufen Sie zuerst SelectBase.subquery() auf, um eine Unterabfrage zu erstellen, die dann dieses Attribut enthält. Um auf die Spalten zuzugreifen, die dieses SELECT-Objekt auswählt, verwenden Sie das Attribut SelectBase.selected_columns.

methode sqlalchemy.sql.expression.Select.column(column: _ColumnsClauseArgument[Any]) → Select[Any]¶

Gibt einen neuen select() Konstrukt zurück, bei dem der angegebene Spaltenausdruck an seine Spaltenklausel angehängt wird.

Veraltet seit Version 1.4: Die Methode Select.column() ist veraltet und wird in einer zukünftigen Version entfernt. Bitte verwenden Sie Select.add_columns().

Z. B.

my_select = my_select.column(table.c.new_column)

Siehe die Dokumentation für Select.with_only_columns() für Richtlinien zum Hinzufügen / Ersetzen der Spalten eines Select Objekts.

attribut sqlalchemy.sql.expression.Select.column_descriptions¶

Gibt eine plugin-fähige 'Spaltenbeschreibungs'-Struktur zurück, die sich auf die Spalten bezieht, die von dieser Anweisung SELECTiert werden.

Dieses Attribut ist generell nützlich, wenn das ORM verwendet wird, da eine erweiterte Struktur zurückgegeben wird, die Informationen über gemappte Entitäten enthält. Der Abschnitt Entitäten und Spalten aus ORM-fähigen SELECT- und DML-Anweisungen inspizieren enthält weitere Hintergründe.

Für eine reine Core-Anweisung leitet sich die von diesem Accessor zurückgegebene Struktur von denselben Objekten ab, die vom Accessor Select.selected_columns zurückgegeben werden, formatiert als Liste von Dictionaries, die die Schlüssel name, type und expr enthalten, welche die zu SELECTierenden Spaltenausdrücke angeben.

>>> stmt = select(user_table)
>>> stmt.column_descriptions
[
    {
        'name': 'id',
        'type': Integer(),
        'expr': Column('id', Integer(), ...)},
    {
        'name': 'name',
        'type': String(length=30),
        'expr': Column('name', String(length=30), ...)}
]

Geändert in Version 1.4.33: Das Attribut Select.column_descriptions gibt eine Struktur für eine reine Core-Entitätsmenge zurück, nicht nur für ORM-eigene Entitäten.

Siehe auch

UpdateBase.entity_description - Entitätsinformationen für ein insert(), update() oder delete()

Entitäten und Spalten aus ORM-fähigen SELECT- und DML-Anweisungen inspizieren - ORM-Hintergrund

attribut sqlalchemy.sql.expression.Select.columns_clause_froms¶: Gibt die Menge der FromClause Objekte zurück, die von der Spaltenklausel dieser SELECT-Anweisung impliziert werden.

Neu in Version 1.4.23.

Siehe auch

Select.froms - "endgültige" FROM-Liste unter Berücksichtigung der gesamten Anweisung

Select.with_only_columns() - verwendet diese Sammlung, um eine neue FROM-Liste einzurichten

methode sqlalchemy.sql.expression.Select.correlate(*fromclauses: Literal[None, False] | _FromClauseArgument) → Self¶

Gibt eine neue Select zurück, die die angegebenen FROM-Klauseln mit einer umschließenden Select korreliert.

Das Aufrufen dieser Methode deaktiviert das Standardverhalten des Select Objekts zur "automatischen Korrelation". Normalerweise werden FROM-Elemente, die in einer Select erscheinen, die diese durch ihre WHERE-Klausel, ORDER BY, HAVING oder Spaltenklausel umschließt, aus der FROM-Klausel dieses Select Objekts weggelassen. Das Festlegen einer expliziten Korrelationssammlung mit der Methode Select.correlate() liefert eine feste Liste von FROM-Objekten, die potenziell an diesem Prozess teilnehmen können.

Wenn Select.correlate() verwendet wird, um spezifische FROM-Klauseln für die Korrelation anzuwenden, werden die FROM-Elemente zu Kandidaten für die Korrelation, unabhängig davon, wie tief diese Select Anweisung relativ zu einer umschließenden Select Anweisung verschachtelt ist, die auf dasselbe FROM-Objekt verweist. Dies steht im Gegensatz zum Verhalten der "automatischen Korrelation", die nur mit einer unmittelbar umschließenden Select korreliert. Mehrstufige Korrelation stellt sicher, dass die Verbindung zwischen umschlossenen und umschließenden Select Anweisungen immer über mindestens eine WHERE/ORDER BY/HAVING/Spaltenklausel erfolgt, damit die Korrelation stattfinden kann.

Wenn None übergeben wird, korreliert das Select-Objekt keine seiner FROM-Einträge, und alle werden bedingungslos in der lokalen FROM-Klausel gerendert.

Parameter:: *fromclauses¶ – ein oder mehrere FromClause-Objekte oder andere FROM-kompatible Konstrukte wie eine ORM-gemappte Entität, die Teil der Korrelationssammlung werden sollen; alternativ kann ein einzelner Wert None übergeben werden, um alle vorhandenen Korrelationen zu entfernen.

Siehe auch

Select.correlate_except()

Skalare und korrelierte Unterabfragen

methode sqlalchemy.sql.expression.Select.correlate_except(*fromclauses: Literal[None, False] | _FromClauseArgument) → Self¶

Gibt ein neues Select-Objekt zurück, das die angegebenen FROM-Klauseln vom automatischen Korrelationsprozess ausschließt.

Das Aufrufen von Select.correlate_except() schaltet das Standardverhalten des Select-Objekts der „Autokorrelation“ für die angegebenen FROM-Elemente ab. Ein hier angegebenes Element wird bedingungslos in der FROM-Liste erscheinen, während alle anderen FROM-Elemente den normalen Autokorrelationsverhalten unterliegen.

Wenn None übergeben wird oder keine Argumente übergeben werden, korreliert das Select-Objekt alle seine FROM-Einträge.

Parameter:: *fromclauses¶ – eine Liste von einem oder mehreren FromClause-Konstrukten oder anderen kompatiblen Konstrukten (d.h. ORM-gemappte Klassen), die Teil der Korrelationsausschluss-Sammlung werden.

Siehe auch

Select.correlate()

Skalare und korrelierte Unterabfragen

methode sqlalchemy.sql.expression.Select.corresponding_column(column: KeyedColumnElement[Any], require_embedded: bool = False) → KeyedColumnElement[Any] | None¶

geerbt von der Selectable.corresponding_column() Methode von Selectable

Gibt ein ColumnElement Objekt aus der Sammlung Selectable.exported_columns dieses Selectable zurück, das mit dem ursprünglichen ColumnElement über einen gemeinsamen Vorfahren korrespondiert.

Parameter:

column¶ – die Ziel-ColumnElement, die abgeglichen werden soll.
require_embedded¶ – gibt nur entsprechende Spalten für die angegebene ColumnElement zurück, wenn die angegebene ColumnElement tatsächlich innerhalb eines Unterelements dieser Selectable vorhanden ist. Normalerweise stimmt die Spalte überein, wenn sie lediglich einen gemeinsamen Vorfahren 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.sql.expression.Select.cte(name: str | None = None, recursive: bool = False, nesting: bool = False) → CTE¶

geerbt von der HasCTE.cte() Methode von HasCTE

Gibt eine neue CTE oder Common Table Expression Instanz zurück.

Gemeinsame Tabellenausdrücke sind ein SQL-Standard, bei dem SELECT-Anweisungen auf sekundäre Anweisungen zurückgreifen können, die zusammen mit der Hauptanweisung angegeben werden, und zwar mit einer Klausel namens „WITH“. Spezielle Semantiken bezüglich UNION können ebenfalls angewendet werden, um „rekursive“ Abfragen zu ermöglichen, bei denen eine SELECT-Anweisung auf die Zeilenmenge zurückgreifen kann, die zuvor ausgewählt wurden.

CTEs können auch auf DML-Konstrukte UPDATE, INSERT und DELETE auf einigen Datenbanken angewendet werden, sowohl als Quelle von CTE-Zeilen in Kombination mit RETURNING als auch als Konsument von CTE-Zeilen.

SQLAlchemy erkennt CTE Objekte, die ähnlich wie Alias Objekte behandelt werden, als spezielle Elemente, die sowohl der FROM-Klausel der Anweisung als auch einer WITH-Klausel am Anfang der Anweisung geliefert werden.

Für spezielle Präfixe wie PostgreSQL „MATERIALIZED“ und „NOT MATERIALIZED“ kann die Methode CTE.prefix_with() verwendet werden, um diese zu etablieren.

Geändert in Version 1.3.13: Unterstützung für Präfixe hinzugefügt. Insbesondere – MATERIALIZED und NOT MATERIALIZED.

Parameter:

name¶ – Name, der dem Common Table Expression zugewiesen wird. Ähnlich wie bei FromClause.alias() kann der Name als None belassen werden, in diesem Fall wird zur Compile-Zeit des Abfrage ein anonymes Symbol verwendet.
recursive¶ – Wenn True, wird WITH RECURSIVE gerendert. Ein rekursiver Common Table Expression ist zur Verwendung in Verbindung mit UNION ALL bestimmt, um Zeilen aus bereits ausgewählten abzuleiten.
nesting¶ –
Wenn True, wird die CTE lokal für die Anweisung gerendert, in der sie referenziert wird. Für komplexere Szenarien kann die Methode HasCTE.add_cte() mit dem Parameter HasCTE.add_cte.nest_here verwendet werden, um die genaue Platzierung einer bestimmten CTE genauer zu steuern.

Neu in Version 1.4.24.

Siehe auch

HasCTE.add_cte()

Die folgenden Beispiele enthalten zwei aus der PostgreSQL-Dokumentation unter https://www.postgresql.org/docs/current/static/queries-with.html sowie zusätzliche Beispiele.

Beispiel 1, nicht rekursiv

from sqlalchemy import (
    Table,
    Column,
    String,
    Integer,
    MetaData,
    select,
    func,
)

metadata = MetaData()

orders = Table(
    "orders",
    metadata,
    Column("region", String),
    Column("amount", Integer),
    Column("product", String),
    Column("quantity", Integer),
)

regional_sales = (
    select(orders.c.region, func.sum(orders.c.amount).label("total_sales"))
    .group_by(orders.c.region)
    .cte("regional_sales")
)


top_regions = (
    select(regional_sales.c.region)
    .where(
        regional_sales.c.total_sales
        > select(func.sum(regional_sales.c.total_sales) / 10)
    )
    .cte("top_regions")
)

statement = (
    select(
        orders.c.region,
        orders.c.product,
        func.sum(orders.c.quantity).label("product_units"),
        func.sum(orders.c.amount).label("product_sales"),
    )
    .where(orders.c.region.in_(select(top_regions.c.region)))
    .group_by(orders.c.region, orders.c.product)
)

result = conn.execute(statement).fetchall()

Beispiel 2, WITH RECURSIVE

from sqlalchemy import (
    Table,
    Column,
    String,
    Integer,
    MetaData,
    select,
    func,
)

metadata = MetaData()

parts = Table(
    "parts",
    metadata,
    Column("part", String),
    Column("sub_part", String),
    Column("quantity", Integer),
)

included_parts = (
    select(parts.c.sub_part, parts.c.part, parts.c.quantity)
    .where(parts.c.part == "our part")
    .cte(recursive=True)
)


incl_alias = included_parts.alias()
parts_alias = parts.alias()
included_parts = included_parts.union_all(
    select(
        parts_alias.c.sub_part, parts_alias.c.part, parts_alias.c.quantity
    ).where(parts_alias.c.part == incl_alias.c.sub_part)
)

statement = select(
    included_parts.c.sub_part,
    func.sum(included_parts.c.quantity).label("total_quantity"),
).group_by(included_parts.c.sub_part)

result = conn.execute(statement).fetchall()

Beispiel 3, ein Upsert mit UPDATE und INSERT mit CTEs

from datetime import date
from sqlalchemy import (
    MetaData,
    Table,
    Column,
    Integer,
    Date,
    select,
    literal,
    and_,
    exists,
)

metadata = MetaData()

visitors = Table(
    "visitors",
    metadata,
    Column("product_id", Integer, primary_key=True),
    Column("date", Date, primary_key=True),
    Column("count", Integer),
)

# add 5 visitors for the product_id == 1
product_id = 1
day = date.today()
count = 5

update_cte = (
    visitors.update()
    .where(
        and_(visitors.c.product_id == product_id, visitors.c.date == day)
    )
    .values(count=visitors.c.count + count)
    .returning(literal(1))
    .cte("update_cte")
)

upsert = visitors.insert().from_select(
    [visitors.c.product_id, visitors.c.date, visitors.c.count],
    select(literal(product_id), literal(day), literal(count)).where(
        ~exists(update_cte.select())
    ),
)

connection.execute(upsert)

Beispiel 4, Verschachtelte CTE (SQLAlchemy 1.4.24 und neuer)

value_a = select(literal("root").label("n")).cte("value_a")

# A nested CTE with the same name as the root one
value_a_nested = select(literal("nesting").label("n")).cte(
    "value_a", nesting=True
)

# Nesting CTEs takes ascendency locally
# over the CTEs at a higher level
value_b = select(value_a_nested.c.n).cte("value_b")

value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

Die obige Abfrage rendert die zweite CTE verschachtelt in die erste, wie unten mit Inline-Parametern dargestellt:

WITH
    value_a AS
        (SELECT 'root' AS n),
    value_b AS
        (WITH value_a AS
            (SELECT 'nesting' AS n)
        SELECT value_a.n AS n FROM value_a)
SELECT value_a.n AS a, value_b.n AS b
FROM value_a, value_b

Die gleiche CTE kann auch mit der Methode HasCTE.add_cte() wie folgt eingerichtet werden (SQLAlchemy 2.0 und neuer)

value_a = select(literal("root").label("n")).cte("value_a")

# A nested CTE with the same name as the root one
value_a_nested = select(literal("nesting").label("n")).cte("value_a")

# Nesting CTEs takes ascendency locally
# over the CTEs at a higher level
value_b = (
    select(value_a_nested.c.n)
    .add_cte(value_a_nested, nest_here=True)
    .cte("value_b")
)

value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

Beispiel 5, Nicht-lineare CTE (SQLAlchemy 1.4.28 und neuer)

edge = Table(
    "edge",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("left", Integer),
    Column("right", Integer),
)

root_node = select(literal(1).label("node")).cte("nodes", recursive=True)

left_edge = select(edge.c.left).join(
    root_node, edge.c.right == root_node.c.node
)
right_edge = select(edge.c.right).join(
    root_node, edge.c.left == root_node.c.node
)

subgraph_cte = root_node.union(left_edge, right_edge)

subgraph = select(subgraph_cte)

Die obige Abfrage rendert 2 UNIONs innerhalb der rekursiven CTE

WITH RECURSIVE nodes(node) AS (
        SELECT 1 AS node
    UNION
        SELECT edge."left" AS "left"
        FROM edge JOIN nodes ON edge."right" = nodes.node
    UNION
        SELECT edge."right" AS "right"
        FROM edge JOIN nodes ON edge."left" = nodes.node
)
SELECT nodes.node FROM nodes

Siehe auch

Query.cte() - ORM-Version von HasCTE.cte().

methode sqlalchemy.sql.expression.Select.distinct(*expr: _ColumnExpressionArgument[Any]) → Self¶

Gibt eine neue select()-Konstruktion zurück, die DISTINCT auf die gesamte SELECT-Anweisung anwendet.

Z. B.

from sqlalchemy import select

stmt = select(users_table.c.id, users_table.c.name).distinct()

Das Obige würde eine Anweisung ergeben, die der folgenden ähnelt

SELECT DISTINCT user.id, user.name FROM user

Die Methode akzeptiert auch einen *expr Parameter, der den PostgreSQL-dialektspezifischen DISTINCT ON Ausdruck erzeugt. Die Verwendung dieses Parameters auf anderen Backends, die diese Syntax nicht unterstützen, löst einen Fehler aus.

Parameter:

*expr¶ –

optionale Spaltenausdrücke. Wenn vorhanden, rendert der PostgreSQL-Dialekt eine DISTINCT ON (<expressions>)-Konstruktion. Eine Deprecation-Warnung und/oder eine CompileError werden auf anderen Backends ausgelöst.

Deprecated since version 1.4: Die Verwendung von *expr in anderen Dialekten ist veraltet und löst in einer zukünftigen Version eine CompileError aus.

methode sqlalchemy.sql.expression.Select.except_(*other: _SelectStatementForCompoundArgument[_TP]) → CompoundSelect[_TP]¶

Gibt eine SQL EXCEPT-Konstruktion dieses select()-Konstrukts gegen die als Positionsargumente bereitgestellten wählbaren Elemente zurück.

Parameter:

*other¶ –

ein oder mehrere Elemente, aus denen eine UNION erstellt werden soll.

Geändert in Version 1.4.28: Mehrere Elemente werden jetzt akzeptiert.

methode sqlalchemy.sql.expression.Select.except_all(*other: _SelectStatementForCompoundArgument[_TP]) → CompoundSelect[_TP]¶

Gibt eine SQL EXCEPT ALL-Konstruktion dieses select()-Konstrukts gegen die als Positionsargumente bereitgestellten wählbaren Elemente zurück.

Parameter:

*other¶ –

ein oder mehrere Elemente, aus denen eine UNION erstellt werden soll.

Geändert in Version 1.4.28: Mehrere Elemente werden jetzt akzeptiert.

methode sqlalchemy.sql.expression.Select.execution_options(**kw: Any) → Self¶

geerbt von der Executable.execution_options() Methode von Executable

Setzt Nicht-SQL-Optionen für die Anweisung, die während der Ausführung wirksam werden.

Ausführungsoptionen können auf verschiedenen Ebenen gesetzt werden, einschließlich pro Anweisung, pro Verbindung oder pro Ausführung, unter Verwendung von Methoden wie Connection.execution_options() und Parametern, die ein Dictionary von Optionen akzeptieren, wie z.B. Connection.execute.execution_options und Session.execute.execution_options.

Das Hauptmerkmal einer Ausführungsoption, im Gegensatz zu anderen Arten von Optionen wie ORM-Laderoptionen, ist, dass **Ausführungsoptionen niemals die kompilierte SQL einer Abfrage beeinflussen, sondern nur Dinge, die beeinflussen, wie die SQL-Anweisung selbst aufgerufen wird oder wie Ergebnisse abgerufen werden**. Das heißt, Ausführungsoptionen sind kein Teil dessen, was durch die SQL-Kompilierung abgedeckt wird, noch gelten sie als Teil des Cache-Zustands einer Anweisung.

Die Methode Executable.execution_options() ist generativ, wie auch die Methode, die auf die Engine und Query Objekte angewendet wird, was bedeutet, dass beim Aufruf der Methode eine Kopie des Objekts zurückgegeben wird, die die gegebenen Parameter auf diese neue Kopie anwendet, aber das Original unverändert lässt

statement = select(table.c.x, table.c.y)
new_statement = statement.execution_options(my_option=True)

Eine Ausnahme von diesem Verhalten ist das Connection-Objekt, bei dem die Methode Connection.execution_options() ausdrücklich **nicht** generativ ist.

Die Arten von Optionen, die an Executable.execution_options() und andere verwandte Methoden und Parameter-Dictionaries übergeben werden können, umfassen Parameter, die explizit von SQLAlchemy Core oder ORM konsumiert werden, sowie beliebige Schlüsselwortargumente, die nicht von SQLAlchemy definiert sind. Dies bedeutet, dass die Methoden und/oder Parameter-Dictionaries für benutzerdefinierte Parameter verwendet werden können, die mit benutzerdefiniertem Code interagieren, der auf die Parameter über Methoden wie Executable.get_execution_options() und Connection.get_execution_options() zugreifen kann, oder innerhalb ausgewählter Event-Hooks unter Verwendung eines dedizierten execution_options-Event-Parameters wie ConnectionEvents.before_execute.execution_options oder ORMExecuteState.execution_options, z. B.

from sqlalchemy import event


@event.listens_for(some_engine, "before_execute")
def _process_opt(conn, statement, multiparams, params, execution_options):
    "run a SQL function before invoking a statement"

    if execution_options.get("do_special_thing", False):
        conn.exec_driver_sql("run_special_function()")

Innerhalb des Bereichs von Optionen, die von SQLAlchemy explizit erkannt werden, gelten die meisten für bestimmte Klassen von Objekten und nicht für andere. Die gängigsten Ausführungsoptionen sind

Connection.execution_options.isolation_level - setzt die Isolationsebene für eine Verbindung oder eine Klasse von Verbindungen über eine Engine. Diese Option wird nur von Connection oder Engine akzeptiert.
Connection.execution_options.stream_results - gibt an, dass Ergebnisse mit einem serverseitigen Cursor abgerufen werden sollen; diese Option wird von Connection, vom Parameter Connection.execute.execution_options auf Connection.execute() und zusätzlich von Executable.execution_options() auf einem SQL-Anweisungsobjekt sowie von ORM-Konstrukten wie Session.execute() akzeptiert.
Connection.execution_options.compiled_cache - gibt ein Dictionary an, das als SQL-Kompilierungs-Cache für eine Connection oder Engine sowie für ORM-Methoden wie Session.execute() dient. Kann als None übergeben werden, um das Caching für Anweisungen zu deaktivieren. Diese Option wird nicht von Executable.execution_options() akzeptiert, da es nicht ratsam ist, einen Kompilierungs-Cache mit einem Anweisungsobjekt mitzuführen.
Connection.execution_options.schema_translate_map - eine Zuordnung von Schemanamen, die von der Schema Translate Map-Funktion verwendet wird, akzeptiert von Connection, Engine, Executable, sowie von ORM-Konstrukten wie Session.execute().

Siehe auch

ORM Ausführungsoptionen - Dokumentation zu allen ORM-spezifischen Ausführungsoptionen

methode sqlalchemy.sql.expression.Select.exists() → Exists¶

geerbt von der SelectBase.exists() Methode von SelectBase

Gibt eine Exists-Repräsentation dieses Selektierbaren zurück, die als Spaltenausdruck verwendet werden kann.

Das zurückgegebene Objekt ist eine Instanz von Exists.

Siehe auch

EXISTS-Unterabfragen – im 2.0-Stil-Tutorial.

Neu in Version 1.4.

attribut sqlalchemy.sql.expression.Select.exported_columns¶

geerbt von dem SelectBase.exported_columns Attribut von SelectBase

Eine ColumnCollection, die die „exportierten“ Spalten dieses Selectable darstellt, ohne TextClause-Konstrukte.

Die „exportierten“ Spalten für ein SelectBase-Objekt sind gleichbedeutend mit der SelectBase.selected_columns-Sammlung.

Neu in Version 1.4.

Siehe auch

methode sqlalchemy.sql.expression.Select.fetch(count: _LimitOffsetType, with_ties: bool = False, percent: bool = False) → Self¶

geerbt von der GenerativeSelect.fetch() Methode von GenerativeSelect

Gibt einen neuen Selektierbaren mit dem angegebenen FETCH FIRST-Kriterium zurück.

Dies ist ein numerischer Wert, der normalerweise als FETCH {FIRST | NEXT} [ count ] {ROW | ROWS} {ONLY | WITH TIES} Ausdruck in der resultierenden SELECT-Anweisung gerendert wird. Diese Funktionalität ist derzeit für Oracle Database, PostgreSQL, MSSQL implementiert.

Verwenden Sie GenerativeSelect.offset(), um den Offset anzugeben.

Hinweis

Die Methode GenerativeSelect.fetch() ersetzt jede mit GenerativeSelect.limit() angewendete Klausel.

Neu in Version 1.4.

Parameter:

count¶ – eine ganze Zahl COUNT, oder ein SQL-Ausdruck, der ein ganzzahliges Ergebnis liefert. Wenn percent=True ist, stellt dies den Prozentsatz der zurückzugebenden Zeilen dar, nicht den absoluten Wert. Übergeben Sie None, um ihn zurückzusetzen.
with_ties¶ – Wenn True, wird die Option WITH TIES verwendet, um zusätzliche Zeilen zurückzugeben, die beim letzten Platz im Ergebnis-Set gemäß der ORDER BY-Klausel gleichrangig sind. Die ORDER BY kann in diesem Fall obligatorisch sein. Standardmäßig False
percent¶ – Wenn True, repräsentiert count den Prozentsatz der gesamten ausgewählten Zeilen, die zurückgegeben werden sollen. Standardmäßig False

Siehe auch

Select.columns_clause_froms

methode sqlalchemy.sql.expression.Select.filter(*criteria: _ColumnExpressionArgument[bool]) → Self¶: Ein Synonym für die Methode Select.where().

methode sqlalchemy.sql.expression.Select.filter_by(**kwargs: Any) → Self¶: Wendet das angegebene Filterkriterium als WHERE-Klausel auf diese Auswahl an.

methode sqlalchemy.sql.expression.Select.from_statement(statement: ReturnsRowsRole) → ExecutableReturnsRows¶

Wendet die Spalten, die dieses Select-Objekt auswählen würde, auf eine andere Anweisung an.

Diese Operation ist pluginspezifisch und löst eine „nicht unterstützt“-Ausnahme aus, wenn diese Select nicht von Plugin-aktivierten Entitäten auswählt.

Die Anweisung ist typischerweise entweder eine text()- oder select()-Konstruktion und sollte die für die von dieser Select repräsentierten Entitäten geeignete Menge an Spalten zurückgeben.

Siehe auch

ORM-Ergebnisse aus textuellen Anweisungen abrufen - Anwendungsbeispiele im ORM-Abfrageleitfaden

attribut sqlalchemy.sql.expression.Select.froms¶: Gibt die angezeigte Liste der FromClause-Elemente zurück.

Deprecated since version 1.4.23: Das Attribut Select.froms wird zur Methode Select.get_final_froms() verschoben.

methode sqlalchemy.sql.expression.Select.get_children(**kw: Any) → Iterable[ClauseElement]¶

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.sql.expression.Select.get_execution_options() → _ExecuteOptions¶: geerbt von der Executable.get_execution_options() Methode von Executable

Ruft die nicht-SQL-Optionen ab, die während der Ausführung wirksam werden.

Neu in Version 1.3.

Siehe auch

Executable.execution_options()

methode sqlalchemy.sql.expression.Select.get_final_froms() → Sequence[FromClause]¶

Berechnet die endgültige angezeigte Liste der FromClause-Elemente.

Diese Methode führt die vollständige Berechnung durch, die erforderlich ist, um zu bestimmen, welche FROM-Elemente in der resultierenden SELECT-Anweisung angezeigt werden, einschließlich des Schattierens einzelner Tabellen mit JOIN-Objekten sowie der vollständigen Berechnung für ORM-Anwendungsfälle, einschließlich Eager Loading-Klauseln.

Für ORM-Zwecke gibt dieser Zugriff die **nach der Kompilierung** Liste der FROM-Objekte zurück; diese Sammlung enthält Elemente wie eifrig geladene Tabellen und Joins. Die Objekte sind **nicht** ORM-aktiviert und können nicht als Ersatz für die Select.select_froms()-Sammlung verwendet werden; darüber hinaus ist die Methode für eine ORM-aktivierte Anweisung nicht gut performant, da sie den vollständigen ORM-Konstruktionsprozess auslöst.

Um die FROM-Liste abzurufen, die durch die „Spalten“-Sammlung impliziert wird, die ursprünglich an das Select übergeben wurde, verwenden Sie den Zugriff Select.columns_clause_froms.

Um aus einer alternativen Spaltensammlung auszuwählen und dabei die FROM-Liste beizubehalten, verwenden Sie die Methode Select.with_only_columns() und übergeben Sie den Parameter Select.with_only_columns.maintain_column_froms.

Neu in Version 1.4.23: - die Methode Select.get_final_froms() ersetzt den vorherigen Zugriff Select.froms, der veraltet ist.

Siehe auch

methode sqlalchemy.sql.expression.Select.get_label_style() → SelectLabelStyle¶: geerbt von der GenerativeSelect.get_label_style() Methode von GenerativeSelect

Ruft den aktuellen Label-Stil ab.

Neu in Version 1.4.

methode sqlalchemy.sql.expression.Select.group_by(_GenerativeSelect__first: Literal[None, _NoArg.NO_ARG] | _ColumnExpressionOrStrLabelArgument[Any] = _NoArg.NO_ARG, *clauses: _ColumnExpressionOrStrLabelArgument[Any]) → Self¶

geerbt von der GenerativeSelect.group_by() Methode von GenerativeSelect

Gibt einen neuen Selektierbaren mit der angegebenen Liste von GROUP BY-Kriterien zurück.

Alle vorhandenen GROUP BY-Einstellungen können unterdrückt werden, indem None übergeben wird.

z. B.

stmt = select(table.c.name, func.max(table.c.stat)).group_by(table.c.name)

Parameter:: *clauses¶ – eine Reihe von ColumnElement-Konstrukten, die zur Erzeugung einer GROUP BY-Klausel verwendet werden.

Siehe auch

Aggregatfunktionen mit GROUP BY / HAVING - im SQLAlchemy Unified Tutorial

Sortierung oder Gruppierung nach einem Label - im SQLAlchemy Unified Tutorial

methode sqlalchemy.sql.expression.Select.having(*having: _ColumnExpressionArgument[bool]) → Self¶: Gibt eine neue select()-Konstruktion zurück, mit dem angegebenen Ausdruck, der zur HAVING-Klausel hinzugefügt wird, verknüpft mit der vorhandenen Klausel über AND, falls vorhanden.

attribut sqlalchemy.sql.expression.Select.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.

attribut sqlalchemy.sql.expression.Select.inner_columns¶

Ein Iterator aller ColumnElement-Ausdrücke, die in die Spaltenklausel der resultierenden SELECT-Anweisung gerendert würden.

Diese Methode ist ab Version 1.4 veraltet und wird durch die Sammlung Select.exported_columns ersetzt.

methode sqlalchemy.sql.expression.Select.intersect(*other: _SelectStatementForCompoundArgument[_TP]) → CompoundSelect[_TP]¶

Gibt eine SQL INTERSECT-Konstruktion dieses select()-Konstrukts gegen die als Positionsargumente bereitgestellten wählbaren Elemente zurück.

Parameter:

*other¶ –
ein oder mehrere Elemente, aus denen eine UNION erstellt werden soll.

Geändert in Version 1.4.28: Mehrere Elemente werden jetzt akzeptiert.
**kwargs¶ – Schlüsselwortargumente werden an den Konstruktor für das neu erstellte CompoundSelect-Objekt weitergeleitet.

methode sqlalchemy.sql.expression.Select.intersect_all(*other: _SelectStatementForCompoundArgument[_TP]) → CompoundSelect[_TP]¶

Gibt eine SQL INTERSECT ALL-Konstruktion dieses select()-Konstrukts gegen die als Positionsargumente bereitgestellten wählbaren Elemente zurück.

Parameter:

*other¶ –
ein oder mehrere Elemente, aus denen eine UNION erstellt werden soll.

Geändert in Version 1.4.28: Mehrere Elemente werden jetzt akzeptiert.
**kwargs¶ – Schlüsselwortargumente werden an den Konstruktor für das neu erstellte CompoundSelect-Objekt weitergeleitet.

methode sqlalchemy.sql.expression.Select.is_derived_from(fromclause: FromClause | None) → bool¶

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

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

methode sqlalchemy.sql.expression.Select.join(target: _JoinTargetArgument, onclause: _OnClauseArgument | None = None, *, isouter: bool = False, full: bool = False) → Self¶

Erstellt einen SQL-JOIN gegen das Select-Objekt des Kriteriums und wendet es generativ an, wobei das neu resultierende Select zurückgegeben wird.

Z. B.

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

Die obige Anweisung generiert SQL, ähnlich wie

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

Geändert in Version 1.4: Select.join() erstellt nun ein Join-Objekt zwischen einer FromClause-Quelle, die sich in der FROM-Klausel des vorhandenen SELECT befindet, und einem gegebenen Ziel-FromClause, und fügt diesen Join zur FROM-Klausel des neu generierten SELECT-Statements hinzu. Dies wurde vollständig von dem Verhalten in 1.3 überarbeitet, das stattdessen eine Unterabfrage des gesamten Select erstellt und diese Unterabfrage dann mit dem Ziel verbunden hätte.

Dies ist eine rückwärts inkompatible Änderung, da das vorherige Verhalten größtenteils nutzlos war und von den meisten Datenbanken ohnehin eine nicht benannte Unterabfrage ablehnte. Das neue Verhalten orientiert sich am sehr erfolgreichen Query.join()-Methode im ORM, um die Funktionalität von Query, die über ein Select-Objekt mit einer Session verfügbar ist, zu unterstützen.

Weitere Informationen zu dieser Änderung finden Sie unter select().join() und outerjoin() fügen JOIN-Kriterien zur aktuellen Abfrage hinzu, anstatt eine Unterabfrage zu erstellen.

Parameter:

ziel¶ – Zieltablle, zu der verbunden werden soll
onclause¶ – ON-Klausel des Joins. Wenn weggelassen, wird eine ON-Klausel automatisch basierend auf den ForeignKey-Verknüpfungen zwischen den beiden Tabellen generiert, falls eine eindeutig bestimmt werden kann, andernfalls wird ein Fehler ausgelöst.
isouter¶ – wenn True, wird ein LEFT OUTER Join generiert. Gleiches wie Select.outerjoin().
full¶ – wenn True, wird ein FULL OUTER Join generiert.

Siehe auch

Explizite FROM-Klauseln und JOINs - im SQLAlchemy Unified Tutorial

Joins - im ORM Querying Guide

Select.join_from()

Select.outerjoin()

methode sqlalchemy.sql.expression.Select.join_from(from_: _FromClauseArgument, target: _JoinTargetArgument, onclause: _OnClauseArgument | None = None, *, isouter: bool = False, full: bool = False) → Self¶

Erstellt einen SQL-JOIN gegen das Select-Objekt des Kriteriums und wendet es generativ an, wobei das neu resultierende Select zurückgegeben wird.

Z. B.

stmt = select(user_table, address_table).join_from(
    user_table, address_table, user_table.c.id == address_table.c.user_id
)

Die obige Anweisung generiert SQL, ähnlich wie

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

Neu in Version 1.4.

Parameter:

from_¶ – die linke Seite des Joins, wird in der FROM-Klausel gerendert und ist grob äquivalent zur Verwendung der Select.select_from()-Methode.
ziel¶ – Zieltablle, zu der verbunden werden soll
onclause¶ – ON-Klausel des Joins.
isouter¶ – wenn True, wird ein LEFT OUTER Join generiert. Gleiches wie Select.outerjoin().
full¶ – wenn True, wird ein FULL OUTER Join generiert.

Siehe auch

Explizite FROM-Klauseln und JOINs - im SQLAlchemy Unified Tutorial

Joins - im ORM Querying Guide

Select.join()

methode sqlalchemy.sql.expression.Select.label(name: str | None) → Label[Any]¶: geerbt von der SelectBase.label() Methode von SelectBase

Gibt eine „skalare“ Repräsentation dieses Selektierbaren zurück, eingebettet als Unterabfrage mit einem Label.

Siehe auch

SelectBase.scalar_subquery().

methode sqlalchemy.sql.expression.Select.lateral(name: str | None = None) → LateralFromClause¶

geerbt von der SelectBase.lateral() Methode von SelectBase

Gibt einen LATERAL-Alias dieses Selectable zurück.

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

Siehe auch

LATERAL Korrelation - Überblick über die Nutzung.

methode sqlalchemy.sql.expression.Select.limit(limit: _LimitOffsetType) → Self¶

geerbt von der GenerativeSelect.limit() Methode von GenerativeSelect

Gibt ein neues auswählbares Objekt mit dem angegebenen LIMIT-Kriterium zurück.

Dies ist ein numerischer Wert, der normalerweise als LIMIT-Ausdruck in der resultierenden Auswahl gerendert wird. Backends, die LIMIT nicht unterstützen, werden versuchen, eine ähnliche Funktionalität bereitzustellen.

Hinweis

Die Methode GenerativeSelect.limit() ersetzt jede mit GenerativeSelect.fetch() angewendete Klausel.

Parameter:: limit¶ – ein Integer-LIMIT-Parameter oder ein SQL-Ausdruck, der ein Integer-Ergebnis liefert. Übergib None, um ihn zurückzusetzen.

Siehe auch

methode sqlalchemy.sql.expression.Select.offset(offset: _LimitOffsetType) → Self¶

geerbt von der GenerativeSelect.offset() Methode von GenerativeSelect

Gibt ein neues auswählbares Objekt mit dem angegebenen OFFSET-Kriterium zurück.

Dies ist ein numerischer Wert, der normalerweise als OFFSET-Ausdruck in der resultierenden Auswahl gerendert wird. Backends, die OFFSET nicht unterstützen, werden versuchen, eine ähnliche Funktionalität bereitzustellen.

Parameter:: offset¶ – ein Integer-OFFSET-Parameter oder ein SQL-Ausdruck, der ein Integer-Ergebnis liefert. Übergib None, um ihn zurückzusetzen.

Siehe auch

Sortierung oder Gruppierung nach einem Label - im SQLAlchemy Unified Tutorial

methode sqlalchemy.sql.expression.Select.options(*options: ExecutableOption) → Self¶

geerbt von der Executable.options() Methode von Executable

Wendet Optionen auf diese Anweisung an.

Im Allgemeinen sind Optionen beliebige Python-Objekte, die vom SQL-Compiler für die Anweisung interpretiert werden können. Diese Optionen können von bestimmten Dialekten oder bestimmten Arten von Compilern verarbeitet werden.

Die bekanntesten Arten von Optionen sind die ORM-Level-Optionen, die "eager load" und andere Lademechanismen auf eine ORM-Abfrage anwenden. Optionen können jedoch theoretisch für viele andere Zwecke verwendet werden.

Informationen zu spezifischen Optionsarten für spezifische Anweisungsarten finden Sie in der Dokumentation zu diesen Options-Objekten.

Geändert in Version 1.4: - hinzugefügt Executable.options() zu Core-Anweisungsobjekten mit dem Ziel, vereinheitlichte Core- / ORM-Abfragefähigkeiten zu ermöglichen.

Siehe auch

Optionen zum Laden von Spalten - bezieht sich auf Optionen, die spezifisch für die Verwendung von ORM-Abfragen sind

Laden von Beziehungen mit Ladeoptionen - bezieht sich auf Optionen, die spezifisch für die Verwendung von ORM-Abfragen sind

methode sqlalchemy.sql.expression.Select.order_by(_GenerativeSelect__first: Literal[None, _NoArg.NO_ARG] | _ColumnExpressionOrStrLabelArgument[Any] = _NoArg.NO_ARG, *clauses: _ColumnExpressionOrStrLabelArgument[Any]) → Self¶

geerbt von der GenerativeSelect.order_by() Methode von GenerativeSelect

Gibt ein neues auswählbares Objekt mit der angegebenen Liste von ORDER BY-Kriterien zurück.

z. B.

stmt = select(table).order_by(table.c.id, table.c.name)

Das mehrmalige Aufrufen dieser Methode ist gleichbedeutend mit dem einmaligen Aufruf mit allen verketteten Klauseln. Alle vorhandenen ORDER BY-Kriterien können durch Übergabe von None als alleinstehendem Argument abgebrochen werden. Neue ORDER BY-Kriterien können dann durch erneutes Aufrufen von Query.order_by() hinzugefügt werden, z. B.

# will erase all ORDER BY and ORDER BY new_col alone
stmt = stmt.order_by(None).order_by(new_col)

Parameter:: *clauses¶ – eine Reihe von ColumnElement-Konstrukten, die zur Generierung einer ORDER BY-Klausel verwendet werden.

Siehe auch

ORDER BY - im SQLAlchemy Unified Tutorial

methode sqlalchemy.sql.expression.Select.outerjoin(target: _JoinTargetArgument, onclause: _OnClauseArgument | None = None, *, full: bool = False) → Self¶

Erstellt einen Left Outer Join.

Parameter sind dieselben wie bei Select.join().

Geändert in Version 1.4: Select.outerjoin() erstellt nun ein Join-Objekt zwischen einer FromClause-Quelle, die sich in der FROM-Klausel des vorhandenen SELECT befindet, und einem gegebenen Ziel-FromClause, und fügt diesen Join zur FROM-Klausel des neu generierten SELECT-Statements hinzu. Dies wurde vollständig von dem Verhalten in 1.3 überarbeitet, das stattdessen eine Unterabfrage des gesamten Select erstellt und diese Unterabfrage dann mit dem Ziel verbunden hätte.

Dies ist eine rückwärts inkompatible Änderung, da das vorherige Verhalten größtenteils nutzlos war und von den meisten Datenbanken ohnehin eine nicht benannte Unterabfrage ablehnte. Das neue Verhalten orientiert sich am sehr erfolgreichen Query.join()-Methode im ORM, um die Funktionalität von Query, die über ein Select-Objekt mit einer Session verfügbar ist, zu unterstützen.

Weitere Informationen zu dieser Änderung finden Sie unter select().join() und outerjoin() fügen JOIN-Kriterien zur aktuellen Abfrage hinzu, anstatt eine Unterabfrage zu erstellen.

Siehe auch

Explizite FROM-Klauseln und JOINs - im SQLAlchemy Unified Tutorial

Joins - im ORM Querying Guide

Select.join()

methode sqlalchemy.sql.expression.Select.outerjoin_from(from_: _FromClauseArgument, target: _JoinTargetArgument, onclause: _OnClauseArgument | None = None, *, full: bool = False) → Self¶

Erstellt einen SQL LEFT OUTER JOIN gegen das Select-Objekt des Kriteriums und wendet es generativ an, wobei das neu resultierende Select zurückgegeben wird.

Die Verwendung ist dieselbe wie bei Select.join_from().

methode sqlalchemy.sql.expression.Select.prefix_with(*prefixes: _TextCoercedExpressionArgument[Any], dialect: str = '*') → Self¶

geerbt von der HasPrefixes.prefix_with() *Methode von* HasPrefixes

Fügt einen oder mehrere Ausdrücke nach dem Statement-Schlüsselwort, d.h. SELECT, INSERT, UPDATE oder DELETE, hinzu. Generativ.

Dies wird verwendet, um Backend-spezifische Präfix-Schlüsselwörter zu unterstützen, wie sie von MySQL bereitgestellt werden.

Z. B.

stmt = table.insert().prefix_with("LOW_PRIORITY", dialect="mysql")

# MySQL 5.7 optimizer hints
stmt = select(table).prefix_with("/*+ BKA(t1) */", dialect="mysql")

Mehrere Präfixe können durch mehrmaliges Aufrufen von HasPrefixes.prefix_with() angegeben werden.

Parameter:

*prefixes¶ – Textualer oder ClauseElement-Konstrukt, das nach dem INSERT-, UPDATE- oder DELETE-Schlüsselwort gerendert wird.
dialect¶ – optionaler String-Dialektname, der das Rendering dieses Präfixes auf diesen Dialekt beschränkt.

methode sqlalchemy.sql.expression.Select.reduce_columns(only_synonyms: bool = True) → Select¶

Gibt ein neues select()-Konstrukt zurück, bei dem redundant benannte, gleichwertige Spalten aus der Spaltenklausel entfernt wurden.

„Redundant“ bedeutet hier zwei Spalten, bei denen eine auf die andere verweist, entweder basierend auf einem Fremdschlüssel oder über einen einfachen Gleichheitsvergleich in der WHERE-Klausel der Anweisung. Der Hauptzweck dieser Methode ist die automatische Konstruktion einer SELECT-Anweisung mit eindeutig benannten Spalten, ohne dass tabellenqualifizierte Labels wie bei Select.set_label_style() verwendet werden müssen.

Wenn Spalten aufgrund eines Fremdschlüssels weggelassen werden, wird die referenzierte Spalte beibehalten. Wenn Spalten aufgrund der Gleichheit in der WHERE-Klausel weggelassen werden, wird die erste Spalte in der Spaltenklausel beibehalten.

Parameter:: only_synonyms¶ – wenn True, wird die Entfernung von Spalten auf diejenigen beschränkt, die denselben Namen wie die Entsprechung haben. Andernfalls werden alle Spalten entfernt, die einer anderen entsprechen.

methode sqlalchemy.sql.expression.Select.replace_selectable(old: FromClause, alias: Alias) → Self¶: geerbt von der Selectable.replace_selectable() Methode von Selectable

Ersetzt alle Vorkommen von FromClause 'old' durch das angegebene Alias-Objekt und gibt eine Kopie dieses 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.

methode sqlalchemy.sql.expression.Select.scalar_subquery() → ScalarSelect[Any]¶

geerbt von der SelectBase.scalar_subquery() Methode von SelectBase

Gibt eine "skalare" Darstellung dieses auswählbaren Objekts zurück, die als Spaltenausdruck verwendet werden kann.

Das zurückgegebene Objekt ist eine Instanz von ScalarSelect.

Typischerweise ist eine SELECT-Anweisung mit nur einer Spalte in ihrer Spaltenklausel als skalarer Ausdruck qualifiziert. Die skalare Unterabfrage kann dann in der WHERE-Klausel oder der Spaltenklausel einer umschließenden SELECT-Anweisung verwendet werden.

Beachten Sie, dass sich die skalare Unterabfrage von der Unterabfrage auf FROM-Ebene unterscheidet, die mit der Methode SelectBase.subquery() erzeugt werden kann.

Siehe auch

Skalare und korrelierte Unterabfragen - im 2.0 Tutorial

methode sqlalchemy.sql.expression.Select.select(*arg: Any, **kw: Any) → Select¶: geerbt von der SelectBase.select() Methode von SelectBase

Veraltet seit Version 1.4: Die Methode SelectBase.select() ist veraltet und wird in einer zukünftigen Version entfernt; diese Methode erstellt implizit eine Unterabfrage, die explizit sein sollte. Bitte rufen Sie zuerst SelectBase.subquery() auf, um eine Unterabfrage zu erstellen, die dann ausgewählt werden kann.

methode sqlalchemy.sql.expression.Select.select_from(*froms: _FromClauseArgument) → Self¶

Gibt ein neues select()-Konstrukt zurück, bei dem die angegebenen FROM-Ausdrücke in seine Liste von FROM-Objekten integriert werden.

Z. B.

table1 = table("t1", column("a"))
table2 = table("t2", column("b"))
s = select(table1.c.a).select_from(
    table1.join(table2, table1.c.a == table2.c.b)
)

Die „from“-Liste ist eine eindeutige Menge basierend auf der Identität jedes Elements. Das Hinzufügen einer bereits vorhandenen Table oder eines anderen auswählbaren Elements hat keine Auswirkung. Das Übergeben eines Join, das sich auf eine bereits vorhandene Table oder ein anderes auswählbares Element bezieht, hat zur Folge, dass das Vorhandensein dieses auswählbaren Elements als einzelnes Element in der gerenderten FROM-Liste verborgen wird und stattdessen in eine JOIN-Klausel gerendert wird.

Während der typische Zweck von Select.select_from() darin besteht, die standardmäßige, abgeleitete FROM-Klausel durch einen Join zu ersetzen, kann sie auch mit einzelnen Tabellenelementen aufgerufen werden, mehrmals, falls die FROM-Klausel nicht vollständig aus der Spaltenklausel abgeleitet werden kann

select(func.count("*")).select_from(table1)

attribut sqlalchemy.sql.expression.Select.selected_columns¶

Eine ColumnCollection, die die Spalten darstellt, die diese SELECT-Anweisung oder ein ähnliches Konstrukt in ihrem Ergebnissatz zurückgibt, einschließlich TextClause-Konstrukten.

Diese Sammlung unterscheidet sich von der FromClause.columns-Sammlung eines FromClause darin, dass die Spalten in dieser Sammlung nicht direkt in eine andere SELECT-Anweisung verschachtelt werden können. Zuerst muss eine Unterabfrage angewendet werden, die die für SQL erforderliche Klammerung bereitstellt.

Für ein select()-Konstrukt ist die hier dargestellte Sammlung genau das, was in der „SELECT“-Anweisung gerendert würde, und die ColumnElement-Objekte sind direkt vorhanden, wie sie gegeben wurden, z.B.

col1 = column("q", Integer)
col2 = column("p", Integer)
stmt = select(col1, col2)

Oben wäre stmt.selected_columns eine Sammlung, die direkt die Objekte col1 und col2 enthält. Für eine Anweisung, die sich gegen eine Table oder eine andere FromClause richtet, verwendet die Sammlung die ColumnElement Objekte, die sich in der FromClause.c Sammlung des From-Elements befinden.

Ein Anwendungsfall für die Select.selected_columns Sammlung ist es, den vorhandenen Spalten beim Hinzufügen zusätzlicher Kriterien Referenz zu ermöglichen, z.B.

def filter_on_id(my_select, id):
    return my_select.where(my_select.selected_columns["id"] == id)


stmt = select(MyModel)

# adds "WHERE id=:param" to the statement
stmt = filter_on_id(stmt, 42)

Hinweis

Die Select.selected_columns Sammlung enthält keine Ausdrücke, die in der Spaltenklausel mit dem text()-Konstrukt erstellt wurden; diese werden stillschweigend aus der Sammlung weggelassen. Um reine Textspaltenausdrücke innerhalb eines Select-Konstrukts zu verwenden, verwenden Sie das literal_column()-Konstrukt.

Neu in Version 1.4.

method sqlalchemy.sql.expression.Select.self_group(against: OperatorType | None = None) → SelectStatementGrouping | Self¶

Gibt ein „Gruppierungs“-Konstrukt gemäß der ClauseElement-Spezifikation zurück.

Dies erzeugt ein Element, das in einen Ausdruck eingebettet werden kann. Beachten Sie, dass diese Methode automatisch bei Bedarf beim Erstellen von Ausdrücken aufgerufen wird und keine explizite Verwendung erfordern sollte.

method sqlalchemy.sql.expression.Select.set_label_style(style: SelectLabelStyle) → Self¶

geerbt von der GenerativeSelect.set_label_style() Methode von GenerativeSelect

Gibt ein neues auswählbares Objekt mit dem angegebenen Beschriftungsstil zurück.

Es stehen drei "Beschriftungsstile" zur Verfügung: SelectLabelStyle.LABEL_STYLE_DISAMBIGUATE_ONLY, SelectLabelStyle.LABEL_STYLE_TABLENAME_PLUS_COL und SelectLabelStyle.LABEL_STYLE_NONE. Der Standardstil ist SelectLabelStyle.LABEL_STYLE_DISAMBIGUATE_ONLY.

Im modernen SQLAlchemy ist es im Allgemeinen nicht erforderlich, den Beschriftungsstil zu ändern, da per Ausdruck zugewiesene Beschriftungen effektiver durch die Verwendung der Methode ColumnElement.label() verwendet werden. In früheren Versionen wurde LABEL_STYLE_TABLENAME_PLUS_COL verwendet, um gleichnamige Spalten aus verschiedenen Tabellen, Aliasen oder Unterabfragen zu disambiguieren; das neuere LABEL_STYLE_DISAMBIGUATE_ONLY wendet nun Beschriftungen nur auf Namen an, die mit einem vorhandenen Namen in Konflikt stehen, so dass die Auswirkungen dieser Beschriftung minimal sind.

Der Grund für die Disambiguierung liegt hauptsächlich darin, dass alle Spaltenausdrücke aus einer gegebenen FromClause.c-Sammlung verfügbar sind, wenn eine Unterabfrage erstellt wird.

Neu in Version 1.4: - die Methode GenerativeSelect.set_label_style() ersetzt die vorherige Kombination der Methoden und/oder Parameter .apply_labels(), .with_labels() und use_labels=True.

Siehe auch

LABEL_STYLE_DISAMBIGUATE_ONLY

LABEL_STYLE_TABLENAME_PLUS_COL

LABEL_STYLE_NONE

LABEL_STYLE_DEFAULT

method sqlalchemy.sql.expression.Select.slice(start: int, stop: int) → Self¶

geerbt von der GenerativeSelect.slice() Methode von GenerativeSelect

Wendet LIMIT / OFFSET auf diese Anweisung basierend auf einem Slice an.

Die Start- und Stoppindizes verhalten sich wie die Argumente für die eingebaute Funktion range() von Python. Diese Methode bietet eine Alternative zur Verwendung von LIMIT/OFFSET, um einen Slice der Abfrage zu erhalten.

Zum Beispiel,

stmt = select(User).order_by(User.id).slice(1, 3)

gerendert als

SELECT users.id AS users_id,
       users.name AS users_name
FROM users ORDER BY users.id
LIMIT ? OFFSET ?
(2, 1)

Hinweis

Die Methode GenerativeSelect.slice() ersetzt jede mit GenerativeSelect.fetch() angewendete Klausel.

Neu in Version 1.4: Hinzugefügt die Methode GenerativeSelect.slice(), die von der ORM verallgemeinert wurde.

Siehe auch

Select.with_statement_hint()

method sqlalchemy.sql.expression.Select.subquery(name: str | None = None) → Subquery¶

geerbt von der SelectBase.subquery() Methode von SelectBase

Gibt eine Unterabfrage dieses SelectBase zurück.

Eine Unterabfrage ist aus SQL-Sicht ein in Klammern gesetztes, benanntes Konstrukt, das in der FROM-Klausel einer anderen SELECT-Anweisung platziert werden kann.

Gegeben eine SELECT-Anweisung wie

stmt = select(table.c.id, table.c.name)

Die obige Anweisung könnte so aussehen

SELECT table.id, table.name FROM table

Die Unterabfrageform selbst wird auf die gleiche Weise gerendert, aber wenn sie in die FROM-Klausel einer anderen SELECT-Anweisung eingebettet wird, wird sie zu einem benannten Unterelement

subq = stmt.subquery()
new_stmt = select(subq)

Die obige Anweisung wird gerendert als

SELECT anon_1.id, anon_1.name
FROM (SELECT table.id, table.name FROM table) AS anon_1

Historisch gesehen ist SelectBase.subquery() äquivalent zum Aufruf der Methode FromClause.alias() für ein FROM-Objekt; da ein SelectBase-Objekt jedoch kein direktes FROM-Objekt ist, bietet die Methode SelectBase.subquery() klarere Semantik.

Neu in Version 1.4.

method sqlalchemy.sql.expression.Select.suffix_with(*suffixes: _TextCoercedExpressionArgument[Any], dialect: str = '*') → Self¶

geerbt von der HasSuffixes.suffix_with() Methode von HasSuffixes

Fügt einen oder mehrere Ausdrücke nach dem gesamten Statement hinzu.

Dies wird verwendet, um Backend-spezifische Suffix-Schlüsselwörter für bestimmte Konstrukte zu unterstützen.

Z. B.

stmt = (
    select(col1, col2)
    .cte()
    .suffix_with(
        "cycle empno set y_cycle to 1 default 0", dialect="oracle"
    )
)

Mehrere Suffixe können durch mehrmaliges Aufrufen von HasSuffixes.suffix_with() angegeben werden.

Parameter:

*suffixes¶ – Textuelles oder ClauseElement-Konstrukt, das nach der Zielklausel gerendert wird.
dialect¶ – Optionaler String-Dialektsname, der das Rendern dieses Suffixes auf nur diesen Dialekt beschränkt.

method sqlalchemy.sql.expression.Select.union(*other: _SelectStatementForCompoundArgument[_TP]) → CompoundSelect[_TP]¶

Gibt eine SQL UNION dieses select()-Konstrukts gegen die als positionsargumente übergebenen selectables zurück.

Parameter:

*other¶ –
ein oder mehrere Elemente, aus denen eine UNION erstellt werden soll.

Geändert in Version 1.4.28: Mehrere Elemente werden jetzt akzeptiert.
**kwargs¶ – Schlüsselwortargumente werden an den Konstruktor für das neu erstellte CompoundSelect-Objekt weitergeleitet.

method sqlalchemy.sql.expression.Select.union_all(*other: _SelectStatementForCompoundArgument[_TP]) → CompoundSelect[_TP]¶

Gibt eine SQL UNION ALL dieses select()-Konstrukts gegen die als positionsargumente übergebenen selectables zurück.

Parameter:

*other¶ –
ein oder mehrere Elemente, aus denen eine UNION erstellt werden soll.

Geändert in Version 1.4.28: Mehrere Elemente werden jetzt akzeptiert.
**kwargs¶ – Schlüsselwortargumente werden an den Konstruktor für das neu erstellte CompoundSelect-Objekt weitergeleitet.

method sqlalchemy.sql.expression.Select.where(*whereclause: _ColumnExpressionArgument[bool]) → Self¶: Gibt ein neues select()-Konstrukt zurück, bei dem der gegebene Ausdruck an seine WHERE-Klausel angehängt wird, verbunden mit AND, falls vorhanden.

attribute sqlalchemy.sql.expression.Select.whereclause¶

Gibt die abgeschlossene WHERE-Klausel für diese Select-Anweisung zurück.

Dies setzt die aktuelle Sammlung von WHERE-Kriterien zu einem einzigen BooleanClauseList-Konstrukt zusammen.

Neu in Version 1.4.

method sqlalchemy.sql.expression.Select.with_for_update(*, nowait: bool = False, read: bool = False, of: _ForUpdateOfArgument | None = None, skip_locked: bool = False, key_share: bool = False) → Self¶

geerbt von der GenerativeSelect.with_for_update() Methode von GenerativeSelect

Gibt eine FOR UPDATE-Klausel für dieses GenerativeSelect an.

Z. B.

stmt = select(table).with_for_update(nowait=True)

Auf einer Datenbank wie PostgreSQL oder Oracle Database würde das Obige eine Anweisung rendern wie

SELECT table.a, table.b FROM table FOR UPDATE NOWAIT

Auf anderen Backends wird die Option nowait ignoriert und stattdessen würde dies produziert werden

SELECT table.a, table.b FROM table FOR UPDATE

Wenn ohne Argumente aufgerufen, wird die Anweisung mit dem Suffix FOR UPDATE gerendert. Zusätzliche Argumente können dann bereitgestellt werden, die gängige datenbankspezifische Varianten ermöglichen.

Parameter:

nowait¶ – bool; rendert FOR UPDATE NOWAIT auf den Dialekten Oracle Database und PostgreSQL.
read¶ – bool; rendert LOCK IN SHARE MODE auf MySQL, FOR SHARE auf PostgreSQL. Auf PostgreSQL, wenn mit nowait kombiniert, rendert es FOR SHARE NOWAIT.
of¶ – SQL-Ausdruck oder Liste von SQL-Ausdruckselementen (typischerweise Column-Objekte oder ein kompatibler Ausdruck, für einige Backends auch ein Tabellenausdruck) die in eine FOR UPDATE OF-Klausel gerendert werden; unterstützt von PostgreSQL, Oracle Database, einigen MySQL-Versionen und möglicherweise anderen. Kann als Tabelle oder als Spalte gerendert werden, abhängig vom Backend.
skip_locked¶ – bool, rendert FOR UPDATE SKIP LOCKED auf den Dialekten Oracle Database und PostgreSQL oder FOR SHARE SKIP LOCKED, wenn read=True ebenfalls angegeben ist.
key_share¶ – bool, rendert FOR NO KEY UPDATE oder, wenn mit read=True kombiniert, rendert FOR KEY SHARE auf dem PostgreSQL-Dialekt.

method sqlalchemy.sql.expression.Select.with_hint(selectable: _FromClauseArgument, text: str, dialect_name: str = '*') → Self¶

geerbt von der HasHints.with_hint() Methode von HasHints

Fügt diesem Select oder einem anderen wählbaren Objekt einen Indexierungs- oder anderen ausführungskontextbezogenen Hinweis für das gegebene wählbare Objekt hinzu.

Tipp

Die Methode Select.with_hint() fügt Hinweise hinzu, die **spezifisch für eine einzelne Tabelle** sind, an einer Position, die **dialektabhängig** ist. Um generische Optimierungshinweise **am Anfang** einer Anweisung vor dem SELECT-Schlüsselwort hinzuzufügen, wie z. B. für MySQL oder Oracle Database, verwenden Sie die Methode Select.prefix_with(). Um Optimierungshinweise **am Ende** einer Anweisung hinzuzufügen, wie z. B. für PostgreSQL, verwenden Sie die Methode Select.with_statement_hint().

Der Text des Hinweises wird an der entsprechenden Stelle für das verwendete Datenbank-Backend relativ zur als Argument selectable übergebenen Table oder Alias gerendert. Die Dialekt-Implementierung verwendet typischerweise die Python-String-Substitutionssyntax mit dem Token %(name)s, um den Namen der Tabelle oder des Alias zu rendern. Z.B. bei Verwendung von Oracle Database wird Folgendes:

select(mytable).with_hint(mytable, "index(%(name)s ix_mytable)")

Würde SQL als folgendes rendern:

select /*+ index(mytable ix_mytable) */ ... from mytable

Die Option dialect_name beschränkt das Rendern eines bestimmten Hinweises auf einen bestimmten Dialekt. Z.B. um gleichzeitig Hinweise für Oracle Database und MSSql hinzuzufügen

select(mytable).with_hint(
    mytable, "index(%(name)s ix_mytable)", "oracle"
).with_hint(mytable, "WITH INDEX ix_mytable", "mssql")

Siehe auch

Select.prefix_with() - generisches SELECT-Präfix, das auch für dialektspezifische HINT-Syntaxen wie MySQL- oder Oracle Database-Optimiererhinweise geeignet sein kann

method sqlalchemy.sql.expression.Select.with_only_columns(*entities: _ColumnsClauseArgument[Any], maintain_column_froms: bool = False, **_Select__kw: Any) → Select[Any]¶

Gibt ein neues select()-Konstrukt zurück, dessen Spaltenklausel durch die angegebenen Entitäten ersetzt wird.

Standardmäßig ist diese Methode exakt äquivalent zu, als wäre die ursprüngliche select()-Aufruf mit den angegebenen Entitäten erfolgt. Z.B. eine Anweisung

s = select(table1.c.a, table1.c.b)
s = s.with_only_columns(table1.c.b)

sollte exakt äquivalent sein zu

s = select(table1.c.b)

In diesem Betriebsmodus ändert Select.with_only_columns() auch dynamisch die FROM-Klausel der Anweisung, wenn sie nicht explizit angegeben ist. Um den bestehenden Satz von FROMs beizubehalten, einschließlich derer, die durch die aktuelle Spaltenklausel impliziert werden, fügen Sie den Parameter Select.with_only_columns.maintain_column_froms hinzu.

s = select(table1.c.a, table2.c.b)
s = s.with_only_columns(table1.c.a, maintain_column_froms=True)

Der obige Parameter führt eine Übertragung der effektiven FROMs in der Spaltensammlung an die Methode Select.select_from() durch, als ob Folgendes aufgerufen worden wäre.

s = select(table1.c.a, table2.c.b)
s = s.select_from(table1, table2).with_only_columns(table1.c.a)

Der Parameter Select.with_only_columns.maintain_column_froms nutzt die Sammlung Select.columns_clause_froms und führt eine Operation durch, die der folgenden entspricht.

s = select(table1.c.a, table2.c.b)
s = s.select_from(*s.columns_clause_froms).with_only_columns(table1.c.a)

Parameter:

*entities¶ – Spaltenausdrücke, die verwendet werden sollen.
maintain_column_froms¶ –
boolean parameter, der sicherstellt, dass die aus der aktuellen Spaltenklausel abgeleitete FROM-Liste zuerst an die Methode Select.select_from() übertragen wird.

Neu in Version 1.4.23.

method sqlalchemy.sql.expression.Select.with_statement_hint(text: str, dialect_name: str = '*') → Self¶

geerbt von der HasHints.with_statement_hint() Methode von HasHints

Fügt diesem Select oder einem anderen wählbaren Objekt einen Anweisungshinweis hinzu.

Tipp

Select.with_statement_hint() fügt im Allgemeinen Hinweise **am Ende** einer SELECT-Anweisung hinzu. Um dialektspezifische Hinweise wie Optimiererhinweise **am Anfang** der SELECT-Anweisung nach dem SELECT-Schlüsselwort zu platzieren, verwenden Sie die Methode Select.prefix_with() für einen offenen Bereich, oder für tabellenspezifische Hinweise kann die Methode Select.with_hint() verwendet werden, die Hinweise an einer dialektabhängigen Stelle platziert.

Diese Methode ist ähnlich wie Select.with_hint(), mit dem Unterschied, dass sie keine einzelne Tabelle benötigt und stattdessen für die gesamte Anweisung gilt.

Hinweise hier sind spezifisch für das Backend und können Direktiven wie Isolationslevel, Dateidirektiven, Abrufrichtlinien usw. enthalten.

Siehe auch

Select.with_hint()

Select.prefix_with() - generisches SELECT-Präfix, das auch für dialektspezifische HINT-Syntaxen wie MySQL- oder Oracle Database-Optimiererhinweise geeignet sein kann

class sqlalchemy.sql.expression.Selectable¶

Markiert eine Klasse als wählbar (selectable).

Mitglieder

corresponding_column(), exported_columns, inherit_cache, is_derived_from(), lateral(), replace_selectable()

Klassensignatur

class sqlalchemy.sql.expression.Selectable (sqlalchemy.sql.expression.ReturnsRows)

method sqlalchemy.sql.expression.Selectable.corresponding_column(column: KeyedColumnElement[Any], require_embedded: bool = False) → KeyedColumnElement[Any] | None¶

Gibt ein ColumnElement Objekt aus der Sammlung Selectable.exported_columns dieses Selectable zurück, das mit dem ursprünglichen ColumnElement über einen gemeinsamen Vorfahren korrespondiert.

Parameter:

column¶ – die Ziel-ColumnElement, die abgeglichen werden soll.
require_embedded¶ – gibt nur entsprechende Spalten für die gegebene ColumnElement zurück, wenn die gegebene ColumnElement tatsächlich innerhalb eines Unterelements dieses Selectable vorhanden ist. Normalerweise stimmt die Spalte überein, wenn sie lediglich einen gemeinsamen Vorfahren mit einer der exportierten Spalten dieses Selectable teilt.

Siehe auch

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

ColumnCollection.corresponding_column() - Implementierungsmethode.

attribute sqlalchemy.sql.expression.Selectable.exported_columns¶

geerbt vom ReturnsRows.exported_columns Attribut von ReturnsRows

Eine ColumnCollection, die die „exportierten“ Spalten dieses ReturnsRows repräsentiert.

Die „exportierten“ Spalten repräsentieren die Sammlung von ColumnElement-Ausdrücken, die von diesem SQL-Konstrukt gerendert werden. Es gibt primäre Varianten, die die „FROM-Klausel-Spalten“ einer FROM-Klausel sind, wie eine Tabelle, ein Join oder eine Unterabfrage, die „ausgewählten Spalten“, die die Spalten in der „Spaltenklausel“ eines SELECT-Statements sind, und die RETURNING-Spalten in einem DML-Statement.

Neu in Version 1.4.

Siehe auch

attribute sqlalchemy.sql.expression.Selectable.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.

method sqlalchemy.sql.expression.Selectable.is_derived_from(fromclause: FromClause | None) → bool¶

geerbt von der ReturnsRows.is_derived_from() Methode von ReturnsRows

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

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

Methode sqlalchemy.sql.expression.Selectable.lateral(name: str | None = None) → LateralFromClause¶

Gibt einen LATERAL-Alias dieses Selectable zurück.

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

Siehe auch

LATERAL Korrelation - Überblick über die Nutzung.

Methode sqlalchemy.sql.expression.Selectable.replace_selectable(old: FromClause, alias: Alias) → Self¶: Ersetzt alle Vorkommen von FromClause 'old' durch das angegebene Alias-Objekt und gibt eine Kopie dieses 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.

Klasse sqlalchemy.sql.expression.SelectBase¶

Basisklasse für SELECT-Anweisungen.

Dies schließt Select, CompoundSelect und TextualSelect ein.

Mitglieder

add_cte(), alias(), as_scalar(), c, corresponding_column(), cte(), exists(), exported_columns, get_label_style(), inherit_cache, is_derived_from(), label(), lateral(), replace_selectable(), scalar_subquery(), select(), selected_columns, set_label_style(), subquery()

Klassensignatur

class sqlalchemy.sql.expression.SelectBase (sqlalchemy.sql.roles.SelectStatementRole, sqlalchemy.sql.roles.DMLSelectRole, sqlalchemy.sql.roles.CompoundElementRole, sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.expression.HasCTE, sqlalchemy.sql.annotation.SupportsCloneAnnotations, sqlalchemy.sql.expression.Selectable)

Methode sqlalchemy.sql.expression.SelectBase.add_cte(*ctes: CTE, nest_here: bool = False) → Self¶

geerbt von der HasCTE.add_cte() Methode von HasCTE

Fügt eine oder mehrere CTE Konstrukte zu dieser Anweisung hinzu.

Diese Methode ordnet die gegebenen CTE Konstrukte der übergeordneten Anweisung zu, sodass sie alle bedingungslos in der WITH-Klausel der endgültigen Anweisung gerendert werden, auch wenn sie woanders in der Anweisung oder in Unterabfragen nicht referenziert werden.

Der optionale Parameter HasCTE.add_cte.nest_here hat, wenn er auf True gesetzt ist, den Effekt, dass jede gegebene CTE in einer WITH-Klausel gerendert wird, die direkt mit dieser Anweisung gerendert wird, anstatt an den Anfang der endgültigen gerenderten Anweisung verschoben zu werden, auch wenn diese Anweisung als Unterabfrage innerhalb einer größeren Anweisung gerendert wird.

Diese Methode hat zwei allgemeine Anwendungsfälle. Einer ist das Einbetten von CTE-Anweisungen, die ohne explizite Referenzierung einen Zweck erfüllen, wie z. B. das Einbetten einer DML-Anweisung wie INSERT oder UPDATE als CTE inline mit einer Hauptanweisung, die indirekt aus ihren Ergebnissen schöpfen kann. Der andere ist die Steuerung der exakten Platzierung einer bestimmten Reihe von CTE-Konstrukten, die direkt in Bezug auf eine bestimmte Anweisung gerendert werden sollen, die in einer größeren Anweisung verschachtelt sein kann.

Z. B.

from sqlalchemy import table, column, select

t = table("t", column("c1"), column("c2"))

ins = t.insert().values({"c1": "x", "c2": "y"}).cte()

stmt = select(t).add_cte(ins)

Würde rendern

WITH anon_1 AS (
    INSERT INTO t (c1, c2) VALUES (:param_1, :param_2)
)
SELECT t.c1, t.c2
FROM t

Oben ist die CTE „anon_1“ nicht in der SELECT-Anweisung referenziert, erfüllt aber dennoch die Aufgabe, eine INSERT-Anweisung auszuführen.

Ähnlich in einem DML-bezogenen Kontext, unter Verwendung des PostgreSQL Insert Konstrukts zur Generierung eines „Upsert“.

from sqlalchemy import table, column
from sqlalchemy.dialects.postgresql import insert

t = table("t", column("c1"), column("c2"))

delete_statement_cte = t.delete().where(t.c.c1 < 1).cte("deletions")

insert_stmt = insert(t).values({"c1": 1, "c2": 2})
update_statement = insert_stmt.on_conflict_do_update(
    index_elements=[t.c.c1],
    set_={
        "c1": insert_stmt.excluded.c1,
        "c2": insert_stmt.excluded.c2,
    },
).add_cte(delete_statement_cte)

print(update_statement)

Die obige Anweisung wird gerendert als

WITH deletions AS (
    DELETE FROM t WHERE t.c1 < %(c1_1)s
)
INSERT INTO t (c1, c2) VALUES (%(c1)s, %(c2)s)
ON CONFLICT (c1) DO UPDATE SET c1 = excluded.c1, c2 = excluded.c2

Neu in Version 1.4.21.

Parameter:

*ctes¶ –
null oder mehr CTE Konstrukte.

Geändert in Version 2.0: Mehrere CTE-Instanzen werden akzeptiert
nest_here¶ –
Wenn True, werden die gegebenen CTEs so gerendert, als würden sie das Flag HasCTE.cte.nesting auf True setzen, wenn sie zu diesem HasCTE hinzugefügt wurden. Unter der Annahme, dass die gegebenen CTEs nicht auch in einer äußeren umgebenden Anweisung referenziert werden, sollten die gegebenen CTEs auf der Ebene dieser Anweisung gerendert werden, wenn dieses Flag gesetzt ist.

Neu in Version 2.0.

Siehe auch

HasCTE.cte.nesting

Methode sqlalchemy.sql.expression.SelectBase.alias(name: str | None = None, flat: bool = False) → Subquery¶

Gibt eine benannte Unterabfrage für diese SelectBase zurück.

Für eine SelectBase (im Gegensatz zu einer FromClause) gibt dies ein Subquery Objekt zurück, das sich größtenteils genauso verhält wie das Alias Objekt, das mit einer FromClause verwendet wird.

Geändert in Version 1.4: Die Methode SelectBase.alias() ist nun ein Synonym für die Methode SelectBase.subquery().

Methode sqlalchemy.sql.expression.SelectBase.as_scalar() → ScalarSelect[Any]¶: Veraltet seit Version 1.4: Die Methode SelectBase.as_scalar() ist veraltet und wird in einer zukünftigen Version entfernt. Bitte siehe SelectBase.scalar_subquery().

Attribut sqlalchemy.sql.expression.SelectBase.c¶: Veraltet seit Version 1.4: Die Attribute SelectBase.c und SelectBase.columns sind veraltet und werden in einer zukünftigen Version entfernt; diese Attribute erstellen implizit eine Unterabfrage, die explizit sein sollte. Bitte rufen Sie zuerst SelectBase.subquery() auf, um eine Unterabfrage zu erstellen, die dann dieses Attribut enthält. Um auf die Spalten zuzugreifen, die dieses SELECT-Objekt auswählt, verwenden Sie das Attribut SelectBase.selected_columns.

Methode sqlalchemy.sql.expression.SelectBase.corresponding_column(column: KeyedColumnElement[Any], require_embedded: bool = False) → KeyedColumnElement[Any] | None¶

geerbt von der Selectable.corresponding_column() Methode von Selectable

Gibt ein ColumnElement Objekt aus der Sammlung Selectable.exported_columns dieses Selectable zurück, das mit dem ursprünglichen ColumnElement über einen gemeinsamen Vorfahren korrespondiert.

Parameter:

column¶ – die Ziel-ColumnElement, die abgeglichen werden soll.
require_embedded¶ – gib nur entsprechende Spalten für die gegebene ColumnElement zurück, wenn die gegebene ColumnElement tatsächlich innerhalb eines Unterelements dieses Selectable vorhanden ist. Normalerweise stimmt die Spalte überein, wenn sie lediglich einen gemeinsamen Vorfahren mit einer der exportierten Spalten dieses Selectable teilt.

Siehe auch

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

ColumnCollection.corresponding_column() - Implementierungsmethode.

Methode sqlalchemy.sql.expression.SelectBase.cte(name: str | None = None, recursive: bool = False, nesting: bool = False) → CTE¶

geerbt von der HasCTE.cte() Methode von HasCTE

Gibt eine neue CTE oder Common Table Expression Instanz zurück.

Gemeinsame Tabellenausdrücke sind ein SQL-Standard, bei dem SELECT-Anweisungen auf sekundäre Anweisungen zurückgreifen können, die zusammen mit der Hauptanweisung angegeben werden, und zwar mit einer Klausel namens „WITH“. Spezielle Semantiken bezüglich UNION können ebenfalls angewendet werden, um „rekursive“ Abfragen zu ermöglichen, bei denen eine SELECT-Anweisung auf die Zeilenmenge zurückgreifen kann, die zuvor ausgewählt wurden.

CTEs können auch auf DML-Konstrukte UPDATE, INSERT und DELETE auf einigen Datenbanken angewendet werden, sowohl als Quelle von CTE-Zeilen in Kombination mit RETURNING als auch als Konsument von CTE-Zeilen.

SQLAlchemy erkennt CTE Objekte, die ähnlich wie Alias Objekte behandelt werden, als spezielle Elemente, die sowohl der FROM-Klausel der Anweisung als auch einer WITH-Klausel am Anfang der Anweisung geliefert werden.

Für spezielle Präfixe wie PostgreSQL „MATERIALIZED“ und „NOT MATERIALIZED“ kann die Methode CTE.prefix_with() verwendet werden, um diese zu etablieren.

Geändert in Version 1.3.13: Unterstützung für Präfixe hinzugefügt. Insbesondere – MATERIALIZED und NOT MATERIALIZED.

Parameter:

name¶ – Name, der dem gemeinsamen Tabellenausdruck gegeben wird. Ähnlich wie bei FromClause.alias() kann der Name als None belassen werden, in diesem Fall wird zur Kompilierungszeit ein anonymer Symbol verwendet.
recursive¶ – wenn True, wird WITH RECURSIVE gerendert. Ein rekursiver gemeinsamer Tabellenausdruck ist dafür gedacht, in Verbindung mit UNION ALL verwendet zu werden, um Zeilen aus bereits ausgewählten Zeilen abzuleiten.
nesting¶ –
Wenn True, wird die CTE lokal für die Anweisung gerendert, in der sie referenziert wird. Für komplexere Szenarien kann die Methode HasCTE.add_cte() mit dem Parameter HasCTE.add_cte.nest_here verwendet werden, um die genaue Platzierung einer bestimmten CTE genauer zu steuern.

Neu in Version 1.4.24.

Siehe auch

HasCTE.add_cte()

Die folgenden Beispiele enthalten zwei aus der PostgreSQL-Dokumentation unter https://www.postgresql.org/docs/current/static/queries-with.html sowie zusätzliche Beispiele.

Beispiel 1, nicht rekursiv

from sqlalchemy import (
    Table,
    Column,
    String,
    Integer,
    MetaData,
    select,
    func,
)

metadata = MetaData()

orders = Table(
    "orders",
    metadata,
    Column("region", String),
    Column("amount", Integer),
    Column("product", String),
    Column("quantity", Integer),
)

regional_sales = (
    select(orders.c.region, func.sum(orders.c.amount).label("total_sales"))
    .group_by(orders.c.region)
    .cte("regional_sales")
)


top_regions = (
    select(regional_sales.c.region)
    .where(
        regional_sales.c.total_sales
        > select(func.sum(regional_sales.c.total_sales) / 10)
    )
    .cte("top_regions")
)

statement = (
    select(
        orders.c.region,
        orders.c.product,
        func.sum(orders.c.quantity).label("product_units"),
        func.sum(orders.c.amount).label("product_sales"),
    )
    .where(orders.c.region.in_(select(top_regions.c.region)))
    .group_by(orders.c.region, orders.c.product)
)

result = conn.execute(statement).fetchall()

Beispiel 2, WITH RECURSIVE

from sqlalchemy import (
    Table,
    Column,
    String,
    Integer,
    MetaData,
    select,
    func,
)

metadata = MetaData()

parts = Table(
    "parts",
    metadata,
    Column("part", String),
    Column("sub_part", String),
    Column("quantity", Integer),
)

included_parts = (
    select(parts.c.sub_part, parts.c.part, parts.c.quantity)
    .where(parts.c.part == "our part")
    .cte(recursive=True)
)


incl_alias = included_parts.alias()
parts_alias = parts.alias()
included_parts = included_parts.union_all(
    select(
        parts_alias.c.sub_part, parts_alias.c.part, parts_alias.c.quantity
    ).where(parts_alias.c.part == incl_alias.c.sub_part)
)

statement = select(
    included_parts.c.sub_part,
    func.sum(included_parts.c.quantity).label("total_quantity"),
).group_by(included_parts.c.sub_part)

result = conn.execute(statement).fetchall()

Beispiel 3, ein Upsert mit UPDATE und INSERT mit CTEs

from datetime import date
from sqlalchemy import (
    MetaData,
    Table,
    Column,
    Integer,
    Date,
    select,
    literal,
    and_,
    exists,
)

metadata = MetaData()

visitors = Table(
    "visitors",
    metadata,
    Column("product_id", Integer, primary_key=True),
    Column("date", Date, primary_key=True),
    Column("count", Integer),
)

# add 5 visitors for the product_id == 1
product_id = 1
day = date.today()
count = 5

update_cte = (
    visitors.update()
    .where(
        and_(visitors.c.product_id == product_id, visitors.c.date == day)
    )
    .values(count=visitors.c.count + count)
    .returning(literal(1))
    .cte("update_cte")
)

upsert = visitors.insert().from_select(
    [visitors.c.product_id, visitors.c.date, visitors.c.count],
    select(literal(product_id), literal(day), literal(count)).where(
        ~exists(update_cte.select())
    ),
)

connection.execute(upsert)

Beispiel 4, Verschachtelte CTE (SQLAlchemy 1.4.24 und neuer)

value_a = select(literal("root").label("n")).cte("value_a")

# A nested CTE with the same name as the root one
value_a_nested = select(literal("nesting").label("n")).cte(
    "value_a", nesting=True
)

# Nesting CTEs takes ascendency locally
# over the CTEs at a higher level
value_b = select(value_a_nested.c.n).cte("value_b")

value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

Die obige Abfrage rendert die zweite CTE verschachtelt in die erste, wie unten mit Inline-Parametern dargestellt:

WITH
    value_a AS
        (SELECT 'root' AS n),
    value_b AS
        (WITH value_a AS
            (SELECT 'nesting' AS n)
        SELECT value_a.n AS n FROM value_a)
SELECT value_a.n AS a, value_b.n AS b
FROM value_a, value_b

Die gleiche CTE kann auch mit der Methode HasCTE.add_cte() wie folgt eingerichtet werden (SQLAlchemy 2.0 und neuer)

value_a = select(literal("root").label("n")).cte("value_a")

# A nested CTE with the same name as the root one
value_a_nested = select(literal("nesting").label("n")).cte("value_a")

# Nesting CTEs takes ascendency locally
# over the CTEs at a higher level
value_b = (
    select(value_a_nested.c.n)
    .add_cte(value_a_nested, nest_here=True)
    .cte("value_b")
)

value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

Beispiel 5, Nicht-lineare CTE (SQLAlchemy 1.4.28 und neuer)

edge = Table(
    "edge",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("left", Integer),
    Column("right", Integer),
)

root_node = select(literal(1).label("node")).cte("nodes", recursive=True)

left_edge = select(edge.c.left).join(
    root_node, edge.c.right == root_node.c.node
)
right_edge = select(edge.c.right).join(
    root_node, edge.c.left == root_node.c.node
)

subgraph_cte = root_node.union(left_edge, right_edge)

subgraph = select(subgraph_cte)

Die obige Abfrage rendert 2 UNIONs innerhalb der rekursiven CTE

WITH RECURSIVE nodes(node) AS (
        SELECT 1 AS node
    UNION
        SELECT edge."left" AS "left"
        FROM edge JOIN nodes ON edge."right" = nodes.node
    UNION
        SELECT edge."right" AS "right"
        FROM edge JOIN nodes ON edge."left" = nodes.node
)
SELECT nodes.node FROM nodes

Siehe auch

Query.cte() - ORM-Version von HasCTE.cte().

Methode sqlalchemy.sql.expression.SelectBase.exists() → Exists¶

Gibt eine Exists-Repräsentation dieses Selektierbaren zurück, die als Spaltenausdruck verwendet werden kann.

Das zurückgegebene Objekt ist eine Instanz von Exists.

Siehe auch

EXISTS-Unterabfragen – im 2.0-Stil-Tutorial.

Neu in Version 1.4.

Attribut sqlalchemy.sql.expression.SelectBase.exported_columns¶

Eine ColumnCollection, die die „exportierten“ Spalten dieses Selectable darstellt, ohne TextClause-Konstrukte.

Die „exportierten“ Spalten für ein SelectBase-Objekt sind gleichbedeutend mit der SelectBase.selected_columns-Sammlung.

Neu in Version 1.4.

Siehe auch

Select.selected_columns

Methode sqlalchemy.sql.expression.SelectBase.get_label_style() → SelectLabelStyle¶

Ruft den aktuellen Label-Stil ab.

Von Unterklassen implementiert.

Attribut sqlalchemy.sql.expression.SelectBase.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.sql.expression.SelectBase.is_derived_from(fromclause: FromClause | None) → bool¶

geerbt von der ReturnsRows.is_derived_from() Methode von ReturnsRows

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

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

Methode sqlalchemy.sql.expression.SelectBase.label(name: str | None) → Label[Any]¶: Gibt eine „skalare“ Repräsentation dieses Selektierbaren zurück, eingebettet als Unterabfrage mit einem Label.

Siehe auch

SelectBase.scalar_subquery().

Methode sqlalchemy.sql.expression.SelectBase.lateral(name: str | None = None) → LateralFromClause¶

Gibt einen LATERAL-Alias dieses Selectable zurück.

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

Siehe auch

LATERAL Korrelation - Überblick über die Nutzung.

Methode sqlalchemy.sql.expression.SelectBase.replace_selectable(old: FromClause, alias: Alias) → Self¶: geerbt von der Selectable.replace_selectable() Methode von Selectable

Ersetzt alle Vorkommen von FromClause 'old' durch das angegebene Alias-Objekt und gibt eine Kopie dieses 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.

Methode sqlalchemy.sql.expression.SelectBase.scalar_subquery() → ScalarSelect[Any]¶

Gibt eine "skalare" Darstellung dieses auswählbaren Objekts zurück, die als Spaltenausdruck verwendet werden kann.

Das zurückgegebene Objekt ist eine Instanz von ScalarSelect.

Typischerweise ist eine SELECT-Anweisung mit nur einer Spalte in ihrer Spaltenklausel als skalarer Ausdruck qualifiziert. Die skalare Unterabfrage kann dann in der WHERE-Klausel oder der Spaltenklausel einer umschließenden SELECT-Anweisung verwendet werden.

Beachten Sie, dass sich die skalare Unterabfrage von der Unterabfrage auf FROM-Ebene unterscheidet, die mit der Methode SelectBase.subquery() erzeugt werden kann.

Siehe auch

Skalare und korrelierte Unterabfragen - im 2.0 Tutorial

Methode sqlalchemy.sql.expression.SelectBase.select(*arg: Any, **kw: Any) → Select¶: Veraltet seit Version 1.4: Die Methode SelectBase.select() ist veraltet und wird in einer zukünftigen Version entfernt; diese Methode erstellt implizit eine Unterabfrage, die explizit sein sollte. Bitte rufen Sie zuerst SelectBase.subquery() auf, um eine Unterabfrage zu erstellen, die dann ausgewählt werden kann.

Attribut sqlalchemy.sql.expression.SelectBase.selected_columns¶

Eine ColumnCollection, die die Spalten darstellt, die diese SELECT-Anweisung oder ein ähnliches Konstrukt in ihrem Ergebnissatz zurückgibt.

Diese Sammlung unterscheidet sich von der FromClause.columns-Sammlung eines FromClause darin, dass die Spalten in dieser Sammlung nicht direkt in eine andere SELECT-Anweisung verschachtelt werden können. Zuerst muss eine Unterabfrage angewendet werden, die die für SQL erforderliche Klammerung bereitstellt.

Hinweis

Die SelectBase.selected_columns Sammlung enthält keine Ausdrücke, die in der Spaltenklausel mit dem text() Konstrukt etabliert wurden; diese werden stillschweigend aus der Sammlung weggelassen. Um reine Text-Spaltenausdrücke innerhalb eines Select Konstrukts zu verwenden, verwenden Sie das literal_column() Konstrukt.

Siehe auch

Neu in Version 1.4.

Methode sqlalchemy.sql.expression.SelectBase.set_label_style(style: SelectLabelStyle) → Self¶

Gibt ein neues auswählbares Objekt mit dem angegebenen Beschriftungsstil zurück.

Von Unterklassen implementiert.

Methode sqlalchemy.sql.expression.SelectBase.subquery(name: str | None = None) → Subquery¶

Gibt eine Unterabfrage dieses SelectBase zurück.

Eine Unterabfrage ist aus SQL-Sicht ein in Klammern gesetztes, benanntes Konstrukt, das in der FROM-Klausel einer anderen SELECT-Anweisung platziert werden kann.

Gegeben eine SELECT-Anweisung wie

stmt = select(table.c.id, table.c.name)

Die obige Anweisung könnte so aussehen

SELECT table.id, table.name FROM table

Die Unterabfrageform selbst wird auf die gleiche Weise gerendert, aber wenn sie in die FROM-Klausel einer anderen SELECT-Anweisung eingebettet wird, wird sie zu einem benannten Unterelement

subq = stmt.subquery()
new_stmt = select(subq)

Die obige Anweisung wird gerendert als

SELECT anon_1.id, anon_1.name
FROM (SELECT table.id, table.name FROM table) AS anon_1

Historisch gesehen ist SelectBase.subquery() äquivalent zum Aufruf der Methode FromClause.alias() für ein FROM-Objekt; da ein SelectBase-Objekt jedoch kein direktes FROM-Objekt ist, bietet die Methode SelectBase.subquery() klarere Semantik.

Neu in Version 1.4.

Klasse sqlalchemy.sql.expression.Subquery¶

Repräsentiert eine Unterabfrage eines SELECT.

Eine Subquery wird durch Aufrufen der Methode SelectBase.subquery() oder zur Bequemlichkeit der Methode SelectBase.alias() für jede SelectBase Unterklasse, die Select, CompoundSelect und TextualSelect umfasst, erstellt. Wie in einer FROM-Klausel gerendert, repräsentiert sie den Körper der SELECT-Anweisung in Klammern, gefolgt vom üblichen „AS <somename>“, das alle „Alias“-Objekte definiert.

Das Subquery-Objekt ist dem Alias-Objekt sehr ähnlich und kann auf äquivalente Weise verwendet werden. Der Unterschied zwischen Alias und Subquery besteht darin, dass Alias immer ein FromClause-Objekt enthält, während Subquery immer ein SelectBase-Objekt enthält.

Neu in Version 1.4: Die Klasse Subquery wurde hinzugefügt, die nun dem Zweck dient, eine Aliased-Version einer SELECT-Anweisung bereitzustellen.

Mitglieder

as_scalar(), inherit_cache

Klassensignatur

class sqlalchemy.sql.expression.Subquery (sqlalchemy.sql.expression.AliasedReturnsRows)

Methode sqlalchemy.sql.expression.Subquery.as_scalar() → ScalarSelect[Any]¶: Veraltet seit Version 1.4: Die Methode Subquery.as_scalar(), die vor Version 1.4 zuvor Alias.as_scalar() war, ist veraltet und wird in einer zukünftigen Version entfernt. Bitte verwenden Sie die Methode Select.scalar_subquery() des select() Konstrukts, bevor Sie ein Subquery-Objekt erstellen, oder verwenden Sie mit dem ORM die Methode Query.scalar_subquery().

Attribut sqlalchemy.sql.expression.Subquery.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.

Klasse sqlalchemy.sql.expression.TableClause¶

Repräsentiert eine minimale "Tabelle" Konstruktion.

Dies ist ein leichtgewichtiges Tabellenobjekt, das nur einen Namen, eine Sammlung von Spalten, die typischerweise von der Funktion column() erzeugt werden, und ein Schema hat

from sqlalchemy import table, column

user = table(
    "user",
    column("id"),
    column("name"),
    column("description"),
)

Das TableClause Konstrukt dient als Basis für das häufiger verwendete Table Objekt und bietet die üblichen FromClause Dienste, einschließlich der .c. Sammlung und der Methoden zur Generierung von Anweisungen.

Es bietet **nicht** alle zusätzlichen Schema-Ebene Dienste von Table, einschließlich Einschränkungen, Verweise auf andere Tabellen oder Unterstützung für MetaData-Ebene Dienste. Es ist eigenständig nützlich als Ad-hoc-Konstrukt, das zur Generierung schneller SQL-Anweisungen verwendet wird, wenn keine vollwertigere Table verfügbar ist.

Klassensignatur

class sqlalchemy.sql.expression.TableClause (sqlalchemy.sql.roles.DMLTableRole, sqlalchemy.sql.expression.Immutable, sqlalchemy.sql.expression.NamedFromClause)

method sqlalchemy.sql.expression.TableClause.alias(name: str | None = None, flat: bool = False) → NamedFromClause¶

inherited from the FromClause.alias() method of 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

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

attribute sqlalchemy.sql.expression.TableClause.c¶

inherited from the FromClause.c attribute of FromClause

Ein Synonym für FromClause.columns

Gibt zurück:: eine ColumnCollection

attribute sqlalchemy.sql.expression.TableClause.columns¶

inherited from the FromClause.columns attribute of FromClause

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

The columns, or c collection, is the gateway to the construction of SQL expressions using table-bound or other selectable-bound columns

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

Gibt zurück:: ein ColumnCollection-Objekt.

method sqlalchemy.sql.expression.TableClause.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.sql.expression.TableClause.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¶ – An Connection or Engine which can provide a Dialect in order to generate a Compiled object. If the bind and dialect parameters are both omitted, a default SQL compiler is used.
column_keys¶ – Used for INSERT and UPDATE statements, a list of column names which should be present in the VALUES clause of the compiled statement. If None, all columns from the target table object are rendered.
dialect¶ – A Dialect instance which can generate a Compiled object. This argument takes precedence over the 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

method sqlalchemy.sql.expression.TableClause.corresponding_column(column: KeyedColumnElement[Any], require_embedded: bool = False) → KeyedColumnElement[Any] | None¶

geerbt von der Selectable.corresponding_column() Methode von Selectable

Gibt ein ColumnElement Objekt aus der Sammlung Selectable.exported_columns dieses Selectable zurück, das mit dem ursprünglichen ColumnElement über einen gemeinsamen Vorfahren korrespondiert.

Parameter:

column¶ – the target ColumnElement to be matched.
require_embedded¶ – only return corresponding columns for the given ColumnElement, if the given ColumnElement is actually present within a sub-element of this Selectable. Normally the column will match if it merely shares a common ancestor with one of the exported columns of this Selectable.

Siehe auch

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

ColumnCollection.corresponding_column() - Implementierungsmethode.

method sqlalchemy.sql.expression.TableClause.delete() → Delete¶

Generate a delete() construct against this TableClause.

Z. B.

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

See delete() for argument and usage information.

attribute sqlalchemy.sql.expression.TableClause.description¶

attribute sqlalchemy.sql.expression.TableClause.entity_namespace¶

inherited from the FromClause.entity_namespace attribute of 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.

stmt.filter_by(address="some address")

Standardmäßig ist dies die „.c“-Sammlung. Intern kann sie jedoch durch die Annotation „entity_namespace“ überschrieben werden, um alternative Ergebnisse zu liefern.

attribute sqlalchemy.sql.expression.TableClause.exported_columns¶

inherited from the FromClause.exported_columns attribute of FromClause

Eine ColumnCollection, die die „exportierten“ Spalten dieses Selectable darstellt.

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

Neu in Version 1.4.

Siehe auch

Table.foreign_key_constraints

attribute sqlalchemy.sql.expression.TableClause.foreign_keys¶

inherited from the FromClause.foreign_keys attribute of FromClause

Gibt die Sammlung der ForeignKey-Markierungsobjekte zurück, auf die sich diese FromClause bezieht.

Jede ForeignKey ist Mitglied einer ForeignKeyConstraint auf Tabellenebene.

Siehe auch

method sqlalchemy.sql.expression.TableClause.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).

attribute sqlalchemy.sql.expression.TableClause.implicit_returning = False¶: TableClause doesn’t support having a primary key or column -level defaults, so implicit returning doesn’t apply.

attribute sqlalchemy.sql.expression.TableClause.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.

method sqlalchemy.sql.expression.TableClause.insert() → Insert¶

Generate an Insert construct against this TableClause.

Z. B.

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

See insert() for argument and usage information.

method sqlalchemy.sql.expression.TableClause.is_derived_from(fromclause: FromClause | None) → bool¶

inherited from the FromClause.is_derived_from() method of FromClause

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

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

method sqlalchemy.sql.expression.TableClause.join(right: _FromClauseArgument, onclause: _ColumnExpressionArgument[bool] | None = None, isouter: bool = False, full: bool = False) → Join¶

inherited from the FromClause.join() method of FromClause

Gibt einen Join von diesem FromClause zu einem 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 etwa so ausgeben:

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

Parameter:

right¶ – the right side of the join; this is any FromClause object such as a Table object, and may also be a selectable-compatible object such as an ORM-mapped class.
onclause¶ – a SQL expression representing the ON clause of the join. If left at None, FromClause.join() will attempt to join the two tables based on a foreign key relationship.
isouter¶ – if True, render a LEFT OUTER JOIN, instead of JOIN.
full¶ – if True, render a FULL OUTER JOIN, instead of LEFT OUTER JOIN. Implies FromClause.join.isouter.

Siehe auch

join() - eigenständige Funktion

Join - der Typ des erzeugten Objekts

method sqlalchemy.sql.expression.TableClause.lateral(name: str | None = None) → LateralFromClause¶

inherited from the Selectable.lateral() method of Selectable

Gibt einen LATERAL-Alias dieses Selectable zurück.

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

Siehe auch

LATERAL Korrelation - Überblick über die Nutzung.

method sqlalchemy.sql.expression.TableClause.outerjoin(right: _FromClauseArgument, onclause: _ColumnExpressionArgument[bool] | None = None, full: bool = False) → Join¶

inherited from the FromClause.outerjoin() method of FromClause

Gibt einen Join von diesem FromClause zu einem anderen FromClause zurück, mit dem „isouter“-Flag auf True gesetzt.

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¶ – the right side of the join; this is any FromClause object such as a Table object, and may also be a selectable-compatible object such as an ORM-mapped class.
onclause¶ – a SQL expression representing the ON clause of the join. If left at None, FromClause.join() will attempt to join the two tables based on a foreign key relationship.
full¶ – if True, render a FULL OUTER JOIN, instead of LEFT OUTER JOIN.

Siehe auch

FromClause.join()

Join

method sqlalchemy.sql.expression.TableClause.params(*optionaldict, **kwargs)¶

inherited from the Immutable.params() method of 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}

attribute sqlalchemy.sql.expression.TableClause.primary_key¶

inherited from the FromClause.primary_key attribute of FromClause

Gibt die iterierbare 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 iterierbare Sammlung von Column-Objekten ist.

method sqlalchemy.sql.expression.TableClause.replace_selectable(old: FromClause, alias: Alias) → Self¶: geerbt von der Selectable.replace_selectable() Methode von Selectable

Ersetzt alle Vorkommen von FromClause 'old' durch das angegebene Alias-Objekt und gibt eine Kopie dieses 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.

attribute sqlalchemy.sql.expression.TableClause.schema: str | None = None¶

inherited from the FromClause.schema attribute of FromClause

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

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

Methode sqlalchemy.sql.expression.TableClause.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 ermöglicht.

Methode sqlalchemy.sql.expression.TableClause.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 selbst bereitzustellen, wenn sie in einen größeren Ausdruck platziert werden, sowie von select()-Konstrukten, wenn sie in die FROM-Klausel eines anderen select() platziert werden. (Beachten Sie, dass Unterabfragen normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen verschachtelte SELECT-Anweisungen benennen müssen).

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 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 self zurück.

Methode sqlalchemy.sql.expression.TableClause.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 backendabhängig und wird in verschiedenen Formen von Backends wie PostgreSQL, Oracle Database und SQL Server unterstützt.

Z. B.

>>> fromsqlalchemyimportselect,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.sql.expression.TableClause.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 ein TABLESAMPLE-Alias dieser FromClause zurück.

Der Rückgabewert ist die TableSample-Konstruktion, die ebenfalls von der übergeordneten Funktion tablesample() bereitgestellt wird.

Siehe auch

tablesample() - Nutzungsrichtlinien und Parameter

Methode sqlalchemy.sql.expression.TableClause.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.sql.expression.TableClause.update() → Update¶

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.

Klasse sqlalchemy.sql.expression.TableSample¶

Repräsentiert eine TABLESAMPLE Klausel.

Dieses Objekt wird aus der Modul-Level-Funktion tablesample() sowie der Methode FromClause.tablesample(), die auf allen FromClause-Unterklassen verfügbar ist, konstruiert.

Siehe auch

tablesample()

Klassensignatur

class sqlalchemy.sql.expression.TableSample (sqlalchemy.sql.expression.FromClauseAlias)

Klasse sqlalchemy.sql.expression.TableValuedAlias¶

Ein Alias gegen eine "tabellenwertige" SQL-Funktion.

Diese Konstruktion ermöglicht eine SQL-Funktion, die Spalten für die Verwendung in der FROM-Klausel einer SELECT-Anweisung zurückgibt. Das Objekt wird über die Methode FunctionElement.table_valued() generiert, z. B.

>>> fromsqlalchemyimportselect,func>>> fn=func.json_array_elements_text('["one", "two", "three"]').table_valued(...     "value"... )>>> print(select(fn.c.value))SELECT anon_1.value
FROM json_array_elements_text(:json_array_elements_text_1) AS anon_1

Neu ab Version 1.4.0b2.

Siehe auch

Tabellenwertige Funktionen - im SQLAlchemy Unified Tutorial

Mitglieder

alias(), column, lateral(), render_derived()

Klassensignatur

class sqlalchemy.sql.expression.TableValuedAlias (sqlalchemy.sql.expression.LateralFromClause, sqlalchemy.sql.expression.Alias)

Methode sqlalchemy.sql.expression.TableValuedAlias.alias(name: str | None = None, flat: bool = False) → TableValuedAlias¶

Gibt einen neuen Alias dieser TableValuedAlias zurück.

Dies erstellt ein separates FROM-Objekt, das bei Verwendung in einer SQL-Anweisung vom Original unterschieden wird.

Attribut sqlalchemy.sql.expression.TableValuedAlias.column¶

Gibt einen Spaltenausdruck zurück, der diese TableValuedAlias darstellt.

Dieser Zugriff wird verwendet, um die Methode FunctionElement.column_valued() zu implementieren. Weitere Details finden Sie in dieser Methode.

Z. B.

>>> print(select(func.some_func().table_valued("value").column))SELECT anon_1 FROM some_func() AS anon_1

Siehe auch

FunctionElement.column_valued()

Methode sqlalchemy.sql.expression.TableValuedAlias.lateral(name: str | None = None) → LateralFromClause¶: Gibt eine neue TableValuedAlias mit gesetztem Lateral-Flag zurück, sodass sie als LATERAL gerendert wird.

Siehe auch

lateral()

Methode sqlalchemy.sql.expression.TableValuedAlias.render_derived(name: str | None = None, with_types: bool = False) → TableValuedAlias¶

Wendet "render derived" auf diese TableValuedAlias an.

Dies hat den Effekt, dass die einzelnen Spaltennamen nach dem Aliasnamen in der "AS"-Sequenz aufgelistet werden, z. B.

>>> print(...     select(...         func.unnest(array(["one", "two", "three"]))...         .table_valued("x", with_ordinality="o")...         .render_derived()...     )... )SELECT anon_1.x, anon_1.o
FROM unnest(ARRAY[%(param_1)s, %(param_2)s, %(param_3)s]) WITH ORDINALITY AS anon_1(x, o)

Das Schlüsselwort with_types rendert Spaltentypen inline innerhalb des Alias-Ausdrucks (diese Syntax gilt derzeit für die PostgreSQL-Datenbank)

>>> print(...     select(...         func.json_to_recordset('[{"a":1,"b":"foo"},{"a":"2","c":"bar"}]')...         .table_valued(column("a", Integer), column("b", String))...         .render_derived(with_types=True)...     )... )SELECT anon_1.a, anon_1.b FROM json_to_recordset(:json_to_recordset_1)
AS anon_1(a INTEGER, b VARCHAR)

Parameter:

name¶ – Optionaler Stringname, der dem generierten Alias zugewiesen wird. Wenn None belassen, wird ein eindeutiger anonymisierender Name verwendet.
with_types¶ – Wenn True, enthalten die abgeleiteten Spalten die Datentyp-Spezifikation für jede Spalte. Dies ist eine spezielle Syntax, die derzeit bekanntermaßen von PostgreSQL für einige SQL-Funktionen benötigt wird.

Klasse sqlalchemy.sql.expression.TextualSelect¶

Wickelt ein TextClause Konstrukt in ein SelectBase Interface.

Dies ermöglicht dem TextClause-Objekt eine .c -Sammlung und andere FROM-ähnliche Fähigkeiten wie FromClause.alias(), SelectBase.cte() usw.

Die Konstruktion TextualSelect wird über die Methode TextClause.columns() erzeugt - siehe diese Methode für Details.

Geändert in Version 1.4: die Klasse TextualSelect wurde von TextAsFrom umbenannt, um ihrer Rolle als SELECT-orientiertes Objekt und nicht als FROM-Klausel besser zu entsprechen.

Siehe auch

text()

TextClause.columns() - primäre Erstellungsschnittstelle.

Klassensignatur

class sqlalchemy.sql.expression.TextualSelect (sqlalchemy.sql.expression.SelectBase, sqlalchemy.sql.expression.ExecutableReturnsRows, sqlalchemy.sql.expression.Generative)

Methode sqlalchemy.sql.expression.TextualSelect.add_cte(*ctes: CTE, nest_here: bool = False) → Self¶

geerbt von der HasCTE.add_cte() Methode von HasCTE

Fügt eine oder mehrere CTE Konstrukte zu dieser Anweisung hinzu.

Diese Methode ordnet die gegebenen CTE Konstrukte der übergeordneten Anweisung zu, sodass sie alle bedingungslos in der WITH-Klausel der endgültigen Anweisung gerendert werden, auch wenn sie woanders in der Anweisung oder in Unterabfragen nicht referenziert werden.

Der optionale Parameter HasCTE.add_cte.nest_here hat, wenn er auf True gesetzt ist, den Effekt, dass jede gegebene CTE in einer WITH-Klausel gerendert wird, die direkt mit dieser Anweisung gerendert wird, anstatt an den Anfang der endgültigen gerenderten Anweisung verschoben zu werden, auch wenn diese Anweisung als Unterabfrage innerhalb einer größeren Anweisung gerendert wird.

Diese Methode hat zwei allgemeine Anwendungsfälle. Einer ist das Einbetten von CTE-Anweisungen, die ohne explizite Referenzierung einen Zweck erfüllen, wie z. B. das Einbetten einer DML-Anweisung wie INSERT oder UPDATE als CTE inline mit einer Hauptanweisung, die indirekt aus ihren Ergebnissen schöpfen kann. Der andere ist die Steuerung der exakten Platzierung einer bestimmten Reihe von CTE-Konstrukten, die direkt in Bezug auf eine bestimmte Anweisung gerendert werden sollen, die in einer größeren Anweisung verschachtelt sein kann.

Z. B.

from sqlalchemy import table, column, select

t = table("t", column("c1"), column("c2"))

ins = t.insert().values({"c1": "x", "c2": "y"}).cte()

stmt = select(t).add_cte(ins)

Würde rendern

WITH anon_1 AS (
    INSERT INTO t (c1, c2) VALUES (:param_1, :param_2)
)
SELECT t.c1, t.c2
FROM t

Oben ist die CTE „anon_1“ nicht in der SELECT-Anweisung referenziert, erfüllt aber dennoch die Aufgabe, eine INSERT-Anweisung auszuführen.

Ähnlich in einem DML-bezogenen Kontext, unter Verwendung des PostgreSQL Insert Konstrukts zur Generierung eines „Upsert“.

from sqlalchemy import table, column
from sqlalchemy.dialects.postgresql import insert

t = table("t", column("c1"), column("c2"))

delete_statement_cte = t.delete().where(t.c.c1 < 1).cte("deletions")

insert_stmt = insert(t).values({"c1": 1, "c2": 2})
update_statement = insert_stmt.on_conflict_do_update(
    index_elements=[t.c.c1],
    set_={
        "c1": insert_stmt.excluded.c1,
        "c2": insert_stmt.excluded.c2,
    },
).add_cte(delete_statement_cte)

print(update_statement)

Die obige Anweisung wird gerendert als

WITH deletions AS (
    DELETE FROM t WHERE t.c1 < %(c1_1)s
)
INSERT INTO t (c1, c2) VALUES (%(c1)s, %(c2)s)
ON CONFLICT (c1) DO UPDATE SET c1 = excluded.c1, c2 = excluded.c2

Neu in Version 1.4.21.

Parameter:

*ctes¶ –
null oder mehr CTE Konstrukte.

Geändert in Version 2.0: Mehrere CTE-Instanzen werden akzeptiert
nest_here¶ –
Wenn True, werden die gegebenen CTEs so gerendert, als würden sie das Flag HasCTE.cte.nesting auf True setzen, wenn sie zu diesem HasCTE hinzugefügt wurden. Unter der Annahme, dass die gegebenen CTEs nicht auch in einer äußeren umgebenden Anweisung referenziert werden, sollten die gegebenen CTEs auf der Ebene dieser Anweisung gerendert werden, wenn dieses Flag gesetzt ist.

Neu in Version 2.0.

Siehe auch

HasCTE.cte.nesting

Methode sqlalchemy.sql.expression.TextualSelect.alias(name: str | None = None, flat: bool = False) → Subquery¶

geerbt von der SelectBase.alias() Methode von SelectBase

Gibt eine benannte Unterabfrage für diese SelectBase zurück.

Für eine SelectBase (im Gegensatz zu einer FromClause) gibt dies ein Subquery Objekt zurück, das sich größtenteils genauso verhält wie das Alias Objekt, das mit einer FromClause verwendet wird.

Geändert in Version 1.4: Die Methode SelectBase.alias() ist nun ein Synonym für die Methode SelectBase.subquery().

Methode sqlalchemy.sql.expression.TextualSelect.as_scalar() → ScalarSelect[Any]¶: geerbt von der SelectBase.as_scalar() Methode von SelectBase

Veraltet seit Version 1.4: Die Methode SelectBase.as_scalar() ist veraltet und wird in einer zukünftigen Version entfernt. Bitte siehe SelectBase.scalar_subquery().

Attribut sqlalchemy.sql.expression.TextualSelect.c¶: geerbt von der SelectBase.c Attribut von SelectBase

Veraltet seit Version 1.4: Die Attribute SelectBase.c und SelectBase.columns sind veraltet und werden in einer zukünftigen Version entfernt; diese Attribute erstellen implizit eine Unterabfrage, die explizit sein sollte. Bitte rufen Sie zuerst SelectBase.subquery() auf, um eine Unterabfrage zu erstellen, die dann dieses Attribut enthält. Um auf die Spalten zuzugreifen, die dieses SELECT-Objekt auswählt, verwenden Sie das Attribut SelectBase.selected_columns.

Methode sqlalchemy.sql.expression.TextualSelect.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.sql.expression.TextualSelect.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 eine 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 vorhanden 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.sql.expression.TextualSelect.corresponding_column(column: KeyedColumnElement[Any], require_embedded: bool = False) → KeyedColumnElement[Any] | None¶

geerbt von der Selectable.corresponding_column() Methode von Selectable

Gibt ein ColumnElement Objekt aus der Sammlung Selectable.exported_columns dieses Selectable zurück, das mit dem ursprünglichen ColumnElement über einen gemeinsamen Vorfahren korrespondiert.

Parameter:

column¶ – die Ziel-ColumnElement, die abgeglichen werden soll.
require_embedded¶ – nur entsprechende Spalten für das angegebene ColumnElement zurückgeben, wenn das angegebene ColumnElement tatsächlich innerhalb eines Unterelements dieses Selectable vorhanden ist. Normalerweise stimmt die Spalte überein, wenn sie lediglich einen gemeinsamen Vorfahren mit einer der exportierten Spalten dieses Selectable teilt.

Siehe auch

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

ColumnCollection.corresponding_column() - Implementierungsmethode.

method sqlalchemy.sql.expression.TextualSelect.cte(name: str | None = None, recursive: bool = False, nesting: bool = False) → CTE¶

geerbt von der HasCTE.cte() Methode von HasCTE

Gibt eine neue CTE oder Common Table Expression Instanz zurück.

Gemeinsame Tabellenausdrücke sind ein SQL-Standard, bei dem SELECT-Anweisungen auf sekundäre Anweisungen zurückgreifen können, die zusammen mit der Hauptanweisung angegeben werden, und zwar mit einer Klausel namens „WITH“. Spezielle Semantiken bezüglich UNION können ebenfalls angewendet werden, um „rekursive“ Abfragen zu ermöglichen, bei denen eine SELECT-Anweisung auf die Zeilenmenge zurückgreifen kann, die zuvor ausgewählt wurden.

CTEs können auch auf DML-Konstrukte UPDATE, INSERT und DELETE auf einigen Datenbanken angewendet werden, sowohl als Quelle von CTE-Zeilen in Kombination mit RETURNING als auch als Konsument von CTE-Zeilen.

SQLAlchemy erkennt CTE Objekte, die ähnlich wie Alias Objekte behandelt werden, als spezielle Elemente, die sowohl der FROM-Klausel der Anweisung als auch einer WITH-Klausel am Anfang der Anweisung geliefert werden.

Für spezielle Präfixe wie PostgreSQL „MATERIALIZED“ und „NOT MATERIALIZED“ kann die Methode CTE.prefix_with() verwendet werden, um diese zu etablieren.

Geändert in Version 1.3.13: Unterstützung für Präfixe hinzugefügt. Insbesondere – MATERIALIZED und NOT MATERIALIZED.

Parameter:

name¶ – Name, der der gemeinsamen Tabellenausdruck erhält. Ähnlich wie bei FromClause.alias() kann der Name als None belassen werden, in diesem Fall wird zur Kompilierungszeit ein anonymer Symbol verwendet.
recursive¶ – wenn True, wird WITH RECURSIVE gerendert. Ein rekursiver gemeinsamer Tabellenausdruck ist zur Verwendung in Verbindung mit UNION ALL vorgesehen, um Zeilen aus bereits ausgewählten Zeilen abzuleiten.
nesting¶ –
Wenn True, wird die CTE lokal für die Anweisung gerendert, in der sie referenziert wird. Für komplexere Szenarien kann die Methode HasCTE.add_cte() mit dem Parameter HasCTE.add_cte.nest_here verwendet werden, um die genaue Platzierung einer bestimmten CTE genauer zu steuern.

Neu in Version 1.4.24.

Siehe auch

HasCTE.add_cte()

Die folgenden Beispiele enthalten zwei aus der PostgreSQL-Dokumentation unter https://www.postgresql.org/docs/current/static/queries-with.html sowie zusätzliche Beispiele.

Beispiel 1, nicht rekursiv

from sqlalchemy import (
    Table,
    Column,
    String,
    Integer,
    MetaData,
    select,
    func,
)

metadata = MetaData()

orders = Table(
    "orders",
    metadata,
    Column("region", String),
    Column("amount", Integer),
    Column("product", String),
    Column("quantity", Integer),
)

regional_sales = (
    select(orders.c.region, func.sum(orders.c.amount).label("total_sales"))
    .group_by(orders.c.region)
    .cte("regional_sales")
)


top_regions = (
    select(regional_sales.c.region)
    .where(
        regional_sales.c.total_sales
        > select(func.sum(regional_sales.c.total_sales) / 10)
    )
    .cte("top_regions")
)

statement = (
    select(
        orders.c.region,
        orders.c.product,
        func.sum(orders.c.quantity).label("product_units"),
        func.sum(orders.c.amount).label("product_sales"),
    )
    .where(orders.c.region.in_(select(top_regions.c.region)))
    .group_by(orders.c.region, orders.c.product)
)

result = conn.execute(statement).fetchall()

Beispiel 2, WITH RECURSIVE

from sqlalchemy import (
    Table,
    Column,
    String,
    Integer,
    MetaData,
    select,
    func,
)

metadata = MetaData()

parts = Table(
    "parts",
    metadata,
    Column("part", String),
    Column("sub_part", String),
    Column("quantity", Integer),
)

included_parts = (
    select(parts.c.sub_part, parts.c.part, parts.c.quantity)
    .where(parts.c.part == "our part")
    .cte(recursive=True)
)


incl_alias = included_parts.alias()
parts_alias = parts.alias()
included_parts = included_parts.union_all(
    select(
        parts_alias.c.sub_part, parts_alias.c.part, parts_alias.c.quantity
    ).where(parts_alias.c.part == incl_alias.c.sub_part)
)

statement = select(
    included_parts.c.sub_part,
    func.sum(included_parts.c.quantity).label("total_quantity"),
).group_by(included_parts.c.sub_part)

result = conn.execute(statement).fetchall()

Beispiel 3, ein Upsert mit UPDATE und INSERT mit CTEs

from datetime import date
from sqlalchemy import (
    MetaData,
    Table,
    Column,
    Integer,
    Date,
    select,
    literal,
    and_,
    exists,
)

metadata = MetaData()

visitors = Table(
    "visitors",
    metadata,
    Column("product_id", Integer, primary_key=True),
    Column("date", Date, primary_key=True),
    Column("count", Integer),
)

# add 5 visitors for the product_id == 1
product_id = 1
day = date.today()
count = 5

update_cte = (
    visitors.update()
    .where(
        and_(visitors.c.product_id == product_id, visitors.c.date == day)
    )
    .values(count=visitors.c.count + count)
    .returning(literal(1))
    .cte("update_cte")
)

upsert = visitors.insert().from_select(
    [visitors.c.product_id, visitors.c.date, visitors.c.count],
    select(literal(product_id), literal(day), literal(count)).where(
        ~exists(update_cte.select())
    ),
)

connection.execute(upsert)

Beispiel 4, Verschachtelte CTE (SQLAlchemy 1.4.24 und neuer)

value_a = select(literal("root").label("n")).cte("value_a")

# A nested CTE with the same name as the root one
value_a_nested = select(literal("nesting").label("n")).cte(
    "value_a", nesting=True
)

# Nesting CTEs takes ascendency locally
# over the CTEs at a higher level
value_b = select(value_a_nested.c.n).cte("value_b")

value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

Die obige Abfrage rendert die zweite CTE verschachtelt in die erste, wie unten mit Inline-Parametern dargestellt:

WITH
    value_a AS
        (SELECT 'root' AS n),
    value_b AS
        (WITH value_a AS
            (SELECT 'nesting' AS n)
        SELECT value_a.n AS n FROM value_a)
SELECT value_a.n AS a, value_b.n AS b
FROM value_a, value_b

Die gleiche CTE kann auch mit der Methode HasCTE.add_cte() wie folgt eingerichtet werden (SQLAlchemy 2.0 und neuer)

value_a = select(literal("root").label("n")).cte("value_a")

# A nested CTE with the same name as the root one
value_a_nested = select(literal("nesting").label("n")).cte("value_a")

# Nesting CTEs takes ascendency locally
# over the CTEs at a higher level
value_b = (
    select(value_a_nested.c.n)
    .add_cte(value_a_nested, nest_here=True)
    .cte("value_b")
)

value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

Beispiel 5, Nicht-lineare CTE (SQLAlchemy 1.4.28 und neuer)

edge = Table(
    "edge",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("left", Integer),
    Column("right", Integer),
)

root_node = select(literal(1).label("node")).cte("nodes", recursive=True)

left_edge = select(edge.c.left).join(
    root_node, edge.c.right == root_node.c.node
)
right_edge = select(edge.c.right).join(
    root_node, edge.c.left == root_node.c.node
)

subgraph_cte = root_node.union(left_edge, right_edge)

subgraph = select(subgraph_cte)

Die obige Abfrage rendert 2 UNIONs innerhalb der rekursiven CTE

WITH RECURSIVE nodes(node) AS (
        SELECT 1 AS node
    UNION
        SELECT edge."left" AS "left"
        FROM edge JOIN nodes ON edge."right" = nodes.node
    UNION
        SELECT edge."right" AS "right"
        FROM edge JOIN nodes ON edge."left" = nodes.node
)
SELECT nodes.node FROM nodes

Siehe auch

Query.cte() - ORM-Version von HasCTE.cte().

method sqlalchemy.sql.expression.TextualSelect.execution_options(**kw: Any) → Self¶

geerbt von der Executable.execution_options() Methode von Executable

Setzt Nicht-SQL-Optionen für die Anweisung, die während der Ausführung wirksam werden.

Ausführungsoptionen können auf verschiedenen Ebenen gesetzt werden, einschließlich pro Anweisung, pro Verbindung oder pro Ausführung, unter Verwendung von Methoden wie Connection.execution_options() und Parametern, die ein Dictionary von Optionen akzeptieren, wie z.B. Connection.execute.execution_options und Session.execute.execution_options.

Das Hauptmerkmal einer Ausführungsoption, im Gegensatz zu anderen Arten von Optionen wie ORM-Laderoptionen, ist, dass **Ausführungsoptionen niemals die kompilierte SQL einer Abfrage beeinflussen, sondern nur Dinge, die beeinflussen, wie die SQL-Anweisung selbst aufgerufen wird oder wie Ergebnisse abgerufen werden**. Das heißt, Ausführungsoptionen sind kein Teil dessen, was durch die SQL-Kompilierung abgedeckt wird, noch gelten sie als Teil des Cache-Zustands einer Anweisung.

Die Methode Executable.execution_options() ist generativ, wie auch die Methode, die auf die Engine und Query Objekte angewendet wird, was bedeutet, dass beim Aufruf der Methode eine Kopie des Objekts zurückgegeben wird, die die gegebenen Parameter auf diese neue Kopie anwendet, aber das Original unverändert lässt

statement = select(table.c.x, table.c.y)
new_statement = statement.execution_options(my_option=True)

Eine Ausnahme von diesem Verhalten ist das Connection-Objekt, bei dem die Methode Connection.execution_options() ausdrücklich **nicht** generativ ist.

Die Arten von Optionen, die an Executable.execution_options() und andere verwandte Methoden und Parameter-Dictionaries übergeben werden können, umfassen Parameter, die explizit von SQLAlchemy Core oder ORM konsumiert werden, sowie beliebige Schlüsselwortargumente, die nicht von SQLAlchemy definiert sind. Dies bedeutet, dass die Methoden und/oder Parameter-Dictionaries für benutzerdefinierte Parameter verwendet werden können, die mit benutzerdefiniertem Code interagieren, der auf die Parameter über Methoden wie Executable.get_execution_options() und Connection.get_execution_options() zugreifen kann, oder innerhalb ausgewählter Event-Hooks unter Verwendung eines dedizierten execution_options-Event-Parameters wie ConnectionEvents.before_execute.execution_options oder ORMExecuteState.execution_options, z. B.

from sqlalchemy import event


@event.listens_for(some_engine, "before_execute")
def _process_opt(conn, statement, multiparams, params, execution_options):
    "run a SQL function before invoking a statement"

    if execution_options.get("do_special_thing", False):
        conn.exec_driver_sql("run_special_function()")

Innerhalb des Bereichs von Optionen, die von SQLAlchemy explizit erkannt werden, gelten die meisten für bestimmte Klassen von Objekten und nicht für andere. Die gängigsten Ausführungsoptionen sind

Connection.execution_options.isolation_level - setzt die Isolationsebene für eine Verbindung oder eine Klasse von Verbindungen über eine Engine. Diese Option wird nur von Connection oder Engine akzeptiert.
Connection.execution_options.stream_results - gibt an, dass Ergebnisse mit einem serverseitigen Cursor abgerufen werden sollen; diese Option wird von Connection, vom Parameter Connection.execute.execution_options auf Connection.execute() und zusätzlich von Executable.execution_options() auf einem SQL-Anweisungsobjekt sowie von ORM-Konstrukten wie Session.execute() akzeptiert.
Connection.execution_options.compiled_cache - gibt ein Dictionary an, das als SQL-Kompilierungs-Cache für eine Connection oder Engine sowie für ORM-Methoden wie Session.execute() dient. Kann als None übergeben werden, um das Caching für Anweisungen zu deaktivieren. Diese Option wird nicht von Executable.execution_options() akzeptiert, da es nicht ratsam ist, einen Kompilierungs-Cache mit einem Anweisungsobjekt mitzuführen.
Connection.execution_options.schema_translate_map - eine Zuordnung von Schemanamen, die von der Schema Translate Map-Funktion verwendet wird, akzeptiert von Connection, Engine, Executable, sowie von ORM-Konstrukten wie Session.execute().

Siehe auch

ORM Ausführungsoptionen - Dokumentation zu allen ORM-spezifischen Ausführungsoptionen

method sqlalchemy.sql.expression.TextualSelect.exists() → Exists¶

geerbt von der SelectBase.exists() Methode von SelectBase

Gibt eine Exists-Repräsentation dieses Selektierbaren zurück, die als Spaltenausdruck verwendet werden kann.

Das zurückgegebene Objekt ist eine Instanz von Exists.

Siehe auch

EXISTS-Unterabfragen – im 2.0-Stil-Tutorial.

Neu in Version 1.4.

attribute sqlalchemy.sql.expression.TextualSelect.exported_columns¶

geerbt von dem SelectBase.exported_columns Attribut von SelectBase

Eine ColumnCollection, die die „exportierten“ Spalten dieses Selectable darstellt, ohne TextClause-Konstrukte.

Die „exportierten“ Spalten für ein SelectBase-Objekt sind gleichbedeutend mit der SelectBase.selected_columns-Sammlung.

Neu in Version 1.4.

Siehe auch

method sqlalchemy.sql.expression.TextualSelect.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).

method sqlalchemy.sql.expression.TextualSelect.get_execution_options() → _ExecuteOptions¶: geerbt von der Executable.get_execution_options() Methode von Executable

Ruft die nicht-SQL-Optionen ab, die während der Ausführung wirksam werden.

Neu in Version 1.3.

Siehe auch

Executable.execution_options()

method sqlalchemy.sql.expression.TextualSelect.get_label_style() → SelectLabelStyle¶

Geerbt von der SelectBase.get_label_style()-Methode von SelectBase

Ruft den aktuellen Label-Stil ab.

Von Unterklassen implementiert.

attribute sqlalchemy.sql.expression.TextualSelect.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.

method sqlalchemy.sql.expression.TextualSelect.is_derived_from(fromclause: FromClause | None) → bool¶

geerbt von der ReturnsRows.is_derived_from() Methode von ReturnsRows

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

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

method sqlalchemy.sql.expression.TextualSelect.label(name: str | None) → Label[Any]¶: geerbt von der SelectBase.label() Methode von SelectBase

Gibt eine „skalare“ Repräsentation dieses Selektierbaren zurück, eingebettet als Unterabfrage mit einem Label.

Siehe auch

SelectBase.scalar_subquery().

method sqlalchemy.sql.expression.TextualSelect.lateral(name: str | None = None) → LateralFromClause¶

geerbt von der SelectBase.lateral() Methode von SelectBase

Gibt einen LATERAL-Alias dieses Selectable zurück.

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

Siehe auch

LATERAL Korrelation - Überblick über die Nutzung.

method sqlalchemy.sql.expression.TextualSelect.options(*options: ExecutableOption) → Self¶

geerbt von der Executable.options() Methode von Executable

Wendet Optionen auf diese Anweisung an.

Im Allgemeinen sind Optionen beliebige Python-Objekte, die vom SQL-Compiler für die Anweisung interpretiert werden können. Diese Optionen können von bestimmten Dialekten oder bestimmten Arten von Compilern verarbeitet werden.

Die bekanntesten Arten von Optionen sind die ORM-Level-Optionen, die "eager load" und andere Lademechanismen auf eine ORM-Abfrage anwenden. Optionen können jedoch theoretisch für viele andere Zwecke verwendet werden.

Informationen zu spezifischen Optionsarten für spezifische Anweisungsarten finden Sie in der Dokumentation zu diesen Options-Objekten.

Geändert in Version 1.4: - hinzugefügt Executable.options() zu Core-Anweisungsobjekten mit dem Ziel, vereinheitlichte Core- / ORM-Abfragefähigkeiten zu ermöglichen.

Siehe auch

Optionen zum Laden von Spalten - bezieht sich auf Optionen, die spezifisch für die Verwendung von ORM-Abfragen sind

Laden von Beziehungen mit Ladeoptionen - bezieht sich auf Optionen, die spezifisch für die Verwendung von ORM-Abfragen sind

method sqlalchemy.sql.expression.TextualSelect.params(_ClauseElement__optionaldict: Mapping[str, Any] | None = None, **kwargs: Any) → Self¶

Geerbt von der ClauseElement.params()-Methode von ClauseElement

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}

method sqlalchemy.sql.expression.TextualSelect.replace_selectable(old: FromClause, alias: Alias) → Self¶: geerbt von der Selectable.replace_selectable() Methode von Selectable

Ersetzt alle Vorkommen von FromClause 'old' durch das angegebene Alias-Objekt und gibt eine Kopie dieses 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.

method sqlalchemy.sql.expression.TextualSelect.scalar_subquery() → ScalarSelect[Any]¶

geerbt von der SelectBase.scalar_subquery() Methode von SelectBase

Gibt eine "skalare" Darstellung dieses auswählbaren Objekts zurück, die als Spaltenausdruck verwendet werden kann.

Das zurückgegebene Objekt ist eine Instanz von ScalarSelect.

Typischerweise ist eine SELECT-Anweisung mit nur einer Spalte in ihrer Spaltenklausel als skalarer Ausdruck qualifiziert. Die skalare Unterabfrage kann dann in der WHERE-Klausel oder der Spaltenklausel einer umschließenden SELECT-Anweisung verwendet werden.

Beachten Sie, dass sich die skalare Unterabfrage von der Unterabfrage auf FROM-Ebene unterscheidet, die mit der Methode SelectBase.subquery() erzeugt werden kann.

Siehe auch

Skalare und korrelierte Unterabfragen - im 2.0 Tutorial

method sqlalchemy.sql.expression.TextualSelect.select(*arg: Any, **kw: Any) → Select¶: geerbt von der SelectBase.select() Methode von SelectBase

Veraltet seit Version 1.4: Die Methode SelectBase.select() ist veraltet und wird in einer zukünftigen Version entfernt; diese Methode erstellt implizit eine Unterabfrage, die explizit sein sollte. Bitte rufen Sie zuerst SelectBase.subquery() auf, um eine Unterabfrage zu erstellen, die dann ausgewählt werden kann.

attribute sqlalchemy.sql.expression.TextualSelect.selected_columns¶

Eine ColumnCollection, die die Spalten darstellt, die diese SELECT-Anweisung oder ein ähnliches Konstrukt in ihrem Ergebnissatz zurückgibt, einschließlich TextClause-Konstrukten.

Diese Sammlung unterscheidet sich von der FromClause.columns-Sammlung eines FromClause darin, dass die Spalten in dieser Sammlung nicht direkt in eine andere SELECT-Anweisung verschachtelt werden können. Zuerst muss eine Unterabfrage angewendet werden, die die für SQL erforderliche Klammerung bereitstellt.

Für ein TextualSelect-Konstrukt enthält die Sammlung die ColumnElement-Objekte, die an den Konstruktor übergeben wurden, typischerweise über die Methode TextClause.columns().

Neu in Version 1.4.

method sqlalchemy.sql.expression.TextualSelect.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 selbst bereitzustellen, wenn sie in einen größeren Ausdruck platziert werden, sowie von select()-Konstrukten, wenn sie in die FROM-Klausel eines anderen select() platziert werden. (Beachten Sie, dass Unterabfragen normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen verschachtelte SELECT-Anweisungen benennen müssen).

Da Ausdrücke miteinander komponiert werden, erfolgt die Anwendung von self_group() automatisch – Endbenutzercode sollte diese Methode niemals direkt verwenden müssen. Beachten Sie, dass SQLAlchemys Klauselkonstrukte die Operatorrangfolge 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 nur self zurück.

method sqlalchemy.sql.expression.TextualSelect.set_label_style(style: SelectLabelStyle) → TextualSelect¶

Gibt ein neues auswählbares Objekt mit dem angegebenen Beschriftungsstil zurück.

Von Unterklassen implementiert.

method sqlalchemy.sql.expression.TextualSelect.subquery(name: str | None = None) → Subquery¶

geerbt von der SelectBase.subquery() Methode von SelectBase

Gibt eine Unterabfrage dieses SelectBase zurück.

Eine Unterabfrage ist aus SQL-Sicht ein in Klammern gesetztes, benanntes Konstrukt, das in der FROM-Klausel einer anderen SELECT-Anweisung platziert werden kann.

Gegeben eine SELECT-Anweisung wie

stmt = select(table.c.id, table.c.name)

Die obige Anweisung könnte so aussehen

SELECT table.id, table.name FROM table

Die Unterabfrageform selbst wird auf die gleiche Weise gerendert, aber wenn sie in die FROM-Klausel einer anderen SELECT-Anweisung eingebettet wird, wird sie zu einem benannten Unterelement

subq = stmt.subquery()
new_stmt = select(subq)

Die obige Anweisung wird gerendert als

SELECT anon_1.id, anon_1.name
FROM (SELECT table.id, table.name FROM table) AS anon_1

Historisch gesehen ist SelectBase.subquery() äquivalent zum Aufruf der Methode FromClause.alias() für ein FROM-Objekt; da ein SelectBase-Objekt jedoch kein direktes FROM-Objekt ist, bietet die Methode SelectBase.subquery() klarere Semantik.

Neu in Version 1.4.

method sqlalchemy.sql.expression.TextualSelect.unique_params(_ClauseElement__optionaldict: Dict[str, Any] | None = None, **kwargs: Any) → Self¶

Geerbt von der ClauseElement.unique_params()-Methode von ClauseElement

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.

class sqlalchemy.sql.expression.Values¶

Stellt ein VALUES Konstrukt dar, das als FROM-Element in einer Anweisung verwendet werden kann.

Das Values-Objekt wird aus der Funktion values() erstellt.

Neu in Version 1.4.

Mitglieder

alias(), data(), lateral(), scalar_values()

Klassensignatur

class sqlalchemy.sql.expression.Values (sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.LateralFromClause)

method sqlalchemy.sql.expression.Values.alias(name: str | None = None, flat: bool = False) → Self¶

Gibt ein neues Values-Konstrukt zurück, das eine Kopie dieses mit dem angegebenen Namen ist.

Diese Methode ist eine VALUES-spezifische Spezialisierung der Methode FromClause.alias().

Siehe auch