SQLAlchemy 2.0 Dokumentation

Auswahl mit textuellen Spaltenausdrücken

try_cast() - eine Alternative zu CAST, die NULLs zurückgibt, wenn die Konvertierung fehlschlägt, anstatt einen Fehler auszulösen. Wird nur von einigen Dialekten unterstützt.

type_coerce() - eine Alternative zu CAST, die den Typ nur auf der Python-Seite umwandelt, was oft ausreicht, um die korrekte SQL- und Datenkonvertierung zu erzeugen.

function sqlalchemy.sql.expression.column(text: str, type_: _TypeEngineArgument[_T] | None = None, is_literal: bool = False, _selectable: FromClause | None = None) → ColumnClause[_T]¶

Erzeugt ein ColumnClause-Objekt.

Die ColumnClause ist ein leichtgewichtiger Analogon zur Klasse Column. Die Funktion column() kann allein mit einem Namen aufgerufen werden, wie in

from sqlalchemy import column

id, name = column("id"), column("name")
stmt = select(id, name).select_from("user")

Die obige Anweisung würde SQL wie folgt erzeugen:

SELECT id, name FROM user

Nach der Konstruktion kann column() wie jedes andere SQL-Ausdruckselement verwendet werden, z. B. innerhalb von select()-Konstrukten

from sqlalchemy.sql import column

id, name = column("id"), column("name")
stmt = select(id, name).select_from("user")

Der von column() behandelte Text wird als Name einer Datenbankspalte behandelt; wenn die Zeichenfolge gemischte Groß-/Kleinschreibung oder Sonderzeichen enthält oder einem bekannten reservierten Wort auf dem Ziel-Backend entspricht, wird der Spaltenausdruck unter Verwendung des vom Backend bestimmten Anführungszeichenverhaltens gerendert. Um einen textuellen SQL-Ausdruck zu erzeugen, der exakt ohne Anführungszeichen gerendert wird, verwenden Sie stattdessen literal_column() oder übergeben Sie True als Wert von column.is_literal. Außerdem werden vollständige SQL-Anweisungen am besten mit dem text()-Konstrukt behandelt.

column() kann auf tabellenähnliche Weise verwendet werden, indem es mit der Funktion table() kombiniert wird (die das leichtgewichtige Analogon zu Table ist), um mit minimalem Aufwand ein funktionierendes Tabellenkonstrukt zu erzeugen

from sqlalchemy import table, column, select

user = table(
    "user",
    column("id"),
    column("name"),
    column("description"),
)

stmt = select(user.c.description).where(user.c.name == "wendy")

Ein column() / table()-Konstrukt wie das oben gezeigte kann ad-hoc erstellt werden und ist im Gegensatz zu seinem Table-Gegenstück nicht mit Metadaten, DDL oder Events verbunden.

Parameter:

text¶ – der Text des Elements.
type¶ – TypeEngine-Objekt, das diese ColumnClause mit einem Typ verknüpfen kann.
is_literal¶ – Wenn True, wird angenommen, dass die ColumnClause ein exakter Ausdruck ist, der ohne Anführungszeichenregeln unabhängig von Groß-/Kleinschreibungseinstellungen ausgegeben wird. Die Funktion literal_column() ruft im Wesentlichen column() auf und übergibt is_literal=True.

Siehe auch

class sqlalchemy.sql.expression.custom_op¶

Stellt einen „benutzerdefinierten“ Operator dar.

custom_op wird normalerweise instanziiert, wenn die Methoden Operators.op() oder Operators.bool_op() verwendet werden, um einen benutzerdefinierten Operator-Callable zu erstellen. Die Klasse kann auch direkt verwendet werden, wenn Ausdrücke programmatisch erstellt werden. Z.B. zur Darstellung der "Fakultät"-Operation

from sqlalchemy.sql import UnaryExpression
from sqlalchemy.sql import operators
from sqlalchemy import Numeric

unary = UnaryExpression(
    table.c.somecolumn, modifier=operators.custom_op("!"), type_=Numeric
)

Siehe auch

ColumnElement.distinct()

Klassensignatur

class sqlalchemy.sql.expression.custom_op (sqlalchemy.sql.expression.OperatorType, typing.Generic)

function sqlalchemy.sql.expression.distinct(expr: _ColumnExpressionArgument[_T]) → UnaryExpression[_T]¶

Erzeugt eine unäre DISTINCT-Klausel auf Spaltenausdrucksebene.

Dies wendet das Schlüsselwort DISTINCT auf einen **einzelnen Spaltenausdruck** an (d. h. nicht auf die gesamte Anweisung) und rendert ihn **spezifisch an dieser Spaltenposition**; dies wird für die Einbettung in eine Aggregatfunktion verwendet, wie in

from sqlalchemy import distinct, func

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

Das obige würde eine Anweisung erzeugen, die so aussieht:

SELECT user.id, count(DISTINCT user.name) FROM user

Tipp

Die Funktion distinct() wendet DISTINCT **nicht** auf die gesamte SELECT-Anweisung an, sondern wendet einen DISTINCT-Modifikator auf **einzelne Spaltenausdrücke** an. Für die allgemeine Unterstützung von SELECT DISTINCT verwenden Sie die Methode Select.distinct() auf Select.

Die Funktion distinct() ist auch als Spalten-Level-Methode verfügbar, z. B. ColumnElement.distinct(), wie in

stmt = select(func.count(users_table.c.name.distinct()))

Der Operator distinct() unterscheidet sich von der Methode Select.distinct() von Select, die eine SELECT-Anweisung mit angewendetem DISTINCT auf das gesamte Ergebnis setzt, z. B. einen SELECT DISTINCT-Ausdruck. Weitere Informationen finden Sie in dieser Methode.

Siehe auch

Select.distinct()

func

function sqlalchemy.sql.expression.extract(field: str, expr: _ColumnExpressionArgument[Any]) → Extract¶

Gibt ein Extract-Konstrukt zurück.

Dies ist typischerweise als extract() sowie als func.extract aus dem func-Namespace verfügbar.

Parameter:

field¶ –
Das zu extrahierende Feld.

Warnung

Dieses Feld wird als literale SQL-Zeichenfolge verwendet. **Geben Sie KEINE nicht vertrauenswürdigen Eingaben in diese Zeichenfolge ein**.
expr¶ – Eine Spalte oder ein Python-Skalar-Ausdruck, der als rechte Seite des EXTRACT-Ausdrucks dient.

Z. B.

from sqlalchemy import extract
from sqlalchemy import table, column

logged_table = table(
    "user",
    column("id"),
    column("date_created"),
)

stmt = select(logged_table.c.id).where(
    extract("YEAR", logged_table.c.date_created) == 2021
)

Im obigen Beispiel wird die Anweisung verwendet, um IDs aus der Datenbank auszuwählen, bei denen die YEAR-Komponente mit einem bestimmten Wert übereinstimmt.

Ähnlich kann man auch eine extrahierte Komponente auswählen

stmt = select(extract("YEAR", logged_table.c.date_created)).where(
    logged_table.c.id == 1
)

Die Implementierung von EXTRACT kann je nach Datenbank-Backend variieren. Benutzer werden daran erinnert, die Dokumentation ihrer Datenbank zu konsultieren.

function sqlalchemy.sql.expression.false() → False_¶

Gibt ein False_-Konstrukt zurück.

Z. B.

>>> fromsqlalchemyimportfalse>>> print(select(t.c.x).where(false()))SELECT x FROM t WHERE false

Ein Backend, das keine TRUE/FALSE-Konstanten unterstützt, wird als Ausdruck gegen 1 oder 0 gerendert

>>> print(select(t.c.x).where(false()))SELECT x FROM t WHERE 0 = 1

Die Konstanten true() und false() bieten auch eine "Short-Circuit"-Operation innerhalb einer and_()- oder or_()-Konjunktion

>>> print(select(t.c.x).where(or_(t.c.x>5,true())))SELECT x FROM t WHERE true
>>> print(select(t.c.x).where(and_(t.c.x>5,false())))SELECT x FROM t WHERE false

Siehe auch

true()

sqlalchemy.sql.expression.func = <sqlalchemy.sql.functions._FunctionGenerator object>¶

Erzeugt SQL-Funktionsausdrücke.

func ist eine spezielle Objektinstanz, die SQL-Funktionen basierend auf namensbasierten Attributen generiert, z. B.

>>> print(func.count(1))count(:param_1)

Das zurückgegebene Objekt ist eine Instanz von Function und ist wie jedes andere spaltenorientierte SQL-Element und wird auf diese Weise verwendet

>>> print(select(func.count(table.c.id)))SELECT count(sometable.id) FROM sometable

Jeder Name kann an func vergeben werden. Wenn der Funktionsname SQLAlchemy unbekannt ist, wird er exakt so gerendert, wie er ist. Für gängige SQL-Funktionen, die SQLAlchemy kennt, kann der Name als *generische Funktion* interpretiert werden, die entsprechend der Zieldatenbank kompiliert wird

>>> print(func.current_timestamp())CURRENT_TIMESTAMP

Um Funktionen aufzurufen, die in punktgetrennten Paketen vorhanden sind, geben Sie sie auf die gleiche Weise an

>>> print(func.stats.yield_curve(5,10))stats.yield_curve(:yield_curve_1, :yield_curve_2)

SQLAlchemy kann auf den Rückgabetyp von Funktionen aufmerksam gemacht werden, um typspezifisches lexikalisches und ergebnisbasiertes Verhalten zu ermöglichen. Um beispielsweise sicherzustellen, dass eine zeichenkettenbasierte Funktion einen Unicode-Wert zurückgibt und in Ausdrücken als Zeichenkette behandelt wird, geben Sie Unicode als Typ an

>>> print(...     func.my_string("hi", type_=Unicode)...     + " "...     + func.my_string("there", type_=Unicode)... )my_string(:my_string_1) || :my_string_2 || my_string(:my_string_3)

Das von einem func-Aufruf zurückgegebene Objekt ist normalerweise eine Instanz von Function. Dieses Objekt erfüllt die "Spalten"-Schnittstelle, einschließlich Vergleichs- und Beschriftungsfunktionen. Das Objekt kann auch an die Connectable.execute()-Methode eines Connection- oder Engine-Objekts übergeben werden, wo es zuerst in eine SELECT-Anweisung eingehüllt wird

print(connection.execute(func.current_timestamp()).scalar())

In einigen Ausnahmefällen leitet der func-Accessor einen Namen an einen integrierten Ausdruck wie cast() oder extract() um, da diese Namen eine bekannte Bedeutung haben, aber aus SQLAlchemy-Perspektive nicht genau dasselbe wie "Funktionen" sind.

Funktionen, die als "generische" Funktionen interpretiert werden, wissen, wie sie ihren Rückgabetyp automatisch berechnen. Eine Liste bekannter generischer Funktionen finden Sie unter SQL- und generische Funktionen.

Hinweis

Die func-Konstruktion hat nur begrenzte Unterstützung für den Aufruf eigenständiger "gespeicherter Prozeduren", insbesondere solcher mit besonderen Parameterisierungsproblemen.

Weitere Informationen zur Verwendung der DBAPI-Level-Methode callproc() für vollständig traditionelle gespeicherte Prozeduren finden Sie im Abschnitt Aufrufen von gespeicherten Prozeduren und benutzerdefinierten Funktionen.

Siehe auch

Arbeiten mit SQL-Funktionen - im SQLAlchemy Unified Tutorial

Funktion

function sqlalchemy.sql.expression.lambda_stmt(lmb: Callable[[], Any], enable_tracking: bool = True, track_closure_variables: bool = True, track_on: object | None = None, global_track_bound_values: bool = True, track_bound_values: bool = True, lambda_cache: MutableMapping[Tuple[Any, ...], NonAnalyzedFunction | AnalyzedFunction] | None = None) → StatementLambdaElement¶

Erzeugt eine SQL-Anweisung, die als Lambda zwischengespeichert wird.

Der Python-Code im Lambda wird sowohl auf Python-Literale, die zu gebundenen Parametern werden, als auch auf Closure-Variablen, die sich auf Core- oder ORM-Konstrukte beziehen, die variieren können, gescannt. Das Lambda selbst wird nur einmal pro bestimmtem Satz erkannter Konstrukte aufgerufen.

Z. B.

from sqlalchemy import lambda_stmt

stmt = lambda_stmt(lambda: table.select())
stmt += lambda s: s.where(table.c.id == 5)

result = connection.execute(stmt)

Das zurückgegebene Objekt ist eine Instanz von StatementLambdaElement.

Neu in Version 1.4.

Parameter:

lmb¶ – eine Python-Funktion, typischerweise ein Lambda, das keine Argumente entgegennimmt und einen SQL-Ausdruckskonstrukt zurückgibt
enable_tracking¶ – wenn False, wird das Scannen des gegebenen Lambda auf Änderungen in Closure-Variablen oder gebundenen Parametern deaktiviert. Verwenden Sie dies für ein Lambda, das in allen Fällen identische Ergebnisse ohne Parametrisierung liefert.
track_closure_variables¶ – wenn False, werden Änderungen in Closure-Variablen innerhalb des Lambda nicht gescannt. Verwenden Sie dies für ein Lambda, bei dem der Zustand seiner Closure-Variablen niemals die vom Lambda zurückgegebene SQL-Struktur ändert.
track_bound_values¶ – wenn False, wird die Verfolgung von gebundenen Parametern für das gegebene Lambda deaktiviert. Verwenden Sie dies für ein Lambda, das entweder keine gebundenen Werte liefert oder bei dem die anfänglichen gebundenen Werte sich niemals ändern.
global_track_bound_values¶ – wenn False, wird die Verfolgung von gebundenen Parametern für die gesamte Anweisung deaktiviert, einschließlich zusätzlicher Links, die über die StatementLambdaElement.add_criteria()-Methode hinzugefügt werden.
lambda_cache¶ – ein Dictionary oder ein anderes Mapping-ähnliches Objekt, in dem Informationen über den Python-Code des Lambda sowie die verfolgten Closure-Variablen im Lambda selbst gespeichert werden. Standardmäßig ein globaler LRU-Cache. Dieser Cache ist unabhängig vom "compiled_cache", der vom Connection-Objekt verwendet wird.

Siehe auch

Verwendung von Lambdas zur Erzielung erheblicher Geschwindigkeitssteigerungen bei der Anweisungsproduktion

function sqlalchemy.sql.expression.literal(value: Any, type_: _TypeEngineArgument[Any] | None = None, literal_execute: bool = False) → BindParameter[Any]¶

Gibt eine Literal-Klausel zurück, die an einen gebundenen Parameter gebunden ist.

Literal-Klauseln werden automatisch erstellt, wenn Nicht-ClauseElement-Objekte (wie Zeichenketten, Ganzzahlen, Daten usw.) in einer Vergleichsoperation mit einer ColumnElement-Unterklasse, wie z. B. einem Column-Objekt, verwendet werden. Verwenden Sie diese Funktion, um die Generierung einer Literal-Klausel zu erzwingen, die als BindParameter mit einem gebundenen Wert erstellt wird.

Parameter:

value¶ – der zu bindende Wert. Kann jedes Python-Objekt sein, das von der zugrunde liegenden DB-API unterstützt wird, oder über das angegebene Typenargument übersetzbar ist.
type_¶ – ein optionales TypeEngine-Objekt, das eine Bindungs-Parameterübersetzung für dieses Literal bereitstellt.
literal_execute¶ –
optionales Bool, wenn True, versucht die SQL-Engine, den gebundenen Wert zur Ausführungszeit direkt in die SQL-Anweisung zu rendern, anstatt ihn als Parameterwert bereitzustellen.

Neu in Version 2.0.

function sqlalchemy.sql.expression.literal_column(text: str, type_: _TypeEngineArgument[_T] | None = None) → ColumnClause[_T]¶

Erzeugt ein ColumnClause-Objekt, bei dem das Flag column.is_literal auf True gesetzt ist.

literal_column() ist ähnlich wie column(), aber es wird häufiger als "eigenständiger" Spaltenausdruck verwendet, der exakt so gerendert wird, wie er angegeben ist; während column() einen Zeichenkettennamen speichert, der als Teil einer Tabelle angenommen wird und als solche zitiert werden kann, kann literal_column() dies oder jeder andere beliebige spaltenorientierte Ausdruck sein.

Parameter:

text¶ – der Text des Ausdrucks; kann jeder SQL-Ausdruck sein. Quoting-Regeln werden nicht angewendet. Um einen Spaltennamenausdruck anzugeben, der Quoting-Regeln unterliegen soll, verwenden Sie die Funktion column().
type_¶ – ein optionales TypeEngine-Objekt, das Ergebnisübersetzung und zusätzliche Ausdruckssemantik für diese Spalte bereitstellt. Wenn es als None belassen wird, ist der Typ NullType.

Siehe auch

column()

text()

Auswahl mit textuellen Spaltenausdrücken

function sqlalchemy.sql.expression.not_(clause: _ColumnExpressionArgument[_T]) → ColumnElement[_T]¶

Gibt eine Negation der gegebenen Klausel zurück, d. h. NOT(clause).

Der Operator ~ ist auch für alle ColumnElement-Unterklassen überladen, um das gleiche Ergebnis zu erzielen.

function sqlalchemy.sql.expression.null() → Null¶: Gibt ein konstantes Null-Konstrukt zurück.

function sqlalchemy.sql.expression.or_(*clauses)¶

Erzeugt eine Konjunktion von Ausdrücken, die mit OR verbunden sind.

Z. B.

from sqlalchemy import or_

stmt = select(users_table).where(
    or_(users_table.c.name == "wendy", users_table.c.name == "jack")
)

Die or_()-Konjunktion ist auch über den Python-Operator | verfügbar (beachten Sie jedoch, dass zusammengesetzte Ausdrücke in Klammern gesetzt werden müssen, um mit dem Verhalten der Python-Operatorpräzedenz zu funktionieren)

stmt = select(users_table).where(
    (users_table.c.name == "wendy") | (users_table.c.name == "jack")
)

Die or_()-Konstruktion muss mindestens ein positionelles Argument erhalten, um gültig zu sein; eine or_()-Konstruktion ohne Argumente ist mehrdeutig. Um einen "leeren" oder dynamisch generierten or_()-Ausdruck aus einer gegebenen Liste von Ausdrücken zu erzeugen, sollte ein "Standard"-Element von false() (oder einfach False) angegeben werden

from sqlalchemy import false

or_criteria = or_(false(), *expressions)

Der obige Ausdruck wird, wenn keine anderen Ausdrücke vorhanden sind, je nach Backend als Ausdruck false oder 0 = 1 in SQL kompiliert. Wenn Ausdrücke vorhanden sind, wird der Wert false() ignoriert, da er das Ergebnis eines OR-Ausdrucks mit anderen Elementen nicht beeinflusst.

Veraltet seit Version 1.4: Das Element or_() erfordert nun, dass mindestens ein Argument übergeben wird; die Erstellung der or_()-Konstruktion ohne Argumente ist veraltet und gibt eine Deprecation-Warnung aus, während sie weiterhin eine leere SQL-Zeichenkette erzeugt.

Siehe auch

and_()

function sqlalchemy.sql.expression.outparam(key: str, type_: TypeEngine[_T] | None = None) → BindParameter[_T]¶

Erstellt einen „OUT“-Parameter zur Verwendung in Funktionen (gespeicherten Prozeduren) für Datenbanken, die diese unterstützen.

Das outparam kann wie ein regulärer Funktionsparameter verwendet werden. Der "Ausgabewert" ist über das Attribut out_parameters des CursorResult-Objekts verfügbar, das ein Dictionary mit den Werten zurückgibt.

function sqlalchemy.sql.expression.text(text: str) → TextClause¶

