class documentation

class Join(roles.DMLTableRole, FromClause):

Known subclasses: sqlalchemy.orm.util._ORMJoin

View In Hierarchy

Represent a JOIN construct between two _expression.FromClause elements.

The public constructor function for _expression.Join is the module-level _expression.join() function, as well as the _expression.FromClause.join method of any _expression.FromClause (e.g. such as _schema.Table).

See Also

_expression.join

_expression.FromClause.join

Method __init__ Construct a new _expression.Join.
Method alias Return an alias of this _expression.Join.
Method is​_derived​_from Return True if this _expression.FromClause is 'derived' from the given FromClause.
Method select Create a _expression.Select from this _expression.Join.
Method self​_group Apply a 'grouping' to this _expression.ClauseElement.
Class Method ​_can​_join Undocumented
Class Method ​_create​_join Produce a _expression.Join object, given two _expression.FromClause expressions.
Class Method ​_create​_outerjoin Return an OUTER JOIN clause element.
Class Method ​_join​_condition Create a join condition between two tables or selectables.
Class Method ​_joincond​_scan​_left​_right Undocumented
Class Method ​_joincond​_trim​_constraints Undocumented
Method ​_anonymous​_fromclause Undocumented
Method ​_copy​_internals Reassign internal elements to be clones of themselves.
Method ​_match​_primaries Undocumented
Method ​_populate​_column​_collection Called on subclasses to establish the .c collection.
Method ​_refresh​_for​_new​_column Given a column added to the .c collection of an underlying selectable, produce the local version of that column, assuming this selectable ultimately should proxy this column.
Class Variable __visit​_name__ Undocumented
Class Variable ​_is​_join Undocumented
Class Variable ​_traverse​_internals Undocumented
Instance Variable full Undocumented
Instance Variable isouter Undocumented
Instance Variable left Undocumented
Instance Variable onclause Undocumented
Instance Variable right Undocumented
Property ​_from​_objects Undocumented
Property ​_hide​_froms Undocumented
Property bind Return the bound engine associated with either the left or right side of this _sql.Join.
Property description A brief description of this _expression.FromClause.

Inherited from DMLTableRole:

Class Variable ​_role​_name Undocumented

Inherited from FromClauseRole (via DMLTableRole):

Class Variable ​_is​_subquery Undocumented

Inherited from ColumnsClauseRole (via DMLTableRole, FromClauseRole):

Property ​_select​_iterable Undocumented

Inherited from AllowsLambdaRole (via DMLTableRole, FromClauseRole, ColumnsClauseRole):

Class Variable allows​_lambda Undocumented

Inherited from UsesInspection (via DMLTableRole, FromClauseRole, ColumnsClauseRole):

Class Variable ​_post​_inspect Undocumented
Class Variable uses​_inspection Undocumented

Inherited from SQLRole (via DMLTableRole, FromClauseRole, ColumnsClauseRole, ColumnListRole):

Class Variable allows​_lambda Undocumented
Class Variable uses​_inspection Undocumented

Inherited from AllowsLambdaRole (via DMLTableRole, FromClauseRole, JoinTargetRole):

Class Variable allows​_lambda Undocumented

Inherited from UsesInspection (via DMLTableRole, FromClauseRole, JoinTargetRole):

Class Variable ​_post​_inspect Undocumented
Class Variable uses​_inspection Undocumented

Inherited from SQLRole (via DMLTableRole, FromClauseRole, JoinTargetRole, StructuralRole):

Class Variable allows​_lambda Undocumented
Class Variable uses​_inspection Undocumented

Inherited from FromClause:

