Function join_inner

python/pathway/internals/joins.py:1241–1304

Inner-joins two tables or join results. Args: left: the left side of the join, ``Table`` or ``JoinResult``. right: the right side of the join, ``Table`` or ``JoinResult``. on: a list of column expressions. Each must have == as the top level operation and b

(
    left: Joinable,
    right: Joinable,
    *on: expr.ColumnExpression,
    id: expr.ColumnReference | None = None,
    left_instance: expr.ColumnReference | None = None,
    right_instance: expr.ColumnReference | None = None,
    left_exactly_once: bool = False,
    right_exactly_once: bool = False,
)

def join_inner(
    left: Joinable,
    right: Joinable,
    *on: expr.ColumnExpression,
    id: expr.ColumnReference | None = None,
    left_instance: expr.ColumnReference | None = None,
    right_instance: expr.ColumnReference | None = None,
    left_exactly_once: bool = False,
    right_exactly_once: bool = False,
) -> JoinResult:
    """Inner-joins two tables or join results.

    Args:
        left:  the left side of the join, ``Table`` or ``JoinResult``.
        right:  the right side of the join, ``Table`` or ``JoinResult``.
        on:  a list of column expressions. Each must have == as the top level operation
            and be of the form LHS: ColumnReference == RHS: ColumnReference.
        id: optional argument for id of result, can be only self.id or other.id
        left_instance/right_instance: optional arguments describing partitioning of the data into
            separate instances
        left_exactly_once: if you can guarantee that each row on the left side of the join will be
            joined at most once, then you can set this parameter to ``True``. Then each row after
            getting a match is removed from the join state. As a result, less memory is needed.
            Works only for append-only tables.
        right_exactly_once: if you can guarantee that each row on the right side of the join will be
            joined at most once, then you can set this parameter to ``True``. Then each row after
            getting a match is removed from the join state. As a result, less memory is needed.
            Works only for append-only tables.

    Returns:
        JoinResult: an object on which `.select()` may be called to extract relevant
        columns from the result of the join.

    Example:

    >>> import pathway as pw
    >>> t1 = pw.debug.table_from_markdown('''
    ... age  | owner  | pet
    ...  10  | Alice  | 1
    ...   9  | Bob    | 1
    ...   8  | Alice  | 2
    ... ''')
    >>> t2 = pw.debug.table_from_markdown('''
    ... age  | owner  | pet | size
    ...  10  | Alice  | 3   | M
    ...  9   | Bob    | 1   | L
    ...  8   | Tom    | 1   | XL
    ... ''')
    >>> t3 = pw.join_inner(t1, t2, t1.pet == t2.pet, t1.owner == t2.owner).select(
    ...     age=t1.age, owner_name=t2.owner, size=t2.size
    ... )
    >>> pw.debug.compute_and_print(t3, include_id = False)
    age | owner_name | size
    9   | Bob        | L
    """
    return left.join_inner(
        right,
        *on,