Konstruiert eine neue TextClause-Klausel, die einen textuellen SQL-String direkt darstellt.

Z. B.

from sqlalchemy import text

t = text("SELECT * FROM users")
result = connection.execute(t)

Die Vorteile, die text() gegenüber einer einfachen Zeichenkette bietet, sind Backend-neutrale Unterstützung für Bindungsparameter, Ausführungsoptionen pro Anweisung sowie Bindungsparameter- und Ergebnisspaltentypisierung, die es SQLAlchemy-Typkonstrukten ermöglicht, eine Rolle bei der Ausführung einer wörtlich angegebenen Anweisung zu spielen. Die Konstruktion kann auch mit einer .c-Sammlung von Spaltenelementen versehen werden, wodurch sie als Unterabfrage in andere SQL-Ausdruckskonstrukte eingebettet werden kann.

Bindungsparameter werden nach Namen angegeben, im Format :name. Z. B.

t = text("SELECT * FROM users WHERE id=:user_id")
result = connection.execute(t, {"user_id": 12})

Für SQL-Anweisungen, bei denen ein Doppelpunkt wörtlich benötigt wird, wie z. B. in einer Inline-Zeichenkette, verwenden Sie einen Backslash zum Maskieren

t = text(r"SELECT * FROM users WHERE name='\:username'")

Die TextClause-Konstruktion enthält Methoden, die Informationen über die gebundenen Parameter sowie über die Spaltenwerte liefern, die aus der Textanweisung zurückgegeben würden, vorausgesetzt, es handelt sich um eine ausführbare SELECT-Art von Anweisung. Die Methode TextClause.bindparams() wird verwendet, um Details zu gebundenen Parametern bereitzustellen, und die Methode TextClause.columns() ermöglicht die Angabe von Rückgabespalten, einschließlich Namen und Typen

t = (
    text("SELECT * FROM users WHERE id=:user_id")
    .bindparams(user_id=7)
    .columns(id=Integer, name=String)
)

for id, name in connection.execute(t):
    print(id, name)

Die text()-Konstruktion wird in Fällen verwendet, in denen ein wörtlicher SQL-Fragment als Teil einer größeren Abfrage angegeben wird, z. B. für die WHERE-Klausel einer SELECT-Anweisung

s = select(users.c.id, users.c.name).where(text("id=:user_id"))
result = connection.execute(s, {"user_id": 12})

text() wird auch für die Konstruktion einer vollständigen, eigenständigen Anweisung mit reinem Text verwendet. Daher bezeichnet SQLAlchemy sie als Executable-Objekt und kann wie jede andere Anweisung verwendet werden, die an eine .execute()-Methode übergeben wird.

Parameter:

text¶ –

der Text der zu erstellenden SQL-Anweisung. Verwenden Sie :<param>, um Bindungsparameter anzugeben; sie werden in ihr enginespezifisches Format kompiliert.

Warnung

Das Argument text.text für text() kann als Python-Zeichenkettenargument übergeben werden, das als **vertrauenswürdiger SQL-Text** behandelt und wie angegeben gerendert wird. **ÜBERGEBEN SIE KEINE UNVERTRAUENSWÜRDIGE EINGABE AN DIESEN PARAMETER**.

Siehe auch

Auswahl mit textuellen Spaltenausdrücken

function sqlalchemy.sql.expression.true() → True_¶

Gibt ein konstantes True_-Konstrukt zurück.

Z. B.

>>> fromsqlalchemyimporttrue>>> print(select(t.c.x).where(true()))SELECT x FROM t WHERE true

Ein Backend, das keine TRUE/FALSE-Konstanten unterstützt, wird als Ausdruck gegen 1 oder 0 gerendert

>>> print(select(t.c.x).where(true()))SELECT x FROM t WHERE 1 = 1

Die Konstanten true() und false() bieten auch eine "Short-Circuit"-Operation innerhalb einer and_()- oder or_()-Konjunktion

>>> print(select(t.c.x).where(or_(t.c.x>5,true())))SELECT x FROM t WHERE true
>>> print(select(t.c.x).where(and_(t.c.x>5,false())))SELECT x FROM t WHERE false

Siehe auch

false()

function sqlalchemy.sql.expression.try_cast(expression: _ColumnExpressionOrLiteralArgument[Any], type_: _TypeEngineArgument[_T]) → TryCast[_T]¶

Erzeugt einen TRY_CAST-Ausdruck für Backends, die ihn unterstützen; dies ist ein CAST, der NULL für nicht umwandelbare Konvertierungen zurückgibt.

In SQLAlchemy wird diese Konstruktion **nur** vom SQL Server-Dialekt unterstützt und löst eine CompileError aus, wenn sie auf anderen enthaltenen Backends verwendet wird. Drittanbieter-Backends können diese Konstruktion jedoch ebenfalls unterstützen.

Tipp

Da try_cast() aus dem SQL Server-Dialekt stammt, ist es sowohl von sqlalchemy. als auch von sqlalchemy.dialects.mssql importierbar.

try_cast() gibt eine Instanz von TryCast zurück und verhält sich im Allgemeinen ähnlich wie die Cast-Konstruktion; auf SQL-Ebene besteht der Unterschied zwischen CAST und TRY_CAST darin, dass TRY_CAST für einen nicht umwandelbaren Ausdruck NULL zurückgibt, wie z. B. der Versuch, einen String "hi" in einen Integer-Wert umzuwandeln.

Z. B.

from sqlalchemy import select, try_cast, Numeric

stmt = select(try_cast(product_table.c.unit_price, Numeric(10, 4)))

Das Obige würde auf Microsoft SQL Server wie folgt gerendert werden

SELECT TRY_CAST (product_table.unit_price AS NUMERIC(10, 4))
FROM product_table

Neu in Version 2.0.14: try_cast() wurde vom SQL Server-Dialekt zu einer allgemeinen Konstruktion verallgemeinert, die von zusätzlichen Dialekten unterstützt werden kann.

function sqlalchemy.sql.expression.tuple_(*clauses: _ColumnExpressionArgument[Any], types: Sequence[_TypeEngineArgument[Any]] | None = None) → Tuple¶

Gibt ein Tuple zurück.

Die Hauptanwendung besteht darin, eine zusammengesetzte IN-Konstruktion unter Verwendung von ColumnOperators.in_() zu erzeugen.

from sqlalchemy import tuple_

tuple_(table.c.col1, table.c.col2).in_([(1, 2), (5, 12), (10, 19)])

Geändert in Version 1.3.6: Unterstützung für SQLite IN-Tupel hinzugefügt.

Warnung

Die zusammengesetzte IN-Konstruktion wird nicht von allen Backends unterstützt und funktioniert derzeit bekanntermaßen auf PostgreSQL, MySQL und SQLite. Nicht unterstützte Backends lösen eine Unterklasse von DBAPIError aus, wenn ein solcher Ausdruck aufgerufen wird.

function sqlalchemy.sql.expression.type_coerce(expression: _ColumnExpressionOrLiteralArgument[Any], type_: _TypeEngineArgument[_T]) → TypeCoerce[_T]¶

Ordnet einen SQL-Ausdruck einem bestimmten Typ zu, ohne CAST zu rendern.

Z. B.

from sqlalchemy import type_coerce

stmt = select(type_coerce(log_table.date_string, StringDateTime()))

Die obige Konstruktion erzeugt ein TypeCoerce-Objekt, das die Darstellung auf SQL-Seite in keiner Weise verändert, mit möglicher Ausnahme eines generierten Labels, wenn es im Kontext einer Spaltenklausel verwendet wird.

SELECT date_string AS date_string FROM log

Beim Abrufen von Ergebniszeilen wird der Typverarbeitungsprozessor StringDateTime im Auftrag der Spalte date_string auf die Ergebniszeilen angewendet.

Hinweis

Die type_coerce()-Konstruktion rendert keine eigene SQL-Syntax, einschließlich der Tatsache, dass sie keine Klammerung impliziert. Bitte verwenden Sie TypeCoerce.self_group(), wenn eine explizite Klammerung erforderlich ist.

Um dem Ausdruck einen benannten Alias zuzuweisen, verwenden Sie ColumnElement.label().

stmt = select(
    type_coerce(log_table.date_string, StringDateTime()).label("date")
)

Ein Typ, der gebundene Wertbehandlung bietet, wird auch sein Verhalten anwenden, wenn Literalwerte oder bindparam()-Konstrukte an type_coerce() als Ziele übergeben werden. Wenn ein Typ beispielsweise die Methode TypeEngine.bind_expression() oder die Methode TypeEngine.bind_processor() oder Äquivalentes implementiert, werden diese Funktionen zur Kompilierungs-/Ausführungszeit der Anweisung wirksam, wenn ein Literalwert übergeben wird, wie z. B.

# bound-value handling of MyStringType will be applied to the
# literal value "some string"
stmt = select(type_coerce("some string", MyStringType))

Bei der Verwendung von type_coerce() mit zusammengesetzten Ausdrücken beachten Sie, dass **keine Klammern angewendet werden**. Wenn type_coerce() in einem Operator-Kontext verwendet wird, in dem die normalerweise von CAST vorhandenen Klammern notwendig sind, verwenden Sie die Methode TypeCoerce.self_group().

>>> some_integer=column("someint",Integer)>>> some_string=column("somestr",String)>>> expr=type_coerce(some_integer+5,String)+some_string>>> print(expr)someint + :someint_1 || somestr
>>> expr=type_coerce(some_integer+5,String).self_group()+some_string>>> print(expr)(someint + :someint_1) || somestr

Parameter:

expression¶ – Ein SQL-Ausdruck, wie z. B. ein ColumnElement-Ausdruck oder ein Python-String, der in einen gebundenen Literalwert umgewandelt wird.
type_¶ – Eine TypeEngine-Klasse oder -Instanz, die den Typ angibt, zu dem der Ausdruck umgewandelt wird.

Siehe auch

ColumnElement.between()

class sqlalchemy.sql.expression.quoted_name¶

Stellt eine SQL-Identifizierung mit Quoting-Präferenzen dar.

quoted_name ist eine Python-Unicode/Str-Unterklasse, die einen bestimmten Bezeichnernamen zusammen mit einem quote-Flag darstellt. Dieses quote-Flag, wenn es auf True oder False gesetzt ist, überschreibt das automatische Quoting-Verhalten für diesen Bezeichner, um den Namen entweder bedingungslos zu quoten oder nicht zu quoten. Wenn es auf seinem Standardwert None belassen wird, wird das Quoting-Verhalten auf Bezeichnerebene pro Backend angewendet, basierend auf einer Untersuchung des Tokens selbst.

Ein quoted_name-Objekt mit quote=True wird auch daran gehindert, im Falle einer sogenannten "Namensnormalisierungs"-Option modifiziert zu werden. Bestimmte Datenbank-Backends, wie Oracle Database, Firebird und DB2, "normalisieren" Groß-/Kleinschreibung-unempfindliche Namen als Großbuchstaben. Die SQLAlchemy-Dialekte für diese Backends konvertieren von der SQLAlchemy-Konvention "Kleinbuchstaben bedeutet unempfindlich" zu den Großbuchstaben-unempfindlichen Konventionen dieser Backends. Das Flag quote=True verhindert hier diese Konvertierung, um einen Bezeichner zu unterstützen, der auf einem solchen Backend als durchgehend Kleinbuchstaben gequotet ist.

Das quoted_name-Objekt wird normalerweise automatisch erstellt, wenn der Name für wichtige Schemakonstrukte wie Table, Column und andere angegeben wird. Die Klasse kann auch explizit als Name an jede Funktion übergeben werden, die einen Namen empfängt, der gequotet werden kann. Zum Beispiel zur Verwendung der Methode Engine.has_table() mit einem bedingungslos gequoteten Namen

from sqlalchemy import create_engine
from sqlalchemy import inspect
from sqlalchemy.sql import quoted_name

engine = create_engine("oracle+oracledb://some_dsn")
print(inspect(engine).has_table(quoted_name("some_table", True)))

Die obige Logik führt die "hat Tabelle"-Logik gegen das Oracle Database-Backend aus und übergibt den Namen genau als "some_table", ohne in Großbuchstaben zu konvertieren.

Geändert in Version 1.2: Die quoted_name-Konstruktion ist jetzt von sqlalchemy.sql importierbar, zusätzlich zur früheren Position von sqlalchemy.sql.elements.

Mitglieder

quote

Klassensignatur

class sqlalchemy.sql.expression.quoted_name (sqlalchemy.util.langhelpers.MemoizedSlots, builtins.str)

attribute sqlalchemy.sql.expression.quoted_name.quote¶: ob der String bedingungslos gequotet werden soll

Konstruktoren für Modifikatoren von Spaltenelementen¶

Die hier aufgeführten Funktionen sind häufiger als Methoden von jedem ColumnElement-Konstrukt verfügbar, z. B. wird die Funktion label() normalerweise über die Methode ColumnElement.label() aufgerufen.

Objektname	Beschreibung
all_(expr)	Erzeugt einen ALL-Ausdruck.
any_(expr)	Erzeugt einen ANY-Ausdruck.
asc(column)	Erzeugt ein Element für eine aufsteigende `ORDER BY`-Klausel.
between(expr, lower_bound, upper_bound[, symmetric])	Erzeugt eine `BETWEEN`-Prädikatsklausel.
collate(expression, collation)	Gibt die Klausel `expression COLLATE collation` zurück.
desc(column)	Erzeugt ein Element für eine absteigende `ORDER BY`-Klausel.
funcfilter(func, *criterion)	Erzeugt ein `FunctionFilter`-Objekt gegen eine Funktion.
label(name, element[, type_])	Gibt ein `Label`-Objekt für das gegebene `ColumnElement` zurück.
nulls_first(column)	Erzeugt den Modifikator `NULLS FIRST` für einen `ORDER BY`-Ausdruck.
nulls_last(column)	Erzeugt den Modifikator `NULLS LAST` für einen `ORDER BY`-Ausdruck.
nullsfirst	Synonym für die Funktion `nulls_first()`.
nullslast	Legacy-Synonym für die Funktion `nulls_last()`.
over(element[, partition_by, order_by, range_, ...])	Erzeugt ein `Over`-Objekt gegen eine Funktion.
within_group(element, *order_by)	Erzeugt ein `WithinGroup`-Objekt gegen eine Funktion.

function sqlalchemy.sql.expression.all_(expr: _ColumnExpressionArgument[_T]) → CollectionAggregate[bool]¶

Erzeugt einen ALL-Ausdruck.

Für Dialekte wie den von PostgreSQL gilt dieser Operator für die Verwendung des Datentyps ARRAY, für MySQL kann er sich auf eine Unterabfrage beziehen. z. B.

# renders on PostgreSQL:
# '5 = ALL (somearray)'
expr = 5 == all_(mytable.c.somearray)

# renders on MySQL:
# '5 = ALL (SELECT value FROM table)'
expr = 5 == all_(select(table.c.value))

Vergleiche mit NULL können mit None funktionieren

None == all_(mytable.c.somearray)

Die Operatoren any_() / all_() weisen auch ein spezielles "Operand Flipping"-Verhalten auf, so dass, wenn any_() / all_() auf der linken Seite eines Vergleichs mit einem eigenständigen Operator wie ==, != usw. verwendet werden (nicht einschließlich Operator-Methoden wie ColumnOperators.is_()), der gerenderte Ausdruck umgedreht wird.

# would render '5 = ALL (column)`
all_(mytable.c.column) == 5

Oder mit None, was beachte, nicht den üblichen Schritt des Renderns von "IS" durchführt, wie es normalerweise bei NULL der Fall ist.

# would render 'NULL = ALL(somearray)'
all_(mytable.c.somearray) == None

Geändert in Version 1.4.26: Die Verwendung von any_() / all_(), die NULL auf der rechten Seite vergleichen, wurde korrigiert, um sie auf die linke Seite umzudrehen.

Die Spalten-Methode ColumnElement.all_() (nicht zu verwechseln mit der ARRAY-Level-Methode Comparator.all()) ist eine Kurzform für all_(col).

5 == mytable.c.somearray.all_()

Siehe auch

ColumnOperators.all_()

any_()

function sqlalchemy.sql.expression.any_(expr: _ColumnExpressionArgument[_T]) → CollectionAggregate[bool]¶

Erzeugt einen ANY-Ausdruck.

Für Dialekte wie den von PostgreSQL gilt dieser Operator für die Verwendung des Datentyps ARRAY, für MySQL kann er sich auf eine Unterabfrage beziehen. z. B.

# renders on PostgreSQL:
# '5 = ANY (somearray)'
expr = 5 == any_(mytable.c.somearray)

# renders on MySQL:
# '5 = ANY (SELECT value FROM table)'
expr = 5 == any_(select(table.c.value))

Vergleiche mit NULL können mit None oder null() funktionieren.

None == any_(mytable.c.somearray)

Die Operatoren any_() / all_() weisen auch ein spezielles "Operand Flipping"-Verhalten auf, so dass, wenn any_() / all_() auf der linken Seite eines Vergleichs mit einem eigenständigen Operator wie ==, != usw. verwendet werden (nicht einschließlich Operator-Methoden wie ColumnOperators.is_()), der gerenderte Ausdruck umgedreht wird.

# would render '5 = ANY (column)`
any_(mytable.c.column) == 5

Oder mit None, was beachte, nicht den üblichen Schritt des Renderns von "IS" durchführt, wie es normalerweise bei NULL der Fall ist.

# would render 'NULL = ANY(somearray)'
any_(mytable.c.somearray) == None

Geändert in Version 1.4.26: Die Verwendung von any_() / all_(), die NULL auf der rechten Seite vergleichen, wurde korrigiert, um sie auf die linke Seite umzudrehen.

Die Spalten-Methode ColumnElement.any_() (nicht zu verwechseln mit der ARRAY-Level-Methode Comparator.any()) ist eine Kurzform für any_(col).

5 = mytable.c.somearray.any_()

Siehe auch

ColumnOperators.any_()

all_()

function sqlalchemy.sql.expression.asc(column: _ColumnExpressionOrStrLabelArgument[_T]) → UnaryExpression[_T]¶

Erzeugt ein Element für eine aufsteigende ORDER BY-Klausel.

z. B.

from sqlalchemy import asc

stmt = select(users_table).order_by(asc(users_table.c.name))

wird SQL wie folgt erzeugen:

SELECT id, name FROM user ORDER BY name ASC

Die Funktion asc() ist eine eigenständige Version der Methode ColumnElement.asc(), die für alle SQL-Ausdrücke verfügbar ist, z. B.

stmt = select(users_table).order_by(users_table.c.name.asc())

Parameter:: column¶ – Ein ColumnElement (z. B. ein skalarer SQL-Ausdruck), auf den die Operation asc() angewendet werden soll.

Siehe auch

function sqlalchemy.sql.expression.between(expr: _ColumnExpressionOrLiteralArgument[_T], lower_bound: Any, upper_bound: Any, symmetric: bool = False) → BinaryExpression[bool]¶

Erzeugt eine BETWEEN-Prädikatsklausel.

Z. B.

from sqlalchemy import between

stmt = select(users_table).where(between(users_table.c.id, 5, 7))

Würde SQL wie folgt erzeugen:

SELECT id, name FROM user WHERE id BETWEEN :id_1 AND :id_2

Die Funktion between() ist eine eigenständige Version der Methode ColumnElement.between(), die auf allen SQL-Ausdrücken verfügbar ist, wie z. B.:

stmt = select(users_table).where(users_table.c.id.between(5, 7))

Alle an between() übergebenen Argumente, einschließlich des linken Spaltenausdrucks, werden von Python-Skalarwerten umgewandelt, wenn der Wert keine Unterklasse von ColumnElement ist. Beispielsweise können drei feste Werte verglichen werden, wie in:

print(between(5, 3, 7))

Was erzeugen würde

:param_1 BETWEEN :param_2 AND :param_3

Parameter:

expr¶ – Ein Spaltenausdruck, typischerweise eine ColumnElement-Instanz oder alternativ ein Python-Skalar-Ausdruck, der in einen Spaltenausdruck umgewandelt wird und als linke Seite des BETWEEN-Ausdrucks dient.
lower_bound¶ – Ein Spalten- oder Python-Skalar-Ausdruck, der als untere Grenze der rechten Seite des BETWEEN-Ausdrucks dient.
upper_bound¶ – Ein Spalten- oder Python-Skalar-Ausdruck, der als obere Grenze der rechten Seite des BETWEEN-Ausdrucks dient.
symmetric¶ – Wenn True, wird " BETWEEN SYMMETRIC " gerendert. Beachten Sie, dass nicht alle Datenbanken diese Syntax unterstützen.

Siehe auch

function sqlalchemy.sql.expression.collate(expression: _ColumnExpressionArgument[str], collation: str) → BinaryExpression[str]¶

Gibt die Klausel expression COLLATE collation zurück.

z. B.

collate(mycolumn, "utf8_bin")

produziert

mycolumn COLLATE utf8_bin

Der Collation-Ausdruck wird auch gequotet, wenn es sich um einen Groß-/Kleinschreibung-sensitiven Bezeichner handelt, z. B. Großbuchstaben enthält.

Geändert in Version 1.2: Die Quoting wird automatisch auf COLLATE-Ausdrücke angewendet, wenn diese Groß-/Kleinschreibung-sensitiv sind.

function sqlalchemy.sql.expression.desc(column: _ColumnExpressionOrStrLabelArgument[_T]) → UnaryExpression[_T]¶

Erzeugt ein Element für eine absteigende ORDER BY-Klausel.

z. B.

from sqlalchemy import desc

stmt = select(users_table).order_by(desc(users_table.c.name))

wird SQL wie folgt erzeugen:

SELECT id, name FROM user ORDER BY name DESC

Die Funktion desc() ist eine eigenständige Version der Methode ColumnElement.desc(), die für alle SQL-Ausdrücke verfügbar ist, z. B.

stmt = select(users_table).order_by(users_table.c.name.desc())

Parameter:: column¶ – Ein ColumnElement (z. B. ein skalarer SQL-Ausdruck), auf den die Operation desc() angewendet werden soll.

Siehe auch

function sqlalchemy.sql.expression.funcfilter(func: FunctionElement[_T], *criterion: _ColumnExpressionArgument[bool]) → FunctionFilter[_T]¶

Erzeugt ein FunctionFilter-Objekt gegen eine Funktion.

Wird gegen Aggregat- und Fensterfunktionen für Datenbank-Backends verwendet, die die "FILTER"-Klausel unterstützen.

Z. B.

from sqlalchemy import funcfilter

funcfilter(func.count(1), MyClass.name == "some name")

Würde "COUNT(1) FILTER (WHERE myclass.name = ‘some name’)".

Diese Funktion ist auch vom func-Konstrukt selbst über die Methode FunctionElement.filter() verfügbar.

Siehe auch

Spezielle Modifikatoren WITHIN GROUP, FILTER - im Unified Tutorial von SQLAlchemy

FunctionElement.filter()

function sqlalchemy.sql.expression.label(name: str, element: _ColumnExpressionArgument[_T], type_: _TypeEngineArgument[_T] | None = None) → Label[_T]¶

Gibt ein Label-Objekt für das gegebene ColumnElement zurück.

Ein Label ändert den Namen eines Elements in der Spaltenklausel einer SELECT-Anweisung, typischerweise über das SQL-Schlüsselwort AS.

Diese Funktionalität ist bequemer über die ColumnElement.label()-Methode auf ColumnElement verfügbar.

Parameter:

name¶ – Label-Name
obj¶ – ein ColumnElement.

function sqlalchemy.sql.expression.nulls_first(column: _ColumnExpressionArgument[_T]) → UnaryExpression[_T]¶

Erzeugt den Modifikator NULLS FIRST für einen ORDER BY-Ausdruck.

nulls_first() soll den von asc() oder desc() erzeugten Ausdruck modifizieren und gibt an, wie NULL-Werte behandelt werden sollen, wenn sie beim Sortieren angetroffen werden.

from sqlalchemy import desc, nulls_first

stmt = select(users_table).order_by(nulls_first(desc(users_table.c.name)))

Der SQL-Ausdruck aus dem Obigen würde ungefähr so aussehen:

SELECT id, name FROM user ORDER BY name DESC NULLS FIRST

Ähnlich wie asc() und desc(), wird nulls_first() typischerweise vom Spaltenausdruck selbst über die Methode ColumnElement.nulls_first() aufgerufen, anstatt als eigenständige Funktionsversion, wie in

stmt = select(users_table).order_by(
    users_table.c.name.desc().nulls_first()
)

Geändert in Version 1.4: nulls_first() wird in früheren Versionen von nullsfirst() umbenannt. Der vorherige Name bleibt aus Kompatibilitätsgründen erhalten.

Siehe auch

function sqlalchemy.sql.expression.nullsfirst()¶: Synonym für die Funktion nulls_first().

Geändert in Version 2.0.5: Fehlendes Legacy-Symbol nullsfirst() wiederhergestellt.

function sqlalchemy.sql.expression.nulls_last(column: _ColumnExpressionArgument[_T]) → UnaryExpression[_T]¶

Erzeugt den Modifikator NULLS LAST für einen ORDER BY-Ausdruck.

nulls_last() soll den von asc() oder desc() erzeugten Ausdruck modifizieren und gibt an, wie NULL-Werte behandelt werden sollen, wenn sie beim Sortieren angetroffen werden.

from sqlalchemy import desc, nulls_last

stmt = select(users_table).order_by(nulls_last(desc(users_table.c.name)))

Der SQL-Ausdruck aus dem Obigen würde ungefähr so aussehen:

SELECT id, name FROM user ORDER BY name DESC NULLS LAST

Ähnlich wie asc() und desc(), wird nulls_last() typischerweise vom Spaltenausdruck selbst über die Methode ColumnElement.nulls_last() aufgerufen, anstatt als eigenständige Funktionsversion, wie in

stmt = select(users_table).order_by(users_table.c.name.desc().nulls_last())

Geändert in Version 1.4: nulls_last() wird in früheren Versionen von nullslast() umbenannt. Der vorherige Name bleibt aus Kompatibilitätsgründen erhalten.

Siehe auch

function sqlalchemy.sql.expression.nullslast()¶: Legacy-Synonym für die Funktion nulls_last().

Geändert in Version 2.0.5: Fehlendes Legacy-Symbol nullslast() wiederhergestellt.

Erzeugt ein Over-Objekt gegen eine Funktion.

Verwendet auf Aggregat- oder sogenannte "Window"-Funktionen für Backends, die Window-Funktionen unterstützen.

over() wird normalerweise über die Methode FunctionElement.over() aufgerufen, z.B.

func.row_number().over(order_by=mytable.c.some_column)

Würde Folgendes erzeugen:

ROW_NUMBER() OVER(ORDER BY some_column)

Bereiche sind auch über die Parameter over.range_ und over.rows möglich. Diese sich gegenseitig ausschließenden Parameter akzeptieren jeweils ein 2-Tupel, das eine Kombination aus ganzen Zahlen und None enthält.

func.row_number().over(order_by=my_table.c.some_column, range_=(None, 0))

Das Obige würde Folgendes erzeugen:

ROW_NUMBER() OVER(ORDER BY some_column
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)

Ein Wert von None bedeutet "unbounded", ein Wert von Null bedeutet "aktuelle Zeile" und negative / positive Ganzzahlen bedeuten "vorhergehend" und "folgend".

RANGE BETWEEN 5 PRECEDING AND 10 FOLLOWING

func.row_number().over(order_by="x", range_=(-5, 10))

ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

func.row_number().over(order_by="x", rows=(None, 0))

RANGE BETWEEN 2 PRECEDING AND UNBOUNDED FOLLOWING

func.row_number().over(order_by="x", range_=(-2, None))

RANGE BETWEEN 1 FOLLOWING AND 3 FOLLOWING

func.row_number().over(order_by="x", range_=(1, 3))

Parameter:

element¶ – ein FunctionElement, WithinGroup oder ein anderes kompatibles Konstrukt.
partition_by¶ – ein Spaltenelement oder eine Zeichenkette oder eine Liste davon, die als PARTITION BY-Klausel des OVER-Konstrukts verwendet wird.
order_by¶ – ein Spaltenelement oder eine Zeichenkette oder eine Liste davon, die als ORDER BY-Klausel des OVER-Konstrukts verwendet wird.
range_¶ – optionale Bereichsklausel für das Fenster. Dies ist ein Tupelwert, der Ganzzahlen oder None enthalten kann und eine RANGE BETWEEN PRECEDING / FOLLOWING-Klausel rendert.
rows¶ – optionale Zeilenklausel für das Fenster. Dies ist ein Tupelwert, der Ganzzahlen oder None enthalten kann und eine ROWS BETWEEN PRECEDING / FOLLOWING-Klausel rendert.

Diese Funktion ist auch über das func-Konstrukt selbst über die Methode FunctionElement.over() verfügbar.

Siehe auch

Verwendung von Window-Funktionen - im Unified Tutorial von SQLAlchemy

func

within_group()

function sqlalchemy.sql.expression.within_group(element: FunctionElement[_T], *order_by: _ColumnExpressionArgument[Any]) → WithinGroup[_T]¶

Erzeugt ein WithinGroup-Objekt gegen eine Funktion.

Verwendet für sogenannte "ordered set aggregate" und "hypothetical set aggregate" Funktionen, einschließlich percentile_cont, rank, dense_rank usw.

within_group() wird normalerweise über die Methode FunctionElement.within_group() aufgerufen, z.B.

from sqlalchemy import within_group

stmt = select(
    department.c.id,
    func.percentile_cont(0.5).within_group(department.c.salary.desc()),
)

Die obige Anweisung würde SQL ähnlich wie SELECT department.id, percentile_cont(0.5) WITHIN GROUP (ORDER BY department.salary DESC) erzeugen.

Parameter:

element¶ – ein FunctionElement-Konstrukt, typischerweise generiert von func.
*order_by¶ – ein oder mehrere Spaltenelemente, die als ORDER BY-Klausel des WITHIN GROUP-Konstrukts verwendet werden.

Siehe auch

Spezielle Modifikatoren WITHIN GROUP, FILTER - im Unified Tutorial von SQLAlchemy

func

over()

Dokumentation der Klasse Column Element¶

Die Klassen hier werden mit den Konstruktoren generiert, die unter Grundlegende Konstruktoren für Spaltenelemente und Modifikator-Konstruktoren für Spaltenelemente aufgeführt sind.

Objektname	Beschreibung
BinaryExpression	Stellt einen Ausdruck dar, der `LINKS <Operator> RECHTS` ist.
BindParameter	Stellt einen "gebundenen Ausdruck" dar.
Case	Stellt einen `CASE`-Ausdruck dar.
Cast	Stellt einen `CAST`-Ausdruck dar.
ClauseList	Beschreibt eine Liste von Klauseln, die durch einen Operator getrennt sind.
ColumnClause	Stellt einen Spaltenausdruck aus einer beliebigen Textzeichenfolge dar.
ColumnCollection	Sammlung von `ColumnElement`-Instanzen, typischerweise für `FromClause`-Objekte.
ColumnElement	Stellt einen spaltenorientierten SQL-Ausdruck dar, der für die Verwendung in der "Spalten"-Klausel, der WHERE-Klausel usw. einer Anweisung geeignet ist.
ColumnExpressionArgument	Allgemeiner Argument für "Spaltenausdruck".
ColumnOperators	Definiert boolesche, Vergleichs- und andere Operatoren für `ColumnElement`-Ausdrücke.
Extract	Stellt eine SQL EXTRACT-Klausel dar, `extract(field FROM expr)`.
False_	Stellt das Schlüsselwort `false` oder Äquivalentes in einer SQL-Anweisung dar.
FunctionFilter	Stellt eine Funktion FILTER-Klausel dar.
Label	Repräsentiert ein Spalten-Label (AS).
Null	Stellt das NULL-Schlüsselwort in einer SQL-Anweisung dar.
Operators	Basis von Vergleichs- und logischen Operatoren.
Over	Stellt eine OVER-Klausel dar.
SQLColumnExpression	Ein Typ, der verwendet werden kann, um ein beliebiges SQL-Spaltenelement oder ein Objekt anzugeben, das an seiner Stelle fungiert.
TextClause	Stellt ein Literal SQL-Textfragment dar.
True_	Stellt das Schlüsselwort `true` oder Äquivalentes in einer SQL-Anweisung dar.
TryCast	Stellt einen TRY_CAST-Ausdruck dar.
Tuple	Stellt ein SQL-Tupel dar.
TypeCoerce	Stellt einen Wrapper für die Typenkonvertierung auf Python-Seite dar.
UnaryExpression	Definiert einen "unären" Ausdruck.
WithinGroup	Stellt eine WITHIN GROUP (ORDER BY) Klausel dar.
WrapsColumnExpression	Mix-in, das ein `ColumnElement` als Wrapper mit speziellem Labeling-Verhalten für einen Ausdruck definiert, der bereits einen Namen hat.

class sqlalchemy.sql.expression.BinaryExpression¶

Stellt einen Ausdruck dar, der LINKS <Operator> RECHTS ist.

Ein BinaryExpression wird automatisch generiert, wenn zwei Spaltenausdrücke in einem Python-Binärausdruck verwendet werden.

>>> fromsqlalchemy.sqlimportcolumn>>> column("a")+column("b")<sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>>>> print(column("a")+column("b"))a + b

Klassensignatur

class sqlalchemy.sql.expression.BinaryExpression (sqlalchemy.sql.expression.OperatorExpression)

class sqlalchemy.sql.expression.BindParameter¶

Stellt einen "gebundenen Ausdruck" dar.

BindParameter wird explizit über die Funktion bindparam() aufgerufen, wie in

from sqlalchemy import bindparam

stmt = select(users_table).where(
    users_table.c.name == bindparam("username")
)

Eine detaillierte Diskussion darüber, wie BindParameter verwendet wird, finden Sie unter bindparam().

Siehe auch

bindparam()

Mitglieder

effective_value, inherit_cache, render_literal_execute()

Klassensignatur

class sqlalchemy.sql.expression.BindParameter (sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.expression.KeyedColumnElement)

attribute sqlalchemy.sql.expression.BindParameter.effective_value¶

Gibt den Wert dieses gebundenen Parameters zurück, unter Berücksichtigung, ob der Parameter callable gesetzt wurde.

Der Wert callable wird ausgewertet und zurückgegeben, falls vorhanden, andernfalls value.

attribute sqlalchemy.sql.expression.BindParameter.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.BindParameter.render_literal_execute() → BindParameter[_T]¶

Erzeugt eine Kopie dieses gebundenen Parameters, die das Flag BindParameter.literal_execute aktiviert.

Das Flag BindParameter.literal_execute hat zur Folge, dass der Parameter im kompilierten SQL-String im [POSTCOMPILE]-Format gerendert wird, was eine spezielle Form ist, die zur Laufzeit der SQL-Ausführung zu einem Rendering des Literalwerts des Parameters wird. Der Grund dafür ist, die Caching von SQL-Anweisungsstrings zu unterstützen, die pro Anweisung Literalwerte einbetten können, wie z.B. LIMIT- und OFFSET-Parameter, im endgültigen SQL-String, der an den DBAPI übergeben wird. Insbesondere Dialekte möchten diese Methode möglicherweise innerhalb benutzerdefinierter Kompilierungsschemata verwenden.

Neu in Version 1.4.5.

Siehe auch

Caching für Drittanbieter-Dialekte

class sqlalchemy.sql.expression.Case¶

Stellt einen CASE-Ausdruck dar.

Case wird mit der Factory-Funktion case() erzeugt, wie in

from sqlalchemy import case

stmt = select(users_table).where(
    case(
        (users_table.c.name == "wendy", "W"),
        (users_table.c.name == "jack", "J"),
        else_="E",
    )
)

Details zur Verwendung von Case finden Sie unter case().

Siehe auch

case()

Klassensignatur

class sqlalchemy.sql.expression.Case (sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.sql.expression.Cast¶

Stellt einen CAST-Ausdruck dar.

Cast wird mit der Factory-Funktion cast() erzeugt, wie in

from sqlalchemy import cast, Numeric

stmt = select(cast(product_table.c.unit_price, Numeric(10, 4)))

Details zur Verwendung von Cast finden Sie unter cast().

Siehe auch

try_cast()

type_coerce() - eine Alternative zu CAST, die den Typ nur auf der Python-Seite umwandelt, was oft ausreicht, um die korrekte SQL- und Datenkonvertierung zu erzeugen.

Klassensignatur

class sqlalchemy.sql.expression.Cast (sqlalchemy.sql.expression.WrapsColumnExpression)

class sqlalchemy.sql.expression.ClauseList¶

Beschreibt eine Liste von Klauseln, die durch einen Operator getrennt sind.

Standardmäßig ist dies eine kommagetrennte Liste, wie z.B. eine Spaltenliste.

Mitglieder

Klassensignatur

class sqlalchemy.sql.expression.ClauseList (sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.roles.OrderByRole, sqlalchemy.sql.roles.ColumnsClauseRole, sqlalchemy.sql.roles.DMLColumnRole, sqlalchemy.sql.expression.DQLDMLClauseElement)

method sqlalchemy.sql.expression.ClauseList.self_group(against: OperatorType | None = None) → Self | Grouping[Any]¶

Wendet eine "Gruppierung" auf dieses ClauseElement an.

Diese Methode wird von Unterklassen überschrieben, um ein "Gruppierungs"-Konstrukt, d.h. Klammern, zurückzugeben. Insbesondere wird sie von "binären" Ausdrücken verwendet, um sich selbst zu gruppieren, 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 Subqueries normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen benannte verschachtelte SELECT-Anweisungen benötigen).

Beim Zusammensetzen von Ausdrücken wird die Anwendung von self_group() automatisch vorgenommen - der Code des Endbenutzers 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) - UND hat Vorrang vor ODER.

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

class sqlalchemy.sql.expression.ColumnClause¶

Stellt einen Spaltenausdruck aus einer beliebigen Textzeichenfolge dar.

Die ColumnClause, ein leichtgewichtiges Analogon zur Klasse Column, wird typischerweise über die Funktion column() aufgerufen, wie in

from sqlalchemy import column

id, name = column("id"), column("name")
stmt = select(id, name).select_from("user")

Die obige Anweisung würde SQL wie folgt erzeugen:

SELECT id, name FROM user

ColumnClause ist die direkte Oberklasse des Schema-spezifischen Objekts Column. Während die Klasse Column alle gleichen Fähigkeiten wie ColumnClause hat, ist die Klasse ColumnClause in Fällen, in denen die Verhaltensanforderungen auf die einfache SQL-Ausdrucksgenerierung beschränkt sind, eigenständig nutzbar. Das Objekt hat keine der Verbindungen zu Schema-Metadaten oder zu Laufzeitverhalten, die Column hat, daher ist es in diesem Sinne eine "leichtgewichtige" Version von Column.

Vollständige Details zur Verwendung von ColumnClause finden Sie unter column().

Siehe auch

column()

Column

Mitglieder

get_children()

Klassensignatur

class sqlalchemy.sql.expression.ColumnClause (sqlalchemy.sql.roles.DDLReferredColumnRole, sqlalchemy.sql.roles.LabeledColumnExprRole, sqlalchemy.sql.roles.StrAsPlainColumnRole, sqlalchemy.sql.expression.Immutable, sqlalchemy.sql.expression.NamedColumn)