Method join Return a _expression.Join from this _expression.FromClause to another FromClause.
Method outerjoin No summary
Method table​_valued Return a _sql.TableValuedColumn object for this _expression.FromClause.
Method tablesample Return a TABLESAMPLE alias of this _expression.FromClause.
Class Variable c Undocumented
Class Variable schema Define the 'schema' attribute for this _expression.FromClause.
Instance Variable foreign​_keys Return the collection of _schema.ForeignKey marker objects which this FromClause references.
Instance Variable primary​_key Return the iterable collection of _schema.Column objects which comprise the primary key of this _selectable.FromClause.
Method ​_generate​_fromclause​_column​_proxies Undocumented
Method ​_init​_collections Undocumented
Method ​_is​_lexical​_equivalent Return True if this _expression.FromClause and the other represent the same lexical identity.
Method ​_reset​_column​_collection Reset the attributes linked to the FromClause.c attribute.
Class Variable ​_is​_from​_clause Undocumented
Class Variable ​_select​_iterable Undocumented
Class Variable ​_use​_schema​_map Undocumented
Class Variable is​_selectable Undocumented
Class Variable named​_with​_column Undocumented
Instance Variable ​_columns Undocumented
Property ​_cols​_populated Undocumented
Property columns A named-based collection of _expression.ColumnElement objects maintained by this _expression.FromClause.
Property entity​_namespace Return a namespace used for name-based access in SQL expressions.
Property exported​_columns A _expression.ColumnCollection that represents the "exported" columns of this _expression.Selectable.

Inherited from FromClauseRole (via FromClause, AnonymizedFromClauseRole, StrictFromClauseRole):

Class Variable ​_is​_subquery Undocumented
Class Variable ​_role​_name Undocumented

Inherited from AllowsLambdaRole (via FromClause, AnonymizedFromClauseRole, StrictFromClauseRole, FromClauseRole, ColumnsClauseRole):

Class Variable allows​_lambda Undocumented

Inherited from UsesInspection (via FromClause, AnonymizedFromClauseRole, StrictFromClauseRole, FromClauseRole, ColumnsClauseRole):

Class Variable ​_post​_inspect Undocumented
Class Variable uses​_inspection Undocumented

Inherited from SQLRole (via FromClause, AnonymizedFromClauseRole, StrictFromClauseRole, FromClauseRole, ColumnsClauseRole, ColumnListRole):

Class Variable allows​_lambda Undocumented
Class Variable uses​_inspection Undocumented

Inherited from AllowsLambdaRole (via FromClause, AnonymizedFromClauseRole, StrictFromClauseRole, FromClauseRole, JoinTargetRole):

Class Variable allows​_lambda Undocumented

Inherited from UsesInspection (via FromClause, AnonymizedFromClauseRole, StrictFromClauseRole, FromClauseRole, JoinTargetRole):

Class Variable ​_post​_inspect Undocumented
Class Variable uses​_inspection Undocumented

Inherited from SQLRole (via FromClause, AnonymizedFromClauseRole, StrictFromClauseRole, FromClauseRole, JoinTargetRole, StructuralRole):

Class Variable allows​_lambda Undocumented
Class Variable uses​_inspection Undocumented

Inherited from Selectable (via FromClause):

Method corresponding​_column No summary
Method lateral Return a LATERAL alias of this _expression.Selectable.
Method replace​_selectable Replace all occurrences of _expression.FromClause 'old' with the given _expression.Alias object, returning a copy of this _expression.FromClause.

Inherited from ReturnsRows (via FromClause, Selectable):

Class Variable ​_is​_lateral Undocumented
Class Variable ​_is​_returns​_rows Undocumented
Class Variable ​_is​_select​_statement Undocumented
Property ​_all​_selected​_columns A sequence of column expression objects that represents the "selected" columns of this _expression.ReturnsRows.
Property selectable Undocumented

Inherited from ReturnsRowsRole (via FromClause, Selectable, ReturnsRows):

Class Variable ​_role​_name Undocumented

Inherited from SQLRole (via FromClause, Selectable, ReturnsRows, ReturnsRowsRole):

Class Variable allows​_lambda Undocumented
Class Variable uses​_inspection Undocumented

Inherited from ClauseElement (via FromClause, Selectable, ReturnsRows):