method sqlalchemy.sql.expression.ColumnClause.get_children(*, column_tables=False, **kw)¶

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).

class sqlalchemy.sql.expression.ColumnCollection¶

Sammlung von ColumnElement-Instanzen, typischerweise für FromClause-Objekte.

Das Objekt ColumnCollection ist am häufigsten als Table.c- oder Table.columns-Sammlung auf dem Objekt Table verfügbar, wie unter Zugriff auf Tabellen und Spalten beschrieben.

Die ColumnCollection hat sowohl Mapping- als auch Sequenz-ähnliche Verhaltensweisen. Eine ColumnCollection speichert normalerweise Column-Objekte, die dann sowohl über Mapping-Stil-Zugriff als auch über Attribut-Zugriff erreichbar sind.

Um auf Column-Objekte über den üblichen Attribut-Stil-Zugriff zuzugreifen, geben Sie den Namen wie jedes andere Objektattribut an, z. B. wird eine Spalte namens employee_name wie folgt zugegriffen

>>> employee_table.c.employee_name

Um auf Spalten zuzugreifen, die Namen mit Sonderzeichen oder Leerzeichen haben, wird ein indexbasierter Zugriff verwendet, wie unten gezeigt, der eine Spalte namens employee ' payment zugreift

>>> employee_table.c["employee ' payment"]

Da das Objekt ColumnCollection eine Python-Dictionary-Schnittstelle bietet, sind gängige Dictionary-Methodennamen wie ColumnCollection.keys(), ColumnCollection.values() und ColumnCollection.items() verfügbar, was bedeutet, dass Datenbankspalten, die unter diesen Namen indiziert sind, ebenfalls einen indexbasierten Zugriff verwenden müssen

>>> employee_table.c["values"]

Der Name, unter dem eine Column vorhanden wäre, ist normalerweise der des Parameters Column.key. In einigen Kontexten, wie z. B. einem Select-Objekt, das einen Label-Stil verwendet, der mit der Methode Select.set_label_style() gesetzt wurde, kann eine Spalte eines bestimmten Schlüssels stattdessen unter einem bestimmten Label-Namen wie tablename_columnname dargestellt werden

>>> from sqlalchemy import select, column, table
>>> from sqlalchemy import LABEL_STYLE_TABLENAME_PLUS_COL
>>> t = table("t", column("c"))
>>> stmt = select(t).set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL)
>>> subq = stmt.subquery()
>>> subq.c.t_c
<sqlalchemy.sql.elements.ColumnClause at 0x7f59dcf04fa0; t_c>

ColumnCollection indiziert die Spalten auch in der Reihenfolge und ermöglicht den Zugriff auf sie über ihre ganzzahlige Position

>>> cc[0]
Column('x', Integer(), table=None)
>>> cc[1]
Column('y', Integer(), table=None)

Neu in Version 1.4: ColumnCollection ermöglicht den ganzzahligen indexbasierten Zugriff auf die Sammlung.

Das Iterieren der Sammlung liefert die Spaltenausdrücke in der Reihenfolge

>>> list(cc)
[Column('x', Integer(), table=None),
 Column('y', Integer(), table=None)]

Das Basisobjekt ColumnCollection kann Duplikate speichern, was entweder zwei Spalten mit demselben Schlüssel bedeuten kann, in diesem Fall ist die Spalte, die über Schlüsselzugriff zurückgegeben wird, beliebig

>>> x1, x2 = Column("x", Integer), Column("x", Integer)
>>> cc = ColumnCollection(columns=[(x1.name, x1), (x2.name, x2)])
>>> list(cc)
[Column('x', Integer(), table=None),
 Column('x', Integer(), table=None)]
>>> cc["x"] is x1
False
>>> cc["x"] is x2
True

Oder es kann auch dieselbe Spalte mehrmals bedeuten. Diese Fälle werden unterstützt, da ColumnCollection verwendet wird, um die Spalten in einer SELECT-Anweisung darzustellen, die Duplikate enthalten kann.

Eine spezielle Unterklasse DedupeColumnCollection existiert, die stattdessen das ältere Verhalten von SQLAlchemy beibehält, Duplikate nicht zuzulassen. Diese Sammlung wird für Schema-Level-Objekte wie Table und PrimaryKeyConstraint verwendet, wo diese Deduzierung hilfreich ist. Die Klasse DedupeColumnCollection hat auch zusätzliche Mutationsmethoden, da die Schema-Konstrukte mehr Anwendungsfälle haben, die das Entfernen und Ersetzen von Spalten erfordern.

Geändert in Version 1.4: ColumnCollection speichert nun doppelte Spaltenschlüssel sowie dieselbe Spalte in mehreren Positionen. Die Klasse DedupeColumnCollection wurde hinzugefügt, um das frühere Verhalten in Fällen beizubehalten, in denen Deduzierung sowie zusätzliche Ersetzungs-/Entfernungsoperationen erforderlich sind.

Mitglieder

add(), as_readonly(), clear(), compare(), contains_column(), corresponding_column(), get(), items(), keys(), update(), values()

Klassensignatur

class sqlalchemy.sql.expression.ColumnCollection (typing.Generic)

method sqlalchemy.sql.expression.ColumnCollection.add(column: ColumnElement[Any], key: _COLKEY | None = None) → None¶: Fügt eine Spalte zu dieser ColumnCollection hinzu.

Hinweis

Diese Methode wird **nicht normalerweise vom Endbenutzer-Code verwendet**, da die ColumnCollection normalerweise Teil eines vorhandenen Objekts wie einer Table ist. Um eine Column zu einem vorhandenen Table-Objekt hinzuzufügen, verwenden Sie die Methode Table.append_column().

method sqlalchemy.sql.expression.ColumnCollection.as_readonly() → ReadOnlyColumnCollection[_COLKEY, _COL_co]¶: Gibt eine "schreibgeschützte" Form dieser ColumnCollection zurück.

method sqlalchemy.sql.expression.ColumnCollection.clear() → NoReturn¶: Dictionary clear() ist für ColumnCollection nicht implementiert.

method sqlalchemy.sql.expression.ColumnCollection.compare(other: ColumnCollection[Any, Any]) → bool¶: Vergleicht diese ColumnCollection mit einer anderen basierend auf den Namen der Schlüssel

method sqlalchemy.sql.expression.ColumnCollection.contains_column(col: ColumnElement[Any]) → bool¶: Prüft, ob ein Spaltenobjekt in dieser Sammlung vorhanden ist

method sqlalchemy.sql.expression.ColumnCollection.corresponding_column(column: _COL, require_embedded: bool = False) → _COL | _COL_co | None¶

Gibt für ein ColumnElement das exportierte ColumnElement-Objekt aus dieser ColumnCollection zurück, das diesem ursprünglichen ColumnElement über eine gemeinsame Elter-Spalte entspricht.

Parameter:

column¶ – das Ziel- ColumnElement, das abgeglichen werden soll.
require_embedded¶ – gibt nur entsprechende Spalten für das gegebene ColumnElement zurück, wenn das gegebene 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.corresponding_column() - ruft diese Methode auf der von Selectable.exported_columns zurückgegebenen Sammlung auf.

Geändert in Version 1.4: die Implementierung für corresponding_column wurde auf die ColumnCollection selbst verschoben.

method sqlalchemy.sql.expression.ColumnCollection.get(key: str, default: _COL | None = None) → _COL | _COL_co | None¶: Ruft ein ColumnClause- oder Column-Objekt basierend auf einem Zeichenketten-Schlüsselnamen aus dieser ColumnCollection ab.

method sqlalchemy.sql.expression.ColumnCollection.items() → List[Tuple[_COLKEY, _COL_co]]¶: Gibt eine Sequenz von (Schlüssel, Spalte)-Tupeln für alle Spalten in dieser Sammlung zurück, die jeweils aus einem Zeichenketten-Schlüsselnamen und einem ColumnClause- oder Column-Objekt bestehen.

method sqlalchemy.sql.expression.ColumnCollection.keys() → List[_COLKEY]¶: Gibt eine Sequenz von Zeichenketten-Schlüsselnamen für alle Spalten in dieser Sammlung zurück.

method sqlalchemy.sql.expression.ColumnCollection.update(iter_: Any) → NoReturn¶: Dictionary update() ist für ColumnCollection nicht implementiert.

method sqlalchemy.sql.expression.ColumnCollection.values() → List[_COL_co]¶: Gibt eine Sequenz von ColumnClause- oder Column-Objekten für alle Spalten in dieser Sammlung zurück.

class sqlalchemy.sql.expression.ColumnElement¶

Stellt einen spaltenorientierten SQL-Ausdruck dar, der für die Verwendung in der "Spalten"-Klausel, der WHERE-Klausel usw. einer Anweisung geeignet ist.

Während die bekannteste Art von ColumnElement das Column-Objekt ist, dient ColumnElement als Grundlage für jede Einheit, die in einem SQL-Ausdruck vorhanden sein kann, einschließlich der Ausdrücke selbst, SQL-Funktionen, gebundenen Parametern, literalen Ausdrücken, Schlüsselwörtern wie NULL usw. ColumnElement ist die ultimative Basisklasse für all diese Elemente.

Eine Vielzahl von SQLAlchemy Core-Funktionen arbeitet auf der Ebene von SQL-Ausdrücken und sind darauf ausgelegt, Instanzen von ColumnElement als Argumente zu akzeptieren. Diese Funktionen dokumentieren normalerweise, dass sie einen "SQL-Ausdruck" als Argument akzeptieren. Dies bedeutet in Bezug auf SQLAlchemy normalerweise eine Eingabe, die entweder bereits in Form eines ColumnElement-Objekts vorliegt oder ein Wert, der **erzwungen** werden kann, um eines zu werden. Die Erzwingungsregeln, die die meisten, aber nicht alle SQLAlchemy Core-Funktionen in Bezug auf SQL-Ausdrücke befolgen, sind wie folgt:

ein literaler Python-Wert, wie z. B. eine Zeichenkette, eine Ganzzahl oder ein Fließkommawert, ein Boolescher Wert, ein Datum/Uhrzeit-Objekt, ein Decimal-Objekt oder praktisch jedes andere Python-Objekt, wird in einen „literalen gebundenen Wert“ umgewandelt. Dies bedeutet im Allgemeinen, dass ein bindparam() erzeugt wird, der den gegebenen Wert in das Konstrukt einbettet; das resultierende BindParameter-Objekt ist eine Instanz von ColumnElement. Der Python-Wert wird zur Ausführungszeit als parametrisiertes Argument an die Methoden execute() oder executemany() des DBAPI gesendet, nachdem SQLAlchemy-typspezifische Konverter (z. B. die von zugehörigen TypeEngine-Objekten) auf den Wert angewendet wurden.

ein spezieller Objektwert, typischerweise ORM-Level-Konstrukte, die einen Zugriff auf eine Methode namens __clause_element__() haben. Das Core-Expressionsystem sucht nach dieser Methode, wenn ein Objekt eines ansonsten unbekannten Typs an eine Funktion übergeben wird, die versucht, das Argument in ein ColumnElement und manchmal in einen SelectBase-Ausdruck umzuwandeln. Dies wird innerhalb des ORM verwendet, um von ORM-spezifischen Objekten wie gemappten Klassen und gemappten Attributen in Core-Ausdrucksobjekte zu konvertieren.

Der Python-Wert None wird typischerweise als NULL interpretiert, was in SQLAlchemy Core eine Instanz von null() erzeugt.

Ein ColumnElement bietet die Möglichkeit, neue ColumnElement-Objekte mithilfe von Python-Ausdrücken zu generieren. Das bedeutet, dass Python-Operatoren wie ==, != und < überladen sind, um SQL-Operationen nachzuahmen und die Instanziierung weiterer ColumnElement-Instanzen zu ermöglichen, die aus anderen, grundlegenderen ColumnElement-Objekten zusammengesetzt sind. Zum Beispiel können zwei ColumnClause-Objekte mit dem Additionsoperator + addiert werden, um ein BinaryExpression zu erzeugen. Sowohl ColumnClause als auch BinaryExpression sind Unterklassen von ColumnElement

>>> fromsqlalchemy.sqlimportcolumn>>> column("a")+column("b")<sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>>>> print(column("a")+column("b"))a + b

Siehe auch

Column

column()

Mitglieder

__eq__(), __le__(), __lt__(), __ne__(), all_(), allows_lambda, anon_key_label, anon_label, any_(), asc(), base_columns, between(), bitwise_and(), bitwise_lshift(), bitwise_not(), bitwise_or(), bitwise_rshift(), bitwise_xor(), bool_op(), cast(), collate(), comparator, compare(), compile(), concat(), contains(), desc(), description, distinct(), endswith(), entity_namespace, expression, foreign_keys, get_children(), icontains(), iendswith(), ilike(), in_(), inherit_cache, is_(), is_clause_element, is_distinct_from(), is_dml, is_not(), is_not_distinct_from(), is_selectable, isnot(), isnot_distinct_from(), istartswith(), key, label(), like(), match(), negation_clause, not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), params(), primary_key, proxy_set, regexp_match(), regexp_replace(), reverse_operate(), self_group(), shares_lineage(), startswith(), stringify_dialect, supports_execution, timetuple, type, unique_params(), uses_inspection

Klassensignatur

class sqlalchemy.sql.expression.ColumnElement (sqlalchemy.sql.roles.ColumnArgumentOrKeyRole, sqlalchemy.sql.roles.StatementOptionRole, sqlalchemy.sql.roles.WhereHavingRole, sqlalchemy.sql.roles.BinaryElementRole, sqlalchemy.sql.roles.OrderByRole, sqlalchemy.sql.roles.ColumnsClauseRole, sqlalchemy.sql.roles.LimitOffsetRole, sqlalchemy.sql.roles.DMLColumnRole, sqlalchemy.sql.roles.DDLConstraintColumnRole, sqlalchemy.sql.roles.DDLExpressionRole, sqlalchemy.sql.expression.SQLColumnExpression, sqlalchemy.sql.expression.DQLDMLClauseElement)

method sqlalchemy.sql.expression.ColumnElement.__eq__(other: Any) → ColumnOperators¶

inherited from the sqlalchemy.sql.expression.ColumnOperators.__eq__ method of ColumnOperators

Implementiert den == Operator.

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

method sqlalchemy.sql.expression.ColumnElement.__le__(other: Any) → ColumnOperators¶

inherited from the sqlalchemy.sql.expression.ColumnOperators.__le__ method of ColumnOperators

Implementiert den Operator <=.

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

method sqlalchemy.sql.expression.ColumnElement.__lt__(other: Any) → ColumnOperators¶

inherited from the sqlalchemy.sql.expression.ColumnOperators.__lt__ method of ColumnOperators

Implementiert den Operator <.

In einem Spaltenkontext wird die Klausel a < b erzeugt.

method sqlalchemy.sql.expression.ColumnElement.__ne__(other: Any) → ColumnOperators¶

inherited from the sqlalchemy.sql.expression.ColumnOperators.__ne__ method of ColumnOperators

Implementiert den Operator !=.

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

method sqlalchemy.sql.expression.ColumnElement.all_() → ColumnOperators¶

inherited from the ColumnOperators.all_() method of ColumnOperators

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

Siehe die Dokumentation für all_() für Beispiele.

Hinweis

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

attribute sqlalchemy.sql.expression.ColumnElement.allows_lambda = True¶

attribute sqlalchemy.sql.expression.ColumnElement.anon_key_label¶: Deprecated since version 1.4: Das Attribut ColumnElement.anon_key_label ist jetzt privat und der öffentliche Zugriff darauf ist veraltet.

attribute sqlalchemy.sql.expression.ColumnElement.anon_label¶: Deprecated since version 1.4: Das Attribut ColumnElement.anon_label ist jetzt privat und der öffentliche Zugriff darauf ist veraltet.

method sqlalchemy.sql.expression.ColumnElement.any_() → ColumnOperators¶

inherited from the ColumnOperators.any_() method of ColumnOperators

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

Siehe die Dokumentation für any_() für Beispiele.

Hinweis

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

method sqlalchemy.sql.expression.ColumnElement.asc() → ColumnOperators¶: inherited from the ColumnOperators.asc() method of ColumnOperators

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

attribute sqlalchemy.sql.expression.ColumnElement.base_columns¶

method sqlalchemy.sql.expression.ColumnElement.between(cleft: Any, cright: Any, symmetric: bool = False) → ColumnOperators¶: inherited from the ColumnOperators.between() method of ColumnOperators

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

method sqlalchemy.sql.expression.ColumnElement.bitwise_and(other: Any) → ColumnOperators¶: inherited from the ColumnOperators.bitwise_and() method of ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.sql.expression.ColumnElement.bitwise_lshift(other: Any) → ColumnOperators¶: inherited from the ColumnOperators.bitwise_lshift() method of ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.sql.expression.ColumnElement.bitwise_not() → ColumnOperators¶: inherited from the ColumnOperators.bitwise_not() method of ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.sql.expression.ColumnElement.bitwise_or(other: Any) → ColumnOperators¶: inherited from the ColumnOperators.bitwise_or() method of ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.sql.expression.ColumnElement.bitwise_rshift(other: Any) → ColumnOperators¶: inherited from the ColumnOperators.bitwise_rshift() method of ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.sql.expression.ColumnElement.bitwise_xor(other: Any) → ColumnOperators¶: inherited from the ColumnOperators.bitwise_xor() method of ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

methode sqlalchemy.sql.expression.ColumnElement.bool_op(opstring: str, precedence: int = 0, python_impl: Callable[[...], Any] | None = None) → Callable[[Any], Operators]¶

geerbt von der Operators.bool_op() Methode von Operators

Gibt einen benutzerdefinierten booleschen Operator zurück.

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.cast(type_: _TypeEngineArgument[_OPT]) → Cast[_OPT]¶

Erzeugt einen Typ-Cast, d. h. CAST(<expression> AS <type>).

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

Siehe auch

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

type_coerce()

methode sqlalchemy.sql.expression.ColumnElement.collate(collation: str) → ColumnOperators¶: geerbt von der ColumnOperators.collate() Methode von ColumnOperators

Erzeugt eine collate()-Klausel gegen das übergeordnete Objekt, unter Angabe des Kollationsstrings.

Siehe auch

collate()

attribut sqlalchemy.sql.expression.ColumnElement.comparator¶

methode sqlalchemy.sql.expression.ColumnElement.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 subclass compare() Methoden verarbeitet werden und zur Modifizierung der Vergleichskriterien verwendet werden können (siehe ColumnElement).

methode sqlalchemy.sql.expression.ColumnElement.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 sollen. 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 Argument bind.
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

methode sqlalchemy.sql.expression.ColumnElement.concat(other: Any) → ColumnOperators¶

geerbt von der ColumnOperators.concat() Methode von ColumnOperators

Implementiert den 'concat'-Operator.

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

methode sqlalchemy.sql.expression.ColumnElement.contains(other: Any, **kw: Any) → ColumnOperators¶

geerbt von der ColumnOperators.contains() Methode von ColumnOperators

Implementiert den 'contains'-Operator.

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

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

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale String-Werte kann das Flag ColumnOperators.contains.autoescape auf True gesetzt werden, um das Escaping von Vorkommen dieser Zeichen innerhalb des String-Wertes anzuwenden, damit sie als sie selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.contains.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck kein literaler String ist.

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher String-Wert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht escaped, es sei denn, das Flag ColumnOperators.contains.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.contains("foo%bar", autoescape=True)
```
Wird gerendert als
```
somecolumn LIKE '%' || :param || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.contains("foo/%bar", escape="^")
```
Wird gerendert als
```
somecolumn LIKE '%' || :param || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.contains.autoescape kombiniert werden.
```
somecolumn.contains("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.desc() → ColumnOperators¶: geerbt von der ColumnOperators.desc() Methode von ColumnOperators

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

attribut sqlalchemy.sql.expression.ColumnElement.description¶: geerbt von der ClauseElement.description Attribut von ClauseElement

methode sqlalchemy.sql.expression.ColumnElement.distinct() → ColumnOperators¶: geerbt von der ColumnOperators.distinct() Methode von ColumnOperators

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

methode sqlalchemy.sql.expression.ColumnElement.endswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators¶

geerbt von der ColumnOperators.endswith() Methode von ColumnOperators

Implementiert den 'endswith'-Operator.

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

column LIKE '%' || <other>

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale String-Werte kann das Flag ColumnOperators.endswith.autoescape auf True gesetzt werden, um das Escaping von Vorkommen dieser Zeichen innerhalb des String-Wertes anzuwenden, damit sie als sie selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.endswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck kein literaler String ist.

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher String-Wert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht escaped, es sei denn, das Flag ColumnOperators.endswith.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.endswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
somecolumn LIKE '%' || :param ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.endswith("foo/%bar", escape="^")
```
Wird gerendert als
```
somecolumn LIKE '%' || :param ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.endswith.autoescape kombiniert werden.
```
somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

attribut sqlalchemy.sql.expression.ColumnElement.entity_namespace¶: geerbt von der ClauseElement.entity_namespace Attribut von ClauseElement

attribut sqlalchemy.sql.expression.ColumnElement.expression¶

Gibt einen Spaltenausdruck zurück.

Teil der Inspektionsschnittstelle; gibt sich selbst zurück.

attribut sqlalchemy.sql.expression.ColumnElement.foreign_keys: AbstractSet[ForeignKey] = frozenset({})¶

methode sqlalchemy.sql.expression.ColumnElement.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).

methode sqlalchemy.sql.expression.ColumnElement.icontains(other: Any, **kw: Any) → ColumnOperators¶

geerbt von der ColumnOperators.icontains() Methode von ColumnOperators

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

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

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

Z. B.

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

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

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenkettenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag ColumnOperators.icontains.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.icontains("foo%bar", autoescape=True)
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.icontains("foo/%bar", escape="^")
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.contains.autoescape kombiniert werden.
```
somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.iendswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators¶

geerbt von der ColumnOperators.iendswith() Methode von ColumnOperators

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

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

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

Z. B.

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

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

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenkettenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag ColumnOperators.iendswith.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.iendswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.iendswith("foo/%bar", escape="^")
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.iendswith.autoescape kombiniert werden.
```
somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.ilike(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.ilike() Methode von ColumnOperators

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

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

lower(a) LIKE lower(other)

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

a ILIKE other

Z. B.

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

Parameter:

other¶ – Ausdruck, der verglichen werden soll
escape¶ –
optionales Escape-Zeichen, rendert das ESCAPE Schlüsselwort, z. B.
```
somecolumn.ilike("foo/%bar", escape="/")
```

Siehe auch

ColumnOperators.is_not()

methode sqlalchemy.sql.expression.ColumnElement.in_(other: Any) → ColumnOperators¶

geerbt von der ColumnOperators.in_() Methode von ColumnOperators

Implementiert den in Operator.

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

Der angegebene Parameter other kann sein

Eine Liste von literalen Werten, z. B.
```
stmt.where(column.in_([1, 2, 3]))
```
In dieser Aufrufform wird die Liste der Elemente in eine Menge von gebundenen Parametern der gleichen Länge wie die angegebene Liste umgewandelt.
```
WHERE COL IN (?, ?, ?)
```
Eine Liste von Tupeln kann bereitgestellt werden, wenn der Vergleich gegen ein tuple_() mit mehreren Ausdrücken erfolgt.
```
from sqlalchemy import tuple_

stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))
```
Eine leere Liste, z. B.
```
stmt.where(column.in_([]))
```
In dieser Aufrufform rendert der Ausdruck einen "leeren Mengen"-Ausdruck. Diese Ausdrücke sind auf einzelne Backends zugeschnitten und versuchen im Allgemeinen, eine leere SELECT-Anweisung als Unterabfrage zu erhalten. Auf SQLite ist der Ausdruck
```
WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Geändert in Version 1.4: Leere IN-Ausdrücke verwenden nun in allen Fällen eine zur Laufzeit generierte SELECT-Unterabfrage.
Ein gebundener Parameter, z. B. bindparam(), kann verwendet werden, wenn er das Flag bindparam.expanding enthält.
```
stmt.where(column.in_(bindparam("value", expanding=True)))
```
In dieser Aufrufform rendert der Ausdruck einen speziellen nicht-SQL-Platzhalter-Ausdruck, der wie folgt aussieht:
```
WHERE COL IN ([EXPANDING_value])
```
Dieser Platzhalter-Ausdruck wird zur Laufzeit der Anweisung abgefangen und in die variable Anzahl von gebundenen Parametern umgewandelt, wie zuvor gezeigt. Wenn die Anweisung ausgeführt würde als
```
connection.execute(stmt, {"value": [1, 2, 3]})
```
Die Datenbank würde für jeden Wert einen gebundenen Parameter erhalten.
```
WHERE COL IN (?, ?, ?)
```
Neu in Version 1.2: "expanding" gebundene Parameter hinzugefügt.

Wenn eine leere Liste übergeben wird, wird ein spezieller "leere Liste"-Ausdruck gerendert, der für die verwendete Datenbank spezifisch ist. Auf SQLite wäre dies
```
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Neu in Version 1.3: "expanding" gebundene Parameter unterstützen nun leere Listen.

ein select()-Konstrukt, was normalerweise eine korrelierte Skalar-SELECT-Abfrage ist.

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

In dieser Aufrufform wird ColumnOperators.in_() wie gegeben gerendert.

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

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

attribut sqlalchemy.sql.expression.ColumnElement.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.ColumnElement.is_(other: Any) → ColumnOperators¶

geerbt von der ColumnOperators.is_() Methode von ColumnOperators

Implementiert den IS Operator.

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

Siehe auch

attribut sqlalchemy.sql.expression.ColumnElement.is_clause_element = True¶

methode sqlalchemy.sql.expression.ColumnElement.is_distinct_from(other: Any) → ColumnOperators¶

geerbt von der ColumnOperators.is_distinct_from() Methode von ColumnOperators

Implementiert den IS DISTINCT FROM Operator.

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

attribut sqlalchemy.sql.expression.ColumnElement.is_dml = False¶

methode sqlalchemy.sql.expression.ColumnElement.is_not(other: Any) → ColumnOperators¶

geerbt von der ColumnOperators.is_not() Methode von ColumnOperators

Implementiert den IS NOT Operator.

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

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.is_not_distinct_from(other: Any) → ColumnOperators¶

geerbt von der ColumnOperators.is_not_distinct_from() Methode von ColumnOperators

Implementiert den IS NOT DISTINCT FROM Operator.

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

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

attribut sqlalchemy.sql.expression.ColumnElement.is_selectable = False¶

methode sqlalchemy.sql.expression.ColumnElement.isnot(other: Any) → ColumnOperators¶

geerbt von der ColumnOperators.isnot() Methode von ColumnOperators

Implementiert den IS NOT Operator.

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

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.isnot_distinct_from(other: Any) → ColumnOperators¶

geerbt von der ColumnOperators.isnot_distinct_from() Methode von ColumnOperators

Implementiert den IS NOT DISTINCT FROM Operator.

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

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

methode sqlalchemy.sql.expression.ColumnElement.istartswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators¶

geerbt von der ColumnOperators.istartswith() Methode von ColumnOperators

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

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

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

Z. B.

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

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

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenkettenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag ColumnOperators.istartswith.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.istartswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.istartswith("foo/%bar", escape="^")
```
Wird gerendert als
```
lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.istartswith.autoescape kombiniert werden.
```
somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

attribut sqlalchemy.sql.expression.ColumnElement.key: str | None = None¶

Der "Schlüssel", der in einigen Fällen dieses Objekt in einem Python-Namespace bezeichnet.

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

methode sqlalchemy.sql.expression.ColumnElement.label(name: str | None) → Label[_T]¶

Erzeugt ein Spalten-Label (Alias), d. h. <spaltenname> AS <name>.

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

Wenn ‘name’ None ist, wird ein anonymer Labelname generiert.

methode sqlalchemy.sql.expression.ColumnElement.like(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.like() Methode von ColumnOperators

Implementiert den like Operator.

In einem Spaltenkontext wird der Ausdruck erzeugt

a LIKE other

Z. B.

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

Parameter:

other¶ – Ausdruck, der verglichen werden soll
escape¶ –
optionales Escape-Zeichen, rendert das ESCAPE Schlüsselwort, z. B.
```
somecolumn.like("foo/%bar", escape="/")
```

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.match(other: Any, **kwargs: Any) → ColumnOperators¶

geerbt von der ColumnOperators.match() Methode von ColumnOperators

Implementiert einen datenbankspezifischen 'match'-Operator.

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

PostgreSQL - rendert x @@ plainto_tsquery(y)

Geändert in Version 2.0: plainto_tsquery() wird jetzt anstelle von to_tsquery() für PostgreSQL verwendet; für Kompatibilität mit anderen Formen siehe Volltextsuche.
MySQL - rendert MATCH (x) AGAINST (y IN BOOLEAN MODE)

Siehe auch

match - MySQL-spezifische Konstruktion mit zusätzlichen Funktionen.
Oracle Database - rendert CONTAINS(x, y)
andere Backends können spezielle Implementierungen bereitstellen.
Backends ohne spezielle Implementierung geben den Operator als „MATCH“ aus. Dies ist beispielsweise mit SQLite kompatibel.

attribut sqlalchemy.sql.expression.ColumnElement.negation_clause: ColumnElement[bool]¶

methode sqlalchemy.sql.expression.ColumnElement.not_ilike(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.not_ilike() Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.ilike(), also ~x.ilike(y).

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.not_in(other: Any) → ColumnOperators¶

geerbt von der ColumnOperators.not_in() Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.in_(), also ~x.in_(y).

Wenn other eine leere Sequenz ist, erzeugt der Compiler einen "leeren not in"-Ausdruck. Dieser entspricht standardmäßig dem Ausdruck "1 = 1", um immer wahr zu sein. Die create_engine.empty_in_strategy kann verwendet werden, um dieses Verhalten zu ändern.

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

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.not_like(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.not_like() Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.like(), also ~x.like(y).

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.notilike(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.notilike() Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.ilike(), also ~x.ilike(y).

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.notin_(other: Any) → ColumnOperators¶

geerbt von der ColumnOperators.notin_() Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.in_(), also ~x.in_(y).

Wenn other eine leere Sequenz ist, erzeugt der Compiler einen "leeren not in"-Ausdruck. Dieser entspricht standardmäßig dem Ausdruck "1 = 1", um immer wahr zu sein. Die create_engine.empty_in_strategy kann verwendet werden, um dieses Verhalten zu ändern.

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

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.notlike(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.notlike() Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.like(), also ~x.like(y).

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnElement.nulls_first() → ColumnOperators¶: geerbt von der ColumnOperators.nulls_first() Methode von ColumnOperators

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

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

methode sqlalchemy.sql.expression.ColumnElement.nulls_last() → ColumnOperators¶: geerbt von der ColumnOperators.nulls_last() Methode von ColumnOperators

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

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

methode sqlalchemy.sql.expression.ColumnElement.nullsfirst() → ColumnOperators¶: geerbt von der ColumnOperators.nullsfirst() Methode von ColumnOperators

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

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

methode sqlalchemy.sql.expression.ColumnElement.nullslast() → ColumnOperators¶: geerbt von der ColumnOperators.nullslast() Methode von ColumnOperators

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

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

methode sqlalchemy.sql.expression.ColumnElement.op(opstring: str, precedence: int = 0, is_comparison: bool = False, return_type: Type[TypeEngine[Any]] | TypeEngine[Any] | None = None, python_impl: Callable[..., Any] | None = None) → Callable[[Any], Operators]¶

geerbt von der Operators.op() Methode von Operators

Erzeugt eine generische Operatorfunktion.

z. B.

somecolumn.op("*")(5)

produziert

somecolumn * 5

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

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

ist ein bitweises UND des Wertes in somecolumn.

Parameter:

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

Siehe auch

Ich verwende op() zur Erzeugung eines benutzerdefinierten Operators und meine Klammern werden nicht richtig ausgegeben - detaillierte Beschreibung, wie der SQLAlchemy SQL-Compiler Klammern rendert
is_comparison¶ –
veraltet; wenn True, wird der Operator als "Vergleichsoperator" betrachtet, d. h. er ergibt einen booleschen Wahr/Falsch-Wert, wie z. B. ==, > usw. Dieses Flag wird bereitgestellt, damit ORM-Beziehungen feststellen können, dass der Operator ein Vergleichsoperator ist, wenn er in einer benutzerdefinierten Join-Bedingung verwendet wird.

Die Verwendung des Parameters is_comparison wird durch die Verwendung der Methode Operators.bool_op() abgelöst; dieser prägnantere Operator setzt diesen Parameter automatisch, bietet aber auch korrekte PEP 484 Typisierungsunterstützung, da das zurückgegebene Objekt einen "booleschen" Datentyp ausdrückt, d. h. BinaryExpression[bool].
return_type¶ – eine TypeEngine Klasse oder ein Objekt, das den Rückgabetyp eines von diesem Operator erzeugten Ausdrucks erzwingt. Standardmäßig werden Operatoren, die Operators.op.is_comparison angeben, zu Boolean aufgelöst, und diejenigen, die dies nicht tun, haben den gleichen Typ wie der linke Operand.
python_impl¶ –
eine optionale Python-Funktion, die zwei Python-Werte auf die gleiche Weise auswerten kann, wie dieser Operator auf dem Datenbankserver funktioniert. Nützlich für die SQL-Ausdrucksauswertung innerhalb von Python, z. B. für ORM-Hybridattribute und den ORM "Evaluator", der verwendet wird, um Objekte in einer Sitzung nach einem Mehrzeilen-Update oder -Löschvorgang abzugleichen.

z. B.
```
>>> expr = column("x").op("+", python_impl=lambda a, b: a + b)("y")
```
Der Operator für den obigen Ausdruck funktioniert auch für nicht-SQL-linke und rechte Objekte
```
>>> expr.operator(5, 10)
15
```
Neu in Version 2.0.

Siehe auch

Verwendung benutzerdefinierter Operatoren in Verknüpfungsbedingungen

methode sqlalchemy.sql.expression.ColumnElement.operate(op: OperatorType, *other: Any, **kwargs: Any) → ColumnElement[Any]¶

Operiert auf einem Argument.

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

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

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

Parameter:

op¶ – Callable für den Operator.
*other¶ – die „andere“ Seite der Operation. Bei den meisten Operationen handelt es sich um einen einzelnen Skalarwert.
**kwargs¶ – Modifikatoren. Diese können von speziellen Operatoren wie ColumnOperators.contains() übergeben werden.

methode sqlalchemy.sql.expression.ColumnElement.params(_ClauseElement__optionaldict: Mapping[str, Any] | None = None, **kwargs: Any) → Self¶

geerbt von der ClauseElement.params() Methode von ClauseElement

Gibt eine Kopie mit ersetzten bindparam() Elementen zurück.

Gibt eine Kopie dieses ClauseElements mit ersetzten bindparam() Elementen zurück, wobei die Werte aus dem gegebenen Wörterbuch übernommen werden.

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

attribut sqlalchemy.sql.expression.ColumnElement.primary_key: bool = False¶

attribut sqlalchemy.sql.expression.ColumnElement.proxy_set: util.generic_fn_descriptor[FrozenSet[Any]]¶

Menge aller Spalten, die wir proxydieren.

Ab Version 2.0 werden hier explizit deannnotierte Spalten verwendet. Zuvor waren dies effektiv deannnotierte Spalten, aber dies wurde nicht erzwungen. Annotierte Spalten sollten, wenn überhaupt möglich, nicht in Mengen aufgenommen werden, da ihr Hashing-Verhalten sehr ineffizient ist.

methode sqlalchemy.sql.expression.ColumnElement.regexp_match(pattern: Any, flags: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.regexp_match() Methode von ColumnOperators

Implementiert einen datenbankspezifischen „regexp match“-Operator.

Z. B.

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

ColumnOperators.regexp_match() versucht, eine REGEXP-ähnliche Funktion oder einen Operator des Backends aufzulösen. Die spezifische Syntax regulärer Ausdrücke und verfügbare Flags sind jedoch nicht Backend-agnostisch.

Beispiele hierfür sind:

PostgreSQL - rendert x ~ y oder x !~ y bei Negation.
Oracle Database - rendert REGEXP_LIKE(x, y)
SQLite - verwendet den Platzhalteroperator REGEXP von SQLite und ruft die Python-Builtin-Funktion re.match() auf.
andere Backends können spezielle Implementierungen bereitstellen.
Backends ohne spezielle Implementierung geben den Operator als „REGEXP“ oder „NOT REGEXP“ aus. Dies ist beispielsweise mit SQLite und MySQL kompatibel.

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

Parameter:

pattern¶ – Der reguläre Ausdrucksmuster-String oder die Spaltenklausel.
flags¶ – Alle regulären Ausdrucks-Flags, die angewendet werden sollen, nur als einfacher Python-String übergeben. Diese Flags sind Backend-spezifisch. Einige Backends wie PostgreSQL und MariaDB können die Flags alternativ als Teil des Musters angeben. Bei Verwendung des „ignore case“-Flags „i“ in PostgreSQL wird der „ignore case“-Regexp-Match-Operator ~* oder !~* verwendet.

Neu in Version 1.4.

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

Siehe auch

ColumnOperators.regexp_replace()

methode sqlalchemy.sql.expression.ColumnElement.regexp_replace(pattern: Any, replacement: Any, flags: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.regexp_replace() Methode von ColumnOperators

Implementiert einen datenbankspezifischen „regexp replace“-Operator.

Z. B.

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

ColumnOperators.regexp_replace() versucht, eine REGEXP_REPLACE-ähnliche Funktion des Backends aufzulösen, die normalerweise die Funktion REGEXP_REPLACE() ausgibt. Die spezifische Syntax regulärer Ausdrücke und verfügbare Flags sind jedoch nicht Backend-agnostisch.

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

Parameter:

pattern¶ – Der reguläre Ausdrucksmuster-String oder die Spaltenklausel.
pattern¶ – Der Ersatz-String oder die Spaltenklausel.
flags¶ – Alle regulären Ausdrucks-Flags, die angewendet werden sollen, nur als einfacher Python-String übergeben. Diese Flags sind Backend-spezifisch. Einige Backends wie PostgreSQL und MariaDB können die Flags alternativ als Teil des Musters angeben.

Neu in Version 1.4.

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

Siehe auch

ColumnOperators.regexp_match()

methode sqlalchemy.sql.expression.ColumnElement.reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → ColumnElement[Any]¶

Umgekehrte Operation auf ein Argument.

Die Verwendung ist dieselbe wie bei operate().

methode sqlalchemy.sql.expression.ColumnElement.self_group(against: OperatorType | None = None) → ColumnElement[Any]¶

Wendet eine "Gruppierung" auf dieses ClauseElement an.

Diese Methode wird von Unterklassen überschrieben, um ein "Gruppierungs"-Konstrukt, d.h. Klammern, zurückzugeben. Insbesondere wird sie von "binären" Ausdrücken verwendet, um sich selbst zu gruppieren, 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 Subqueries normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen benannte verschachtelte SELECT-Anweisungen benötigen).

Wenn Ausdrücke zusammengesetzt werden, ist die Anwendung von self_group() automatisch - Endbenutzercode sollte diese Methode niemals direkt verwenden. Beachten Sie, dass SQLAlchemy-Klauselkonstrukte 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- self_group() Methode von ClauseElement gibt einfach sich selbst zurück.

methode sqlalchemy.sql.expression.ColumnElement.shares_lineage(othercolumn: ColumnElement[Any]) → bool¶: Gibt True zurück, wenn das gegebene ColumnElement einen gemeinsamen Vorfahren zu diesem ColumnElement hat.

methode sqlalchemy.sql.expression.ColumnElement.startswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators¶

geerbt von der ColumnOperators.startswith() Methode von ColumnOperators

Implementiert den Operator startswith.

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

column LIKE <other> || '%'

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale String-Werte kann das Flag ColumnOperators.startswith.autoescape auf True gesetzt werden, um die Eskapierung von Vorkommen dieser Zeichen innerhalb des String-Wertes anzuwenden, damit sie als sie selbst und nicht als Wildcards interpretiert werden. Alternativ kann mit dem Parameter ColumnOperators.startswith.escape ein gegebenes Zeichen als Escape-Zeichen festgelegt werden, was nützlich sein kann, wenn der Zielausdruck kein literaler String ist.

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher String-Wert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht eskaliert, es sei denn, das Flag ColumnOperators.startswith.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.startswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
somecolumn LIKE :param || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.startswith("foo/%bar", escape="^")
```
Wird gerendert als
```
somecolumn LIKE :param || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.startswith.autoescape kombiniert werden.
```
somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

attribut sqlalchemy.sql.expression.ColumnElement.stringify_dialect = 'default'¶

attribut sqlalchemy.sql.expression.ColumnElement.supports_execution = False¶

attribut sqlalchemy.sql.expression.ColumnElement.timetuple: Literal[None] = None¶: geerbt von der ColumnOperators.timetuple Attribut von ColumnOperators

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

attribut sqlalchemy.sql.expression.ColumnElement.type: TypeEngine[_T]¶

methode sqlalchemy.sql.expression.ColumnElement.unique_params(_ClauseElement__optionaldict: Dict[str, Any] | None = None, **kwargs: Any) → Self¶

geerbt von der ClauseElement.unique_params() Methode von ClauseElement

Gibt eine Kopie mit ersetzten bindparam() Elementen zurück.

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

attribut sqlalchemy.sql.expression.ColumnElement.uses_inspection = True¶

sqlalchemy.sql.expression.ColumnExpressionArgument¶

Allgemeiner Argument für "Spaltenausdruck".

Neu in Version 2.0.13.

Dieser Typ wird für Ausdrücke vom Typ „Spalte“ verwendet, die typischerweise einen einzelnen SQL-Spaltenausdruck darstellen, einschließlich ColumnElement sowie ORM-zugeordnete Attribute, die eine __clause_element__() Methode haben.

klasse sqlalchemy.sql.expression.ColumnOperators¶

Definiert boolesche, Vergleichs- und andere Operatoren für ColumnElement-Ausdrücke.

Standardmäßig rufen alle Methoden operate() oder reverse_operate() auf und übergeben die entsprechende Operatorfunktion aus dem Python-Builtin-Modul operator oder eine SQLAlchemy-spezifische Operatorfunktion aus sqlalchemy.expression.operators. Zum Beispiel die Funktion __eq__

def __eq__(self, other):
    return self.operate(operators.eq, other)

Wobei operators.eq im Wesentlichen ist

def eq(a, b):
    return a == b

Die zentrale Spaltenausdruckseinheit ColumnElement überschreibt Operators.operate() und andere, um weitere ColumnElement-Konstrukte zurückzugeben, sodass die obige `==`-Operation durch ein Klauselkonstrukt ersetzt wird.

Siehe auch

TypeEngine.comparator_factory

ColumnOperators

PropComparator

Mitglieder

__add__(), __and__(), __eq__(), __floordiv__(), __ge__(), __getitem__(), __gt__(), __hash__(), __invert__(), __le__(), __lshift__(), __lt__(), __mod__(), __mul__(), __ne__(), __neg__(), __or__(), __radd__(), __rfloordiv__(), __rmod__(), __rmul__(), __rshift__(), __rsub__(), __rtruediv__(), __sa_operate__(), __sub__(), __truediv__(), all_(), any_(), asc(), between(), bitwise_and(), bitwise_lshift(), bitwise_not(), bitwise_or(), bitwise_rshift(), bitwise_xor(), bool_op(), collate(), concat(), contains(), desc(), distinct(), endswith(), icontains(), iendswith(), ilike(), in_(), is_(), is_distinct_from(), is_not(), is_not_distinct_from(), isnot(), isnot_distinct_from(), istartswith(), like(), match(), not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), regexp_match(), regexp_replace(), reverse_operate(), startswith(), timetuple