Method compare Compare this _expression.ClauseElement to the given _expression.ClauseElement.
Method compile Compile this SQL expression.
Method params Return a copy with _expression.bindparam elements replaced.
Method unique​_params Return a copy with _expression.bindparam elements replaced.
Method __bool__ Undocumented
Method __getstate__ Undocumented
Method __invert__ Undocumented
Method __repr__ Undocumented
Method __str__ Undocumented
Method ​_clone Create a shallow copy of this ClauseElement.
Method ​_cloned​_set Return the set consisting all cloned ancestors of this ClauseElement.
Method ​_compile​_w​_cache Undocumented
Method ​_compiler Return a compiler appropriate for this ClauseElement, given a Dialect.
Method ​_execute​_on​_connection Undocumented
Method ​_negate Undocumented
Method ​_negate​_in​_binary a hook to allow the right side of a binary expression to respond to a negation of the binary expression.
Method ​_replace​_params Undocumented
Method ​_set​_propagate​_attrs Undocumented
Method ​_ungroup Return this _expression.ClauseElement without any groupings.
Method ​_with​_binary​_element​_type in the context of binary expression, convert the type of this object to the one given.
Class Variable ​_cache​_key​_traversal Undocumented
Class Variable ​_is​_bind​_parameter Undocumented
Class Variable ​_is​_clause​_list Undocumented
Class Variable ​_is​_clone​_of Undocumented
Class Variable ​_is​_from​_container Undocumented
Class Variable ​_is​_immutable Undocumented
Class Variable ​_is​_lambda​_element Undocumented
Class Variable ​_is​_select​_container Undocumented
Class Variable ​_is​_singleton​_constant Undocumented
Class Variable ​_is​_text​_clause Undocumented
Class Variable ​_is​_textual Undocumented
Class Variable ​_order​_by​_label​_element Undocumented
Class Variable is​_clause​_element Undocumented
Class Variable stringify​_dialect Undocumented
Class Variable supports​_execution Undocumented
Instance Variable ​_propagate​_attrs like annotations, however these propagate outwards liberally as SQL constructs are built, and are set up at construction time.
Property ​_constructor return the 'constructor' for this ClauseElement.

Inherited from SQLRole (via FromClause, Selectable, ReturnsRows, ClauseElement):

Class Variable allows​_lambda Undocumented
Class Variable uses​_inspection Undocumented

Inherited from SupportsWrappingAnnotations (via FromClause, Selectable, ReturnsRows, ClauseElement):

Method ​_annotate return a copy of this ClauseElement with annotations updated by the given dictionary.
Method ​_deannotate return a copy of this _expression.ClauseElement with annotations removed.
Method ​_with​_annotations return a copy of this ClauseElement with annotations replaced by the given dictionary.

Inherited from SupportsAnnotations (via FromClause, Selectable, ReturnsRows, ClauseElement, SupportsWrappingAnnotations):

Property ​_annotations​_cache​_key Undocumented

Inherited from MemoizedHasCacheKey (via FromClause, Selectable, ReturnsRows, ClauseElement):

Method ​_generate​_cache​_key return a cache key.

Inherited from HasCacheKey (via FromClause, Selectable, ReturnsRows, ClauseElement, MemoizedHasCacheKey):

Class Variable inherit​_cache Indicate if this .HasCacheKey instance should make use of the cache key generation scheme used by its immediate superclass.
Class Method ​_generate​_cache​_attrs generate cache key dispatcher for a new class.
Class Method ​_generate​_cache​_key​_for​_object Undocumented
Method ​_gen​_cache​_key return an optional cache key.
Class Variable __slots__ Undocumented
Class Variable ​_hierarchy​_supports​_caching private attribute which may be set to False to prevent the inherit_cache warning from being emitted for a hierarchy of subclasses.
Class Variable ​_is​_has​_cache​_key Undocumented

Inherited from Traversible (via FromClause, Selectable, ReturnsRows, ClauseElement):

Method get​_children Return immediate child .visitors.Traversible elements of this .visitors.Traversible.
Method __class​_getitem__ Undocumented
def __init__(self, left, right, onclause=None, isouter=False, full=False):

Construct a new _expression.Join.

The usual entrypoint here is the _expression.join function or the _expression.FromClause.join method of any _expression.FromClause object.

@util.deprecated_20(':meth:`_sql.Join.alias`', alternative='Create a select + subquery, or alias the individual tables inside the join, instead.')
def alias(self, name=None, flat=False):

Return an alias of this _expression.Join.

The default behavior here is to first produce a SELECT construct from this _expression.Join, then to produce an _expression.Alias from that. So given a join of the form:

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

The JOIN by itself would look like:

table_a JOIN table_b ON table_a.id = table_b.a_id

Whereas the alias of the above, j.alias(), would in a SELECT context look like:

(SELECT table_a.id AS table_a_id, table_b.id AS table_b_id,
    table_b.a_id AS table_b_a_id
    FROM table_a
    JOIN table_b ON table_a.id = table_b.a_id) AS anon_1