Klassensignatur

class sqlalchemy.sql.expression.ColumnOperators (sqlalchemy.sql.expression.Operators)

method sqlalchemy.sql.expression.ColumnOperators.__add__(other: Any) → ColumnOperators¶

Implement the + operator.

In a column context, produces the clause a + b if the parent object has non-string affinity. If the parent object has a string affinity, produces the concatenation operator, a || b - see ColumnOperators.concat().

method sqlalchemy.sql.expression.ColumnOperators.__and__(other: Any) → Operators¶

inherited from the sqlalchemy.sql.expression.Operators.__and__ method of Operators

Implement the & operator.

When used with SQL expressions, results in an AND operation, equivalent to and_(), that is

a & b

is equivalent to

from sqlalchemy import and_

and_(a, b)

Care should be taken when using & regarding operator precedence; the & operator has the highest precedence. The operands should be enclosed in parenthesis if they contain further sub expressions

(a == 2) & (b == 4)

method sqlalchemy.sql.expression.ColumnOperators.__eq__(other: Any) → ColumnOperators¶

Implementiert den == Operator.

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

method sqlalchemy.sql.expression.ColumnOperators.__floordiv__(other: Any) → ColumnOperators¶

Implement the // operator.

In a column context, produces the clause a / b, which is the same as “truediv”, but considers the result type to be integer.

Neu in Version 2.0.

method sqlalchemy.sql.expression.ColumnOperators.__ge__(other: Any) → ColumnOperators¶

Implement the >= operator.

In a column context, produces the clause a >= b.

method sqlalchemy.sql.expression.ColumnOperators.__getitem__(index: Any) → ColumnOperators¶

Implement the [] operator.

This can be used by some database-specific types such as PostgreSQL ARRAY and HSTORE.

method sqlalchemy.sql.expression.ColumnOperators.__gt__(other: Any) → ColumnOperators¶

Implement the > operator.

In a column context, produces the clause a > b.

method sqlalchemy.sql.expression.ColumnOperators.__hash__()¶: Return hash(self).

method sqlalchemy.sql.expression.ColumnOperators.__invert__() → Operators¶

inherited from the sqlalchemy.sql.expression.Operators.__invert__ method of Operators

Implement the ~ operator.

When used with SQL expressions, results in a NOT operation, equivalent to not_(), that is

~a

is equivalent to

from sqlalchemy import not_

not_(a)

method sqlalchemy.sql.expression.ColumnOperators.__le__(other: Any) → ColumnOperators¶

Implementiert den Operator <=.

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

method sqlalchemy.sql.expression.ColumnOperators.__lshift__(other: Any) → ColumnOperators¶

implement the << operator.

Not used by SQLAlchemy core, this is provided for custom operator systems which want to use << as an extension point.

method sqlalchemy.sql.expression.ColumnOperators.__lt__(other: Any) → ColumnOperators¶

Implementiert den Operator <.

In einem Spaltenkontext wird die Klausel a < b erzeugt.

method sqlalchemy.sql.expression.ColumnOperators.__mod__(other: Any) → ColumnOperators¶

Implement the % operator.

In a column context, produces the clause a % b.

method sqlalchemy.sql.expression.ColumnOperators.__mul__(other: Any) → ColumnOperators¶

Implement the * operator.

In a column context, produces the clause a * b.

method sqlalchemy.sql.expression.ColumnOperators.__ne__(other: Any) → ColumnOperators¶

Implementiert den Operator !=.

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

method sqlalchemy.sql.expression.ColumnOperators.__neg__() → ColumnOperators¶

Implement the - operator.

In a column context, produces the clause -a.

method sqlalchemy.sql.expression.ColumnOperators.__or__(other: Any) → Operators¶

inherited from the sqlalchemy.sql.expression.Operators.__or__ method of Operators

Implement the | operator.

When used with SQL expressions, results in an OR operation, equivalent to or_(), that is

a | b

is equivalent to

from sqlalchemy import or_

or_(a, b)

Care should be taken when using | regarding operator precedence; the | operator has the highest precedence. The operands should be enclosed in parenthesis if they contain further sub expressions

(a == 2) | (b == 4)

method sqlalchemy.sql.expression.ColumnOperators.__radd__(other: Any) → ColumnOperators¶

Implement the + operator in reverse.

See ColumnOperators.__add__().

method sqlalchemy.sql.expression.ColumnOperators.__rfloordiv__(other: Any) → ColumnOperators¶

Implement the // operator in reverse.

See ColumnOperators.__floordiv__().

method sqlalchemy.sql.expression.ColumnOperators.__rmod__(other: Any) → ColumnOperators¶

Implement the % operator in reverse.

See ColumnOperators.__mod__().

method sqlalchemy.sql.expression.ColumnOperators.__rmul__(other: Any) → ColumnOperators¶

Implement the * operator in reverse.

See ColumnOperators.__mul__().

method sqlalchemy.sql.expression.ColumnOperators.__rshift__(other: Any) → ColumnOperators¶

implement the >> operator.

Not used by SQLAlchemy core, this is provided for custom operator systems which want to use >> as an extension point.

method sqlalchemy.sql.expression.ColumnOperators.__rsub__(other: Any) → ColumnOperators¶

Implement the - operator in reverse.

See ColumnOperators.__sub__().

methode sqlalchemy.sql.expression.ColumnOperators.__rtruediv__(other: Any) → ColumnOperators¶

Implementiere den Operator / in umgekehrter Reihenfolge.

Siehe ColumnOperators.__truediv__().

methode sqlalchemy.sql.expression.ColumnOperators.__sa_operate__(op: OperatorType, *other: Any, **kwargs: Any) → Operators¶

geerbt von der sqlalchemy.sql.expression.Operators.__sa_operate__ Methode von Operators

Operiert auf einem Argument.

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

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

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

Parameter:

op¶ – Operator-Callable.
*other¶ – die „andere“ Seite der Operation. Bei den meisten Operationen ist dies ein einzelner Skalar.
**kwargs¶ – Modifikatoren. Diese können von speziellen Operatoren wie ColumnOperators.contains() übergeben werden.

methode sqlalchemy.sql.expression.ColumnOperators.__sub__(other: Any) → ColumnOperators¶

Implement the - operator.

In einem Spaltenkontext erzeugt dies die Klausel a - b.

methode sqlalchemy.sql.expression.ColumnOperators.__truediv__(other: Any) → ColumnOperators¶

Implementiere den Operator /.

In einem Spaltenkontext erzeugt dies die Klausel a / b und betrachtet das Ergebnis als numerisch.

Geändert in Version 2.0: Der truediv-Operator für zwei Ganzzahlen gibt nun einen numerischen Wert zurück. Das Verhalten auf spezifischen Backends kann variieren.

methode sqlalchemy.sql.expression.ColumnOperators.all_() → ColumnOperators¶

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

Siehe die Dokumentation für all_() für Beispiele.

Hinweis

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

methode sqlalchemy.sql.expression.ColumnOperators.any_() → ColumnOperators¶

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

Siehe die Dokumentation für any_() für Beispiele.

Hinweis

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

methode sqlalchemy.sql.expression.ColumnOperators.asc() → ColumnOperators¶: Erzeugt eine asc()-Klausel gegen das übergeordnete Objekt.

methode sqlalchemy.sql.expression.ColumnOperators.between(cleft: Any, cright: Any, symmetric: bool = False) → ColumnOperators¶: Erzeugt eine between()-Klausel gegen das übergeordnete Objekt, gegeben den unteren und oberen Bereich.

methode sqlalchemy.sql.expression.ColumnOperators.bitwise_and(other: Any) → ColumnOperators¶: Erzeugt eine bitweise AND-Operation, typischerweise über den Operator &.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

methode sqlalchemy.sql.expression.ColumnOperators.bitwise_lshift(other: Any) → ColumnOperators¶: Erzeugt eine bitweise LSHIFT-Operation, typischerweise über den Operator <<.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

methode sqlalchemy.sql.expression.ColumnOperators.bitwise_not() → ColumnOperators¶: Erzeugt eine bitweise NOT-Operation, typischerweise über den Operator ~.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

methode sqlalchemy.sql.expression.ColumnOperators.bitwise_or(other: Any) → ColumnOperators¶: Erzeugt eine bitweise OR-Operation, typischerweise über den Operator |.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

methode sqlalchemy.sql.expression.ColumnOperators.bitwise_rshift(other: Any) → ColumnOperators¶: Erzeugt eine bitweise RSHIFT-Operation, typischerweise über den Operator >>.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

methode sqlalchemy.sql.expression.ColumnOperators.bitwise_xor(other: Any) → ColumnOperators¶: Erzeugt eine bitweise XOR-Operation, typischerweise über den Operator ^ oder # für PostgreSQL.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

methode sqlalchemy.sql.expression.ColumnOperators.bool_op(opstring: str, precedence: int = 0, python_impl: Callable[[...], Any] | None = None) → Callable[[Any], Operators]¶

geerbt von der Operators.bool_op() Methode von Operators

Gibt einen benutzerdefinierten booleschen Operator zurück.

Diese Methode ist eine Kurzform für den Aufruf von Operators.op() und das Übergeben des Flags is_comparison mit dem Wert True. Ein Hauptvorteil der Verwendung von Operators.bool_op() ist, dass bei Verwendung von Spaltenkonstrukten die „boolesche“ Natur des zurückgegebenen Ausdrucks für PEP 484-Zwecke vorhanden ist.

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.collate(collation: str) → ColumnOperators¶: Erzeugt eine collate()-Klausel gegen das übergeordnete Objekt, unter Angabe des Kollationsstrings.

Siehe auch

collate()

methode sqlalchemy.sql.expression.ColumnOperators.concat(other: Any) → ColumnOperators¶

Implementiert den 'concat'-Operator.

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

methode sqlalchemy.sql.expression.ColumnOperators.contains(other: Any, **kw: Any) → ColumnOperators¶

Implementiert den 'contains'-Operator.

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

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

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale String-Werte kann das Flag ColumnOperators.contains.autoescape auf True gesetzt werden, um das Escaping von Vorkommen dieser Zeichen innerhalb des String-Wertes anzuwenden, damit sie als sie selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.contains.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck kein literaler String ist.

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenkettenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Platzhalterzeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.contains("foo%bar", autoescape=True)
```
Wird gerendert als
```
somecolumn LIKE '%' || :param || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.contains("foo/%bar", escape="^")
```
Wird gerendert als
```
somecolumn LIKE '%' || :param || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.contains.autoescape kombiniert werden.
```
somecolumn.contains("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.desc() → ColumnOperators¶: Erzeugt eine desc()-Klausel gegen das übergeordnete Objekt.

methode sqlalchemy.sql.expression.ColumnOperators.distinct() → ColumnOperators¶: Erzeugt eine distinct()-Klausel gegen das übergeordnete Objekt.

methode sqlalchemy.sql.expression.ColumnOperators.endswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators¶

Implementiert den 'endswith'-Operator.

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

column LIKE '%' || <other>

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale String-Werte kann das Flag ColumnOperators.endswith.autoescape auf True gesetzt werden, um das Escaping von Vorkommen dieser Zeichen innerhalb des String-Wertes anzuwenden, damit sie als sie selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.endswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck kein literaler String ist.

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenkettenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Platzhalterzeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.endswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
somecolumn LIKE '%' || :param ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.endswith("foo/%bar", escape="^")
```
Wird gerendert als
```
somecolumn LIKE '%' || :param ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.endswith.autoescape kombiniert werden.
```
somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.icontains(other: Any, **kw: Any) → ColumnOperators¶

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

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

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

Z. B.

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

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

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenkettenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Platzhalterzeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.icontains("foo%bar", autoescape=True)
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.icontains("foo/%bar", escape="^")
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.contains.autoescape kombiniert werden.
```
somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.iendswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators¶

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

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

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

Z. B.

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

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

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenkettenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Platzhalterzeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.iendswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.iendswith("foo/%bar", escape="^")
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.iendswith.autoescape kombiniert werden.
```
somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.ilike(other: Any, escape: str | None = None) → ColumnOperators¶

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

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

lower(a) LIKE lower(other)

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

a ILIKE other

Z. B.

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

Parameter:

other¶ – Ausdruck, der verglichen werden soll
escape¶ –
optionales Escape-Zeichen, rendert das ESCAPE Schlüsselwort, z. B.
```
somecolumn.ilike("foo/%bar", escape="/")
```

Siehe auch

ColumnOperators.is_not()

methode sqlalchemy.sql.expression.ColumnOperators.in_(other: Any) → ColumnOperators¶

Implementiert den in Operator.

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

Der angegebene Parameter other kann sein

Eine Liste von literalen Werten, z. B.
```
stmt.where(column.in_([1, 2, 3]))
```
In dieser Aufrufform wird die Liste der Elemente in eine Menge von gebundenen Parametern der gleichen Länge wie die angegebene Liste umgewandelt.
```
WHERE COL IN (?, ?, ?)
```
Eine Liste von Tupeln kann bereitgestellt werden, wenn der Vergleich gegen ein tuple_() mit mehreren Ausdrücken erfolgt.
```
from sqlalchemy import tuple_

stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))
```
Eine leere Liste, z. B.
```
stmt.where(column.in_([]))
```
In dieser Aufrufform rendert der Ausdruck einen "leeren Mengen"-Ausdruck. Diese Ausdrücke sind auf einzelne Backends zugeschnitten und versuchen im Allgemeinen, eine leere SELECT-Anweisung als Unterabfrage zu erhalten. Auf SQLite ist der Ausdruck
```
WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Geändert in Version 1.4: Leere IN-Ausdrücke verwenden nun in allen Fällen eine zur Laufzeit generierte SELECT-Unterabfrage.
Ein gebundener Parameter, z. B. bindparam(), kann verwendet werden, wenn er das Flag bindparam.expanding enthält.
```
stmt.where(column.in_(bindparam("value", expanding=True)))
```
In dieser Aufrufform rendert der Ausdruck einen speziellen nicht-SQL-Platzhalter-Ausdruck, der wie folgt aussieht:
```
WHERE COL IN ([EXPANDING_value])
```
Dieser Platzhalter-Ausdruck wird zur Laufzeit der Anweisung abgefangen und in die variable Anzahl von gebundenen Parametern umgewandelt, wie zuvor gezeigt. Wenn die Anweisung ausgeführt würde als
```
connection.execute(stmt, {"value": [1, 2, 3]})
```
Die Datenbank würde für jeden Wert einen gebundenen Parameter erhalten.
```
WHERE COL IN (?, ?, ?)
```
Neu in Version 1.2: "expanding" gebundene Parameter hinzugefügt.

Wenn eine leere Liste übergeben wird, wird ein spezieller "leere Liste"-Ausdruck gerendert, der für die verwendete Datenbank spezifisch ist. Auf SQLite wäre dies
```
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Neu in Version 1.3: "expanding" gebundene Parameter unterstützen nun leere Listen.

ein select()-Konstrukt, was normalerweise eine korrelierte Skalar-SELECT-Abfrage ist.

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