The equivalent long-hand form, given a _expression.Join object j, is:

from sqlalchemy import select, alias
j = alias(
    select(j.left, j.right).\
        select_from(j).\
        set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL).\
        correlate(False),
    name=name
)

The selectable produced by _expression.Join.alias features the same columns as that of the two individual selectables presented under a single name - the individual columns are "auto-labeled", meaning the .c. collection of the resulting _expression.Alias represents the names of the individual columns using a <tablename>_<columname> scheme:

j.c.table_a_id
j.c.table_b_a_id

_expression.Join.alias also features an alternate option for aliasing joins which produces no enclosing SELECT and does not normally apply labels to the column names. The flat=True option will call _expression.FromClause.alias against the left and right sides individually. Using this option, no new SELECT is produced; we instead, from a construct as below:

j = table_a.join(table_b, table_a.c.id == table_b.c.a_id)
j = j.alias(flat=True)

we get a result like this:

table_a AS table_a_1 JOIN table_b AS table_b_1 ON
table_a_1.id = table_b_1.a_id

The flat=True argument is also propagated to the contained selectables, so that a composite join such as:

j = table_a.join(
        table_b.join(table_c,
                table_b.c.id == table_c.c.b_id),
        table_b.c.a_id == table_a.c.id
    ).alias(flat=True)

Will produce an expression like:

table_a AS table_a_1 JOIN (
        table_b AS table_b_1 JOIN table_c AS table_c_1
        ON table_b_1.id = table_c_1.b_id
) ON table_a_1.id = table_b_1.a_id

The standalone _expression.alias function as well as the base _expression.FromClause.alias method also support the flat=True argument as a no-op, so that the argument can be passed to the alias() method of any selectable.

See Also

:ref:`core_tutorial_aliases`

_expression.alias

Parameters
namename given to the alias.
flatif True, produce an alias of the left and right sides of this _expression.Join and return the join of those two selectables. This produces join expression that does not include an enclosing SELECT.
def is_derived_from(self, fromclause):

Return True if this _expression.FromClause is 'derived' from the given FromClause.

An example would be an Alias of a Table is derived from that Table.

@util.deprecated_params(whereclause=('2.0', 'The :paramref:`_sql.Join.select().whereclause` parameter is deprecated and will be removed in version 2.0. Please make use of the :meth:`.Select.where` method to add WHERE criteria to the SELECT statement.'), kwargs=('2.0', 'The :meth:`_sql.Join.select` method will no longer accept keyword arguments in version 2.0. Please use generative methods from the :class:`_sql.Select` construct in order to apply additional modifications.'))
def select(self, whereclause=None, **kwargs):

Create a _expression.Select from this _expression.Join.

E.g.:

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

stmt = stmt.select()

The above will produce a SQL string resembling:

SELECT table_a.id, table_a.col, table_b.id, table_b.a_id
FROM table_a JOIN table_b ON table_a.id = table_b.a_id
Parameters
whereclauseWHERE criteria, same as calling _sql.Select.where on the resulting statement
**kwargsadditional keyword arguments are passed to the legacy constructor for _sql.Select described at _sql.Select.create_legacy_select.
def self_group(self, against=None):

Apply a 'grouping' to this _expression.ClauseElement.

This method is overridden by subclasses to return a "grouping" construct, i.e. parenthesis. In particular it's used by "binary" expressions to provide a grouping around themselves when placed into a larger expression, as well as by _expression.select constructs when placed into the FROM clause of another _expression.select. (Note that subqueries should be normally created using the _expression.Select.alias method, as many platforms require nested SELECT statements to be named).

As expressions are composed together, the application of self_group is automatic - end-user code should never need to use this method directly. Note that SQLAlchemy's clause constructs take operator precedence into account - so parenthesis might not be needed, for example, in an expression like x OR (y AND z) - AND takes precedence over OR.

The base self_group method of _expression.ClauseElement just returns self.

@classmethod
def _can_join(cls, left, right, consider_as_foreign_keys=None):

Undocumented

@classmethod
def _create_join(cls, left, right, onclause=None, isouter=False, full=False):

Produce a _expression.Join object, given two _expression.FromClause expressions.

E.g.:

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

would emit SQL along the lines of:

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

Similar functionality is available given any _expression.FromClause object (e.g. such as a _schema.Table) using the _expression.FromClause.join method.

See Also

_expression.FromClause.join - method form, based on a given left side.

_expression.Join - the type of object produced.

Parameters
leftThe left side of the join.
rightthe right side of the join; this is any _expression.FromClause object such as a _schema.Table object, and may also be a selectable-compatible object such as an ORM-mapped class.
onclausea SQL expression representing the ON clause of the join. If left at None, _expression.FromClause.join will attempt to join the two tables based on a foreign key relationship.
isouterif True, render a LEFT OUTER JOIN, instead of JOIN.
full

if True, render a FULL OUTER JOIN, instead of JOIN.

New in version 1.1.
@classmethod
def _create_outerjoin(cls, left, right, onclause=None, full=False):

Return an OUTER JOIN clause element.

The returned object is an instance of _expression.Join.

Similar functionality is also available via the _expression.FromClause.outerjoin method on any _expression.FromClause.

To chain joins together, use the _expression.FromClause.join or _expression.FromClause.outerjoin methods on the resulting _expression.Join object.

Parameters
leftThe left side of the join.
rightThe right side of the join.
onclauseOptional criterion for the ON clause, is derived from foreign key relationships established between left and right otherwise.
fullUndocumented
@classmethod
def _join_condition(cls, a, b, a_subset=None, consider_as_foreign_keys=None):

Create a join condition between two tables or selectables.

e.g.:

join_condition(tablea, tableb)

would produce an expression along the lines of:

tablea.c.id==tableb.c.tablea_id

The join is determined based on the foreign key relationships between the two selectables. If there are multiple ways to join, or no way to join, an error is raised.

Parameters
aUndocumented
bUndocumented
a​_subsetAn optional expression that is a sub-component of a. An attempt will be made to join to just this sub-component first before looking at the full a construct, and if found will be successful even if there are other ways to join to a. This allows the "right side" of a join to be passed thereby providing a "natural join".
consider​_as​_foreign​_keysUndocumented
@classmethod
@util.preload_module('sqlalchemy.sql.util')
def _joincond_scan_left_right(cls, a, a_subset, b, consider_as_foreign_keys):

Undocumented

@classmethod
def _joincond_trim_constraints(cls, a, b, constraints, consider_as_foreign_keys):

Undocumented

@util.preload_module('sqlalchemy.sql.util')
def _anonymous_fromclause(self, name=None, flat=False):
def _copy_internals(self, clone=_clone, **kw):

Reassign internal elements to be clones of themselves.

Called during a copy-and-traverse operation on newly shallow-copied elements to create a deep copy.

The given clone function should be used, which may be applying additional transformations to the element (i.e. replacement traversal, cloned traversal, annotations).

def _match_primaries(self, left, right):

Undocumented

@util.preload_module('sqlalchemy.sql.util')
def _populate_column_collection(self):

Called on subclasses to establish the .c collection.

Each implementation has a different way of establishing this collection.

def _refresh_for_new_column(self, column):

Given a column added to the .c collection of an underlying selectable, produce the local version of that column, assuming this selectable ultimately should proxy this column.

this is used to "ping" a derived selectable to add a new column to its .c. collection when a Column has been added to one of the Table objects it ultimately derives from.

If the given selectable hasn't populated its .c. collection yet, it should at least pass on the message to the contained selectables, but it will return None.

This method is currently used by Declarative to allow Table columns to be added to a partially constructed inheritance mapping that may have already produced joins. The method isn't public right now, as the full span of implications and/or caveats aren't yet clear.

It's also possible that this functionality could be invoked by default via an event, which would require that selectables maintain a weak referencing collection of all derivations.

__visit_name__: str =
_is_join: bool =
_traverse_internals =

Undocumented

full =

Undocumented

isouter =

Undocumented

left =

Undocumented

onclause =

Undocumented

right =

Undocumented

@property
_from_objects =
@property
_hide_froms =
@property
@util.deprecated_20(':attr:`.Executable.bind`', alternative='Bound metadata is being removed as of SQLAlchemy 2.0.', enable_warnings=False)
bind =
Return the bound engine associated with either the left or right side of this _sql.Join.
@property
description =

A brief description of this _expression.FromClause.

Used primarily for error message formatting.