In dieser Aufrufform wird ColumnOperators.in_() wie gegeben gerendert.

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

Parameter:: other¶ – eine Liste von Literalen, ein select()-Konstrukt oder ein bindparam()-Konstrukt mit gesetztem Flag expanding auf True.

methode sqlalchemy.sql.expression.ColumnOperators.is_(other: Any) → ColumnOperators¶

Implementiert den IS Operator.

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.is_distinct_from(other: Any) → ColumnOperators¶

Implementiert den IS DISTINCT FROM Operator.

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

methode sqlalchemy.sql.expression.ColumnOperators.is_not(other: Any) → ColumnOperators¶

Implementiert den IS NOT Operator.

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

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.is_not_distinct_from(other: Any) → ColumnOperators¶

Implementiert den IS NOT DISTINCT FROM Operator.

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

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

methode sqlalchemy.sql.expression.ColumnOperators.isnot(other: Any) → ColumnOperators¶

Implementiert den IS NOT Operator.

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

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.isnot_distinct_from(other: Any) → ColumnOperators¶

Implementiert den IS NOT DISTINCT FROM Operator.

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

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

methode sqlalchemy.sql.expression.ColumnOperators.istartswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators¶

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

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

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

Z. B.

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

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

Parameter:

other¶ – Ausdruck, mit dem verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenfolgenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht escaped, es sei denn, das Flag ColumnOperators.istartswith.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.istartswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.istartswith("foo/%bar", escape="^")
```
Wird gerendert als
```
lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.istartswith.autoescape kombiniert werden.
```
somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.like(other: Any, escape: str | None = None) → ColumnOperators¶

Implementiert den like Operator.

In einem Spaltenkontext wird der Ausdruck erzeugt

a LIKE other

Z. B.

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

Parameter:

other¶ – Ausdruck, mit dem verglichen werden soll
escape¶ –
optionales Escape-Zeichen, rendert das ESCAPE Schlüsselwort, z. B.
```
somecolumn.like("foo/%bar", escape="/")
```

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.match(other: Any, **kwargs: Any) → ColumnOperators¶

Implementiert einen datenbankspezifischen 'match'-Operator.

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

PostgreSQL - rendert x @@ plainto_tsquery(y)

Geändert in Version 2.0: plainto_tsquery() wird jetzt anstelle von to_tsquery() für PostgreSQL verwendet; für Kompatibilität mit anderen Formen siehe Volltextsuche.
MySQL - rendert MATCH (x) AGAINST (y IN BOOLEAN MODE)

Siehe auch

match - MySQL-spezifische Konstruktion mit zusätzlichen Funktionen.
Oracle Database - rendert CONTAINS(x, y)
andere Backends können spezielle Implementierungen bereitstellen.
Backends ohne spezielle Implementierung geben den Operator als „MATCH“ aus. Dies ist beispielsweise mit SQLite kompatibel.

methode sqlalchemy.sql.expression.ColumnOperators.not_ilike(other: Any, escape: str | None = None) → ColumnOperators¶

Implementiert den NOT ILIKE Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.ilike(), also ~x.ilike(y).

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.not_in(other: Any) → ColumnOperators¶

Implementiert den NOT IN Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.in_(), also ~x.in_(y).

Wenn other eine leere Sequenz ist, erzeugt der Compiler einen "leeren not in"-Ausdruck. Dieser entspricht standardmäßig dem Ausdruck "1 = 1", um immer wahr zu sein. Die create_engine.empty_in_strategy kann verwendet werden, um dieses Verhalten zu ändern.

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

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.not_like(other: Any, escape: str | None = None) → ColumnOperators¶

Implementiert den NOT LIKE Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.like(), also ~x.like(y).

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.notilike(other: Any, escape: str | None = None) → ColumnOperators¶

Implementiert den NOT ILIKE Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.ilike(), also ~x.ilike(y).

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.notin_(other: Any) → ColumnOperators¶

Implementiert den NOT IN Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.in_(), also ~x.in_(y).

Wenn other eine leere Sequenz ist, erzeugt der Compiler einen "leeren not in"-Ausdruck. Dieser entspricht standardmäßig dem Ausdruck "1 = 1", um immer wahr zu sein. Die create_engine.empty_in_strategy kann verwendet werden, um dieses Verhalten zu ändern.

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

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.notlike(other: Any, escape: str | None = None) → ColumnOperators¶

Implementiert den NOT LIKE Operator.

Dies ist äquivalent zur Verwendung der Negation mit ColumnOperators.like(), also ~x.like(y).

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

Siehe auch

methode sqlalchemy.sql.expression.ColumnOperators.nulls_first() → ColumnOperators¶: Erzeugt eine nulls_first() Klausel gegen das übergeordnete Objekt.

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

methode sqlalchemy.sql.expression.ColumnOperators.nulls_last() → ColumnOperators¶: Erzeugt eine nulls_last() Klausel gegen das übergeordnete Objekt.

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

methode sqlalchemy.sql.expression.ColumnOperators.nullsfirst() → ColumnOperators¶: Erzeugt eine nulls_first() Klausel gegen das übergeordnete Objekt.

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

methode sqlalchemy.sql.expression.ColumnOperators.nullslast() → ColumnOperators¶: Erzeugt eine nulls_last() Klausel gegen das übergeordnete Objekt.

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

methode sqlalchemy.sql.expression.ColumnOperators.op(opstring: str, precedence: int = 0, is_comparison: bool = False, return_type: Type[TypeEngine[Any]] | TypeEngine[Any] | None = None, python_impl: Callable[..., Any] | None = None) → Callable[[Any], Operators]¶

geerbt von der Operators.op() Methode von Operators

Erzeugt eine generische Operatorfunktion.

z. B.

somecolumn.op("*")(5)

produziert

somecolumn * 5

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

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

ist ein bitweises UND des Wertes in somecolumn.

Parameter:

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

Siehe auch

Ich verwende op() zur Erzeugung eines benutzerdefinierten Operators und meine Klammern werden nicht richtig ausgegeben - detaillierte Beschreibung, wie der SQLAlchemy SQL-Compiler Klammern rendert
is_comparison¶ –
veraltet; wenn True, wird der Operator als "Vergleichsoperator" betrachtet, d. h. er ergibt einen booleschen Wahr/Falsch-Wert, wie z. B. ==, > usw. Dieses Flag wird bereitgestellt, damit ORM-Beziehungen feststellen können, dass der Operator ein Vergleichsoperator ist, wenn er in einer benutzerdefinierten Join-Bedingung verwendet wird.

Die Verwendung des Parameters is_comparison wird durch die Verwendung der Methode Operators.bool_op() ersetzt; dieser prägnantere Operator setzt diesen Parameter automatisch, bietet aber auch korrekte PEP 484-Typunterstützung, da das zurückgegebene Objekt einen "booleschen" Datentyp ausdrückt, d. h. BinaryExpression[bool].
return_type¶ – eine TypeEngine-Klasse oder ein Objekt, das den Rückgabetyp eines von diesem Operator erzeugten Ausdrucks auf diesen Typ erzwingt. Standardmäßig werden Operatoren, die Operators.op.is_comparison angeben, zu Boolean aufgelöst, und solche, die dies nicht tun, haben den gleichen Typ wie der linke Operand.
python_impl¶ –
eine optionale Python-Funktion, die zwei Python-Werte auf die gleiche Weise auswerten kann, wie dieser Operator auf dem Datenbankserver funktioniert. Nützlich für die SQL-Ausdrucksauswertung innerhalb von Python, z. B. für ORM-Hybridattribute und den ORM "Evaluator", der verwendet wird, um Objekte in einer Sitzung nach einem Mehrzeilen-Update oder -Löschvorgang abzugleichen.

z. B.
```
>>> expr = column("x").op("+", python_impl=lambda a, b: a + b)("y")
```
Der Operator für den obigen Ausdruck funktioniert auch für nicht-SQL-linke und rechte Objekte
```
>>> expr.operator(5, 10)
15
```
Neu in Version 2.0.

Siehe auch

Verwendung benutzerdefinierter Operatoren in Verknüpfungsbedingungen

methode sqlalchemy.sql.expression.ColumnOperators.operate(op: OperatorType, *other: Any, **kwargs: Any) → Operators¶

geerbt von der Operators.operate()-Methode von Operators

Operiert auf einem Argument.

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

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

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

Parameter:

op¶ – Operatoraufruf.
*other¶ – die „andere“ Seite der Operation. Ist für die meisten Operationen ein einzelner Skalar.
**kwargs¶ – Modifikatoren. Diese können von speziellen Operatoren wie ColumnOperators.contains() übergeben werden.

methode sqlalchemy.sql.expression.ColumnOperators.regexp_match(pattern: Any, flags: str | None = None) → ColumnOperators¶

Implementiert einen datenbankspezifischen „regexp match“-Operator.

Z. B.

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

ColumnOperators.regexp_match() versucht, eine REGEXP-ähnliche Funktion oder einen Operator des Backends aufzulösen. Die spezifische Syntax regulärer Ausdrücke und verfügbare Flags sind jedoch nicht Backend-agnostisch.

Beispiele hierfür sind:

PostgreSQL - rendert x ~ y oder x !~ y bei Negation.
Oracle Database - rendert REGEXP_LIKE(x, y)
SQLite - verwendet den Platzhalteroperator REGEXP von SQLite und ruft die Python-Builtin-Funktion re.match() auf.
andere Backends können spezielle Implementierungen bereitstellen.
Backends ohne spezielle Implementierung geben den Operator als „REGEXP“ oder „NOT REGEXP“ aus. Dies ist beispielsweise mit SQLite und MySQL kompatibel.

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

Parameter:

pattern¶ – Der reguläre Ausdrucksmuster-String oder Spaltenklausel.
flags¶ – Jegliche regulären Ausdrucks-String-Flags, die angewendet werden sollen, übergeben als einfacher Python-String. Diese Flags sind backend-spezifisch. Einige Backends wie PostgreSQL und MariaDB können die Flags alternativ als Teil des Musters angeben. Bei Verwendung des Ignore-Case-Flags 'i' in PostgreSQL wird der Ignore-Case-Regex-Match-Operator ~* oder !~* verwendet.

Neu in Version 1.4.

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

Siehe auch

ColumnOperators.regexp_replace()

methode sqlalchemy.sql.expression.ColumnOperators.regexp_replace(pattern: Any, replacement: Any, flags: str | None = None) → ColumnOperators¶

Implementiert einen datenbankspezifischen „regexp replace“-Operator.

Z. B.

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

ColumnOperators.regexp_replace() versucht, eine REGEXP_REPLACE-ähnliche Funktion des Backends aufzulösen, die normalerweise die Funktion REGEXP_REPLACE() ausgibt. Die spezifische Syntax regulärer Ausdrücke und verfügbare Flags sind jedoch nicht Backend-agnostisch.

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

Parameter:

pattern¶ – Der reguläre Ausdrucksmuster-String oder Spaltenklausel.
pattern¶ – Der Ersetzungsstring oder die Spaltenklausel.
flags¶ – Jegliche regulären Ausdrucks-String-Flags, die angewendet werden sollen, übergeben als einfacher Python-String. Diese Flags sind backend-spezifisch. Einige Backends wie PostgreSQL und MariaDB können die Flags alternativ als Teil des Musters angeben.

Neu in Version 1.4.

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

Siehe auch

ColumnOperators.regexp_match()

methode sqlalchemy.sql.expression.ColumnOperators.reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → Operators¶

geerbt von der Operators.reverse_operate()-Methode von Operators

Umgekehrte Operation auf ein Argument.

Die Verwendung ist dieselbe wie bei operate().

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

Implementiert den Operator startswith.

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

column LIKE <other> || '%'

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale String-Werte kann das Flag ColumnOperators.startswith.autoescape auf True gesetzt werden, um die Eskapierung von Vorkommen dieser Zeichen innerhalb des String-Wertes anzuwenden, damit sie als sie selbst und nicht als Wildcards interpretiert werden. Alternativ kann mit dem Parameter ColumnOperators.startswith.escape ein gegebenes Zeichen als Escape-Zeichen festgelegt werden, was nützlich sein kann, wenn der Zielausdruck kein literaler String ist.

Parameter:

other¶ – Ausdruck, mit dem verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenfolgenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht escaped, es sei denn, das Flag ColumnOperators.startswith.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.startswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
somecolumn LIKE :param || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.startswith("foo/%bar", escape="^")
```
Wird gerendert als
```
somecolumn LIKE :param || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.startswith.autoescape kombiniert werden.
```
somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

FunctionElement.filter()

attribut sqlalchemy.sql.expression.ColumnOperators.timetuple: Literal[None] = None¶: Hack, erlaubt den Vergleich von Datetime-Objekten auf der linken Seite.

klasse sqlalchemy.sql.expression.Extract¶: Stellt eine SQL EXTRACT-Klausel dar, extract(field FROM expr).

Klassensignatur

klasse sqlalchemy.sql.expression.Extract (sqlalchemy.sql.expression.ColumnElement)

klasse sqlalchemy.sql.expression.False_¶

Stellt das Schlüsselwort false oder Äquivalentes in einer SQL-Anweisung dar.

False_ wird als Konstante über die Funktion false() aufgerufen.

Klassensignatur

klasse sqlalchemy.sql.expression.False_ (sqlalchemy.sql.expression.SingletonConstant, sqlalchemy.sql.roles.ConstExprRole, sqlalchemy.sql.expression.ColumnElement)

klasse sqlalchemy.sql.expression.FunctionFilter¶

Stellt eine Funktion FILTER-Klausel dar.

Dies ist ein spezieller Operator für Aggregat- und Fensterfunktionen, der steuert, welche Zeilen an diese übergeben werden. Er wird nur von bestimmten Datenbank-Backends unterstützt.

Die Invocation von FunctionFilter erfolgt über FunctionElement.filter()

func.count(1).filter(True)

Siehe auch

Mitglieder

filter(), over(), self_group(), within_group()

Klassensignatur

klasse sqlalchemy.sql.expression.FunctionFilter (sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.ColumnElement)

methode sqlalchemy.sql.expression.FunctionFilter.filter(*criterion: _ColumnExpressionArgument[bool]) → Self¶

Erzeugt ein zusätzliches FILTER für die Funktion.

Diese Methode fügt zusätzliche Kriterien zu den anfänglichen Kriterien hinzu, die von FunctionElement.filter() eingerichtet wurden.

Mehrere Kriterien werden zur SQL-Rendering-Zeit über AND verbunden.

Erzeugt eine OVER-Klausel für diese gefilterte Funktion.

Verwendet auf Aggregat- oder sogenannte "Window"-Funktionen für Backends, die Window-Funktionen unterstützen.

Der Ausdruck

func.rank().filter(MyClass.y > 5).over(order_by="x")

ist Kurzform für

from sqlalchemy import over, funcfilter

over(funcfilter(func.rank(), MyClass.y > 5), order_by="x")

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

Methode sqlalchemy.sql.expression.FunctionFilter.self_group(against: OperatorType | None = None) → Self | Grouping[_T]¶

Wendet eine "Gruppierung" auf dieses ClauseElement an.

Diese Methode wird von Unterklassen überschrieben, um ein "Gruppierungs"-Konstrukt, d.h. Klammern, zurückzugeben. Insbesondere wird sie von "binären" Ausdrücken verwendet, um sich selbst zu gruppieren, 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 Subqueries normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen benannte verschachtelte SELECT-Anweisungen benötigen).

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

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

Methode sqlalchemy.sql.expression.FunctionFilter.within_group(*order_by: _ColumnExpressionArgument[Any]) → WithinGroup[_T]¶: Erzeugt eine WITHIN GROUP (ORDER BY expr)-Klausel für diese Funktion.

Klasse sqlalchemy.sql.expression.Label¶

Repräsentiert ein Spalten-Label (AS).

Stellt ein Label dar, wie es typischerweise mit dem SQL-Schlüsselwort AS auf jedes spaltenbezogene Element angewendet wird.

Mitglieder

foreign_keys, primary_key, self_group()

Klassensignatur

class sqlalchemy.sql.expression.Label (sqlalchemy.sql.roles.LabeledColumnExprRole, sqlalchemy.sql.expression.NamedColumn)

Attribut sqlalchemy.sql.expression.Label.foreign_keys: AbstractSet[ForeignKey]¶

Attribut sqlalchemy.sql.expression.Label.primary_key: bool¶

Methode sqlalchemy.sql.expression.Label.self_group(against: OperatorType | None = None) → Label[_T]¶

Wendet eine "Gruppierung" auf dieses ClauseElement an.

Diese Methode wird von Unterklassen überschrieben, um ein "Gruppierungs"-Konstrukt, d.h. Klammern, zurückzugeben. Insbesondere wird sie von "binären" Ausdrücken verwendet, um sich selbst zu gruppieren, 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 Subqueries normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen benannte verschachtelte SELECT-Anweisungen benötigen).

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

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

Klasse sqlalchemy.sql.expression.Null¶

Stellt das NULL-Schlüsselwort in einer SQL-Anweisung dar.

Null wird als Konstante über die Funktion null() aufgerufen.

Klassensignatur

class sqlalchemy.sql.expression.Null (sqlalchemy.sql.expression.SingletonConstant, sqlalchemy.sql.roles.ConstExprRole, sqlalchemy.sql.expression.ColumnElement)

Klasse sqlalchemy.sql.expression.Operators¶

Basis von Vergleichs- und logischen Operatoren.

Implementiert die Basis-Methoden Operators.operate() und Operators.reverse_operate(), sowie Operators.__and__(), Operators.__or__(), Operators.__invert__().

Mitglieder

__and__(), __invert__(), __or__(), __sa_operate__(), bool_op(), op(), operate(), reverse_operate()

Wird normalerweise über seine gebräuchlichste Unterklasse ColumnOperators verwendet.

Methode sqlalchemy.sql.expression.Operators.__and__(other: Any) → Operators¶

Implement the & operator.

When used with SQL expressions, results in an AND operation, equivalent to and_(), that is

a & b

is equivalent to

from sqlalchemy import and_

and_(a, b)

Care should be taken when using & regarding operator precedence; the & operator has the highest precedence. The operands should be enclosed in parenthesis if they contain further sub expressions

(a == 2) & (b == 4)

Methode sqlalchemy.sql.expression.Operators.__invert__() → Operators¶

Implement the ~ operator.

When used with SQL expressions, results in a NOT operation, equivalent to not_(), that is

~a

is equivalent to

from sqlalchemy import not_

not_(a)

Methode sqlalchemy.sql.expression.Operators.__or__(other: Any) → Operators¶

Implement the | operator.

When used with SQL expressions, results in an OR operation, equivalent to or_(), that is

a | b

is equivalent to

from sqlalchemy import or_

or_(a, b)

Care should be taken when using | regarding operator precedence; the | operator has the highest precedence. The operands should be enclosed in parenthesis if they contain further sub expressions

(a == 2) | (b == 4)

Methode sqlalchemy.sql.expression.Operators.__sa_operate__(op: OperatorType, *other: Any, **kwargs: Any) → Operators¶

Operiert auf einem Argument.

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

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

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

Parameter:

op¶ – Operator callable.
*other¶ – die „andere“ Seite der Operation. Für die meisten Operationen ist dies ein einzelner Skalar.
**kwargs¶ – Modifikatoren. Diese können von speziellen Operatoren wie ColumnOperators.contains() übergeben werden.

Methode sqlalchemy.sql.expression.Operators.bool_op(opstring: str, precedence: int = 0, python_impl: Callable[[...], Any] | None = None) → Callable[[Any], Operators]¶

Gibt einen benutzerdefinierten booleschen Operator zurück.

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

Siehe auch

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

Erzeugt eine generische Operatorfunktion.

z. B.

somecolumn.op("*")(5)

produziert

somecolumn * 5

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

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

ist ein bitweises UND des Wertes in somecolumn.

Parameter:

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

Siehe auch

Ich verwende op() zur Erzeugung eines benutzerdefinierten Operators und meine Klammern werden nicht richtig ausgegeben - detaillierte Beschreibung, wie der SQLAlchemy SQL-Compiler Klammern rendert
is_comparison¶ –
veraltet; wenn True, wird der Operator als "Vergleichsoperator" betrachtet, d. h. er ergibt einen booleschen Wahr/Falsch-Wert, wie z. B. ==, > usw. Dieses Flag wird bereitgestellt, damit ORM-Beziehungen feststellen können, dass der Operator ein Vergleichsoperator ist, wenn er in einer benutzerdefinierten Join-Bedingung verwendet wird.

Die Verwendung des Parameters is_comparison wird durch die Verwendung der Methode Operators.bool_op() ersetzt; dieser kürzere Operator setzt diesen Parameter automatisch, bietet aber auch korrekte PEP 484-Typisierungsunterstützung, da das zurückgegebene Objekt einen „booleschen“ Datentyp ausdrückt, d. h. BinaryExpression[bool].
return_type¶ – eine TypeEngine-Klasse oder ein Objekt, das den Rückgabetyp eines von diesem Operator erzeugten Ausdrucks auf diesen Typ erzwingt. Standardmäßig werden Operatoren, die Operators.op.is_comparison angeben, zu Boolean aufgelöst, und solche, die dies nicht tun, haben denselben Typ wie der linke Operand.
python_impl¶ –
eine optionale Python-Funktion, die zwei Python-Werte auf die gleiche Weise auswerten kann, wie dieser Operator auf dem Datenbankserver funktioniert. Nützlich für die SQL-Ausdrucksauswertung innerhalb von Python, z. B. für ORM-Hybridattribute und den ORM "Evaluator", der verwendet wird, um Objekte in einer Sitzung nach einem Mehrzeilen-Update oder -Löschvorgang abzugleichen.

z. B.
```
>>> expr = column("x").op("+", python_impl=lambda a, b: a + b)("y")
```
Der Operator für den obigen Ausdruck funktioniert auch für nicht-SQL-linke und rechte Objekte
```
>>> expr.operator(5, 10)
15
```
Neu in Version 2.0.

Siehe auch

Verwendung benutzerdefinierter Operatoren in Verknüpfungsbedingungen

Methode sqlalchemy.sql.expression.Operators.operate(op: OperatorType, *other: Any, **kwargs: Any) → Operators¶

Operiert auf einem Argument.

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

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

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

Parameter:

op¶ – Operator callable.
*other¶ – die „andere“ Seite der Operation. Für die meisten Operationen ist dies ein einzelner Skalar.
**kwargs¶ – Modifikatoren. Diese können von speziellen Operatoren wie ColumnOperators.contains() übergeben werden.

Methode sqlalchemy.sql.expression.Operators.reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → Operators¶

Umgekehrte Operation auf ein Argument.

Die Verwendung ist dieselbe wie bei operate().

Klasse sqlalchemy.sql.expression.Over¶

Stellt eine OVER-Klausel dar.

Dies ist ein spezieller Operator für eine sogenannte „Fensterfunktion“ sowie für jede Aggregatfunktion, die Ergebnisse relativ zum Ergebnis-Set selbst erzeugt. Die meisten modernen SQL-Backends unterstützen Fensterfunktionen.

Mitglieder

element

Klassensignatur

class sqlalchemy.sql.expression.Over (sqlalchemy.sql.expression.ColumnElement)

Attribut sqlalchemy.sql.expression.Over.element: ColumnElement[_T]¶: Das zugrunde liegende Ausdrucksobjekt, auf das sich dieses Over-Objekt bezieht.

Klasse sqlalchemy.sql.expression.SQLColumnExpression¶

Ein Typ, der verwendet werden kann, um ein beliebiges SQL-Spaltenelement oder ein Objekt anzugeben, das an seiner Stelle fungiert.

SQLColumnExpression ist eine Basisklasse von ColumnElement sowie innerhalb der Basen von ORM-Elementen wie InstrumentedAttribute und kann in PEP 484-Typisierungen verwendet werden, um Argumente oder Rückgabewerte anzugeben, die sich wie Spaltenausdrücke verhalten sollen.

Neu ab Version 2.0.0b4.

Klassensignatur

class sqlalchemy.sql.expression.SQLColumnExpression (sqlalchemy.sql.expression.SQLCoreOperations, sqlalchemy.sql.roles.ExpressionElementRole, sqlalchemy.util.langhelpers.TypingOnly)

Klasse sqlalchemy.sql.expression.TextClause¶

Stellt ein Literal SQL-Textfragment dar.

Z. B.

from sqlalchemy import text

t = text("SELECT * FROM users")
result = connection.execute(t)

Der TextClause-Konstrukt wird mit der Funktion text() erzeugt; siehe diese Funktion für eine vollständige Dokumentation.

Siehe auch

text()

Mitglieder

bindparams(), columns(), self_group()

Klassensignatur

class sqlalchemy.sql.expression.TextClause (sqlalchemy.sql.roles.DDLConstraintColumnRole, sqlalchemy.sql.roles.DDLExpressionRole, sqlalchemy.sql.roles.StatementOptionRole, sqlalchemy.sql.roles.WhereHavingRole, sqlalchemy.sql.roles.OrderByRole, sqlalchemy.sql.roles.FromClauseRole, sqlalchemy.sql.roles.SelectStatementRole, sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.Executable, sqlalchemy.sql.expression.DQLDMLClauseElement, sqlalchemy.sql.roles.BinaryElementRole, sqlalchemy.inspection.Inspectable)

Methode sqlalchemy.sql.expression.TextClause.bindparams(*binds: BindParameter[Any], **names_to_values: Any) → Self¶

Lege die Werte und/oder Typen von gebundenen Parametern innerhalb dieses TextClause-Konstrukts fest.

Gegeben sei ein Textkonstrukt wie

from sqlalchemy import text

stmt = text(
    "SELECT id, name FROM user WHERE name=:name AND timestamp=:timestamp"
)

Die Methode TextClause.bindparams() kann verwendet werden, um den Anfangswert von :name und :timestamp festzulegen, unter Verwendung einfacher Schlüsselwortargumente

stmt = stmt.bindparams(
    name="jack", timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5)
)

Wobei oben neue BindParameter-Objekte mit den Namen name und timestamp und den Werten jack bzw. datetime.datetime(2012, 10, 8, 15, 12, 5) generiert werden. Die Typen werden aus den gegebenen Werten abgeleitet, in diesem Fall String und DateTime.

Wenn ein spezifisches Typisierungsverhalten erforderlich ist, kann das positionelle Argument *binds verwendet werden, um bindparam()-Konstrukte direkt anzugeben. Diese Konstrukte müssen mindestens das Argument key enthalten, dann einen optionalen Wert und Typ

from sqlalchemy import bindparam

stmt = stmt.bindparams(
    bindparam("name", value="jack", type_=String),
    bindparam("timestamp", type_=DateTime),
)

Oben haben wir den Typ DateTime für die Bindung timestamp und den Typ String für die Bindung name angegeben. Im Fall von name haben wir auch den Standardwert "jack" gesetzt.

Zusätzliche gebundene Parameter können zur Ausführungszeit der Anweisung bereitgestellt werden, z. B.

result = connection.execute(
    stmt, timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5)
)

Die Methode TextClause.bindparams() kann wiederholt aufgerufen werden, wobei vorhandene BindParameter-Objekte wiederverwendet werden, um neue Informationen hinzuzufügen. Zum Beispiel können wir TextClause.bindparams() zuerst mit Typinformationen und ein zweites Mal mit Wertinformationen aufrufen, und diese werden kombiniert

stmt = text(
    "SELECT id, name FROM user WHERE name=:name "
    "AND timestamp=:timestamp"
)
stmt = stmt.bindparams(
    bindparam("name", type_=String), bindparam("timestamp", type_=DateTime)
)
stmt = stmt.bindparams(
    name="jack", timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5)
)

Die Methode TextClause.bindparams() unterstützt auch das Konzept der **eindeutigen** gebundenen Parameter. Dies sind Parameter, die zur Kompilierungszeit der Anweisung nach Namen "unifiziert" werden, sodass mehrere text()-Konstrukte kombiniert werden können, ohne dass die Namen in Konflikt geraten. Um diese Funktion zu nutzen, geben Sie das Flag BindParameter.unique auf jedem bindparam()-Objekt an

stmt1 = text("select id from table where name=:name").bindparams(
    bindparam("name", value="name1", unique=True)
)
stmt2 = text("select id from table where name=:name").bindparams(
    bindparam("name", value="name2", unique=True)
)

union = union_all(stmt1.columns(column("id")), stmt2.columns(column("id")))

Die obige Anweisung wird wie folgt gerendert

select id from table where name=:name_1
UNION ALL select id from table where name=:name_2

Neu in Version 1.3.11: Unterstützung für das Flag BindParameter.unique zur Verwendung mit text()-Konstrukten hinzugefügt.

Methode sqlalchemy.sql.expression.TextClause.columns(*cols: _ColumnExpressionArgument[Any], **types: _TypeEngineArgument[Any]) → TextualSelect¶

Verwandle dieses TextClause-Objekt in ein TextualSelect-Objekt, das die gleiche Rolle wie eine SELECT-Anweisung spielt.

Das TextualSelect ist Teil der SelectBase-Hierarchie und kann in eine andere Anweisung eingebettet werden, indem die Methode TextualSelect.subquery() verwendet wird, um ein Subquery-Objekt zu erzeugen, aus dem dann SELECTiert werden kann.

Diese Funktion schlägt im Wesentlichen die Lücke zwischen einer rein textuellen SELECT-Anweisung und dem SQL-Ausdruckskonzept eines „selektierbaren“

from sqlalchemy.sql import column, text

stmt = text("SELECT id, name FROM some_table")
stmt = stmt.columns(column("id"), column("name")).subquery("st")

stmt = (
    select(mytable)
    .select_from(mytable.join(stmt, mytable.c.name == stmt.c.name))
    .where(stmt.c.id > 5)
)

Oben übergeben wir eine Reihe von column()-Elementen positionell an die Methode TextClause.columns(). Diese column()-Elemente werden nun zu First-Class-Elementen in der Spaltenkollektion TextualSelect.selected_columns, die dann Teil der Subquery.c-Kollektion werden, nachdem TextualSelect.subquery() aufgerufen wurde.

Die Spaltenausdrücke, die wir an TextClause.columns() übergeben, können auch typisiert werden. Wenn wir dies tun, werden diese TypeEngine-Objekte zum effektiven Rückgabetyp der Spalte, sodass die Ergebnisverarbeitungssysteme von SQLAlchemy auf die Rückgabewerte angewendet werden können. Dies ist oft für Typen wie Datums- oder boolesche Typen sowie für die Unicode-Verarbeitung in einigen Dialektkonfigurationen erforderlich

stmt = text("SELECT id, name, timestamp FROM some_table")
stmt = stmt.columns(
    column("id", Integer),
    column("name", Unicode),
    column("timestamp", DateTime),
)

for id, name, timestamp in connection.execute(stmt):
    print(id, name, timestamp)

Als Abkürzung zur obigen Syntax können Schlüsselwortargumente verwendet werden, die sich nur auf Typen beziehen, wenn nur eine Typkonvertierung erforderlich ist

stmt = text("SELECT id, name, timestamp FROM some_table")
stmt = stmt.columns(id=Integer, name=Unicode, timestamp=DateTime)

for id, name, timestamp in connection.execute(stmt):
    print(id, name, timestamp)

Die positionelle Form von TextClause.columns() bietet auch die einzigartige Funktion des **positionalen Spaltenzielings**, was besonders nützlich ist, wenn die ORM mit komplexen textuellen Abfragen verwendet wird. Wenn wir die Spalten aus unserem Modell an TextClause.columns() übergeben, stimmt der Ergebnisdatensatz positionell mit diesen Spalten überein, d. h. Name oder Herkunft der Spalte in der textuellen SQL spielt keine Rolle

stmt = text(
    "SELECT users.id, addresses.id, users.id, "
    "users.name, addresses.email_address AS email "
    "FROM users JOIN addresses ON users.id=addresses.user_id "
    "WHERE users.id = 1"
).columns(
    User.id,
    Address.id,
    Address.user_id,
    User.name,
    Address.email_address,
)

query = (
    session.query(User)
    .from_statement(stmt)
    .options(contains_eager(User.addresses))
)

Die Methode TextClause.columns() bietet einen direkten Weg zum Aufruf von FromClause.subquery() sowie SelectBase.cte() gegen eine textuelle SELECT-Anweisung

stmt = stmt.columns(id=Integer, name=String).cte("st")

stmt = select(sometable).where(sometable.c.id == stmt.c.id)

Parameter:

*cols¶ – Eine Reihe von ColumnElement-Objekten, typischerweise Column-Objekte aus einer Table oder spaltenzugeordnete Attribute auf ORM-Ebene, die eine Menge von Spalten darstellen, aus der diese textuelle Zeichenkette SELECTiert.
**types¶ – Eine Zuordnung von Zeichenkettennamen zu TypeEngine-Typobjekten, die die für aus der textuellen Zeichenkette SELECTierte Namen zu verwendenden Datentypen angeben. Bevorzugen Sie die Verwendung des Arguments *cols, da dies auch die positionelle Reihenfolge angibt.

Methode sqlalchemy.sql.expression.TextClause.self_group(against: OperatorType | None = None) → Self | Grouping[Any]¶

Wendet eine "Gruppierung" auf dieses ClauseElement an.

Diese Methode wird von Unterklassen überschrieben, um ein "Gruppierungs"-Konstrukt, d.h. Klammern, zurückzugeben. Insbesondere wird sie von "binären" Ausdrücken verwendet, um sich selbst zu gruppieren, 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 Subqueries normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen benannte verschachtelte SELECT-Anweisungen benötigen).

Beim Komponieren von Ausdrücken 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 – Klammern sind möglicherweise nicht erforderlich, z. B. in einem Ausdruck wie x OR (y AND z) – UND hat Vorrang vor ODER.

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

Klasse sqlalchemy.sql.expression.TryCast¶

Stellt einen TRY_CAST-Ausdruck dar.

Details zur Verwendung von TryCast finden Sie unter try_cast().

Siehe auch

try_cast()

Mitglieder

inherit_cache

Klassensignatur

class sqlalchemy.sql.expression.TryCast (sqlalchemy.sql.expression.Cast)

Attribut sqlalchemy.sql.expression.TryCast.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.Tuple¶

Stellt ein SQL-Tupel dar.

Mitglieder

class sqlalchemy.sql.expression.Tuple (sqlalchemy.sql.expression.ClauseList, sqlalchemy.sql.expression.ColumnElement)

Klassensignatur

Methode sqlalchemy.sql.expression.Tuple.self_group(against: OperatorType | None = None) → Self¶

Wendet eine "Gruppierung" auf dieses ClauseElement an.

Diese Methode wird von Unterklassen überschrieben, um ein "Gruppierungs"-Konstrukt, d.h. Klammern, zurückzugeben. Insbesondere wird sie von "binären" Ausdrücken verwendet, um sich selbst zu gruppieren, 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 Subqueries normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen benannte verschachtelte SELECT-Anweisungen benötigen).

Beim Komponieren von Ausdrücken 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 – Klammern sind möglicherweise nicht erforderlich, z. B. in einem Ausdruck wie x OR (y AND z) – UND hat Vorrang vor ODER.

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

Klasse sqlalchemy.sql.expression.WithinGroup¶

Stellt eine WITHIN GROUP (ORDER BY) Klausel dar.

Dies ist ein spezieller Operator für sogenannte „Ordered Set Aggregate“ und „Hypothetical Set Aggregate“ Funktionen, einschließlich percentile_cont(), rank(), dense_rank() usw.

Es wird nur von bestimmten Datenbank-Backends unterstützt, wie z. B. PostgreSQL, Oracle Database und MS SQL Server.

Das WithinGroup-Konstrukt extrahiert seinen Typ aus der Methode FunctionElement.within_group_type(). Wenn diese None zurückgibt, wird der .type der Funktion verwendet.

Mitglieder

filter(), over()

Klassensignatur

class sqlalchemy.sql.expression.WithinGroup (sqlalchemy.sql.expression.ColumnElement)

Methode sqlalchemy.sql.expression.WithinGroup.filter(*criterion: _ColumnExpressionArgument[bool]) → Self | FunctionFilter[_T]¶: Erzeuge eine FILTER-Klausel gegen diese Funktion.

Erzeuge eine OVER-Klausel gegen dieses WithinGroup-Konstrukt.

Diese Funktion hat die gleiche Signatur wie die von FunctionElement.over().

Klasse sqlalchemy.sql.elements.WrapsColumnExpression¶: Mix-in, das ein ColumnElement als Wrapper mit speziellem Labeling-Verhalten für einen Ausdruck definiert, der bereits einen Namen hat.

Neu in Version 1.4.

Siehe auch

Verbesserte Spaltenbenennung für einfache Spaltenausdrücke mit CAST oder ähnlichem

Klassensignatur

class sqlalchemy.sql.expression.WrapsColumnExpression (sqlalchemy.sql.expression.ColumnElement)

Klasse sqlalchemy.sql.expression.True_¶

Stellt das Schlüsselwort true oder Äquivalentes in einer SQL-Anweisung dar.

True_ wird als Konstante über die Funktion true() zugegriffen.

Klassensignatur

class sqlalchemy.sql.expression.True_ (sqlalchemy.sql.expression.SingletonConstant, sqlalchemy.sql.roles.ConstExprRole, sqlalchemy.sql.expression.ColumnElement)

Klasse sqlalchemy.sql.expression.TypeCoerce¶

Stellt einen Wrapper für die Typenkonvertierung auf Python-Seite dar.

TypeCoerce liefert die Funktion type_coerce(); siehe diese Funktion für Nutzungsdetails.

Siehe auch

type_coerce()

Mitglieder

Klassensignatur

class sqlalchemy.sql.expression.TypeCoerce (sqlalchemy.sql.expression.WrapsColumnExpression)

Methode sqlalchemy.sql.expression.TypeCoerce.self_group(against: OperatorType | None = None) → TypeCoerce[_T]¶

Wendet eine "Gruppierung" auf dieses ClauseElement an.

Diese Methode wird von Unterklassen überschrieben, um ein "Gruppierungs"-Konstrukt, d.h. Klammern, zurückzugeben. Insbesondere wird sie von "binären" Ausdrücken verwendet, um sich selbst zu gruppieren, 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 Subqueries normalerweise mit der Methode Select.alias() erstellt werden sollten, da viele Plattformen benannte verschachtelte SELECT-Anweisungen benötigen).

Beim Komponieren von Ausdrücken 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 – Klammern sind möglicherweise nicht erforderlich, z. B. in einem Ausdruck wie x OR (y AND z) – UND hat Vorrang vor ODER.

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

Klasse sqlalchemy.sql.expression.UnaryExpression¶

Definiert einen "unären" Ausdruck.

Ein unärer Ausdruck hat einen einzelnen Spaltenausdruck und einen Operator. Der Operator kann links (wo er als 'Operator' bezeichnet wird) oder rechts (wo er als 'Modifikator' bezeichnet wird) vom Spaltenausdruck platziert werden.

UnaryExpression ist die Grundlage für mehrere unäre Operatoren, einschließlich derer, die von desc(), asc(), distinct(), nulls_first() und nulls_last() verwendet werden.

Mitglieder