id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
152,975 | from __future__ import annotations
import datetime
import inspect
import logging
import re
import sys
import typing as t
from collections.abc import Collection, Set
from contextlib import contextmanager
from copy import copy
from enum import Enum
from itertools import count
if t.TYPE_CHECKING:
from sqlglot import exp
from sqlglot._typing import A, E, T
from sqlglot.expressions import Expression
logger = logging.getLogger("sqlglot")
E = t.TypeVar("E", bound="sqlglot.exp.Expression")
class Expression(metaclass=_Expression):
"""
The base class for all expressions in a syntax tree. Each Expression encapsulates any necessary
context, such as its child expressions, their names (arg keys), and whether a given child expression
is optional or not.
Attributes:
key: a unique key for each class in the Expression hierarchy. This is useful for hashing
and representing expressions as strings.
arg_types: determines the arguments (child nodes) supported by an expression. It maps
arg keys to booleans that indicate whether the corresponding args are optional.
parent: a reference to the parent expression (or None, in case of root expressions).
arg_key: the arg key an expression is associated with, i.e. the name its parent expression
uses to refer to it.
index: the index of an expression if it is inside of a list argument in its parent
comments: a list of comments that are associated with a given expression. This is used in
order to preserve comments when transpiling SQL code.
type: the `sqlglot.expressions.DataType` type of an expression. This is inferred by the
optimizer, in order to enable some transformations that require type information.
meta: a dictionary that can be used to store useful metadata for a given expression.
Example:
>>> class Foo(Expression):
... arg_types = {"this": True, "expression": False}
The above definition informs us that Foo is an Expression that requires an argument called
"this" and may also optionally receive an argument called "expression".
Args:
args: a mapping used for retrieving the arguments of an expression, given their arg keys.
"""
key = "expression"
arg_types = {"this": True}
__slots__ = ("args", "parent", "arg_key", "index", "comments", "_type", "_meta", "_hash")
def __init__(self, **args: t.Any):
self.args: t.Dict[str, t.Any] = args
self.parent: t.Optional[Expression] = None
self.arg_key: t.Optional[str] = None
self.index: t.Optional[int] = None
self.comments: t.Optional[t.List[str]] = None
self._type: t.Optional[DataType] = None
self._meta: t.Optional[t.Dict[str, t.Any]] = None
self._hash: t.Optional[int] = None
for arg_key, value in self.args.items():
self._set_parent(arg_key, value)
def __eq__(self, other) -> bool:
return type(self) is type(other) and hash(self) == hash(other)
def hashable_args(self) -> t.Any:
return frozenset(
(k, tuple(_norm_arg(a) for a in v) if type(v) is list else _norm_arg(v))
for k, v in self.args.items()
if not (v is None or v is False or (type(v) is list and not v))
)
def __hash__(self) -> int:
if self._hash is not None:
return self._hash
return hash((self.__class__, self.hashable_args))
def this(self) -> t.Any:
"""
Retrieves the argument with key "this".
"""
return self.args.get("this")
def expression(self) -> t.Any:
"""
Retrieves the argument with key "expression".
"""
return self.args.get("expression")
def expressions(self) -> t.List[t.Any]:
"""
Retrieves the argument with key "expressions".
"""
return self.args.get("expressions") or []
def text(self, key) -> str:
"""
Returns a textual representation of the argument corresponding to "key". This can only be used
for args that are strings or leaf Expression instances, such as identifiers and literals.
"""
field = self.args.get(key)
if isinstance(field, str):
return field
if isinstance(field, (Identifier, Literal, Var)):
return field.this
if isinstance(field, (Star, Null)):
return field.name
return ""
def is_string(self) -> bool:
"""
Checks whether a Literal expression is a string.
"""
return isinstance(self, Literal) and self.args["is_string"]
def is_number(self) -> bool:
"""
Checks whether a Literal expression is a number.
"""
return isinstance(self, Literal) and not self.args["is_string"]
def is_int(self) -> bool:
"""
Checks whether a Literal expression is an integer.
"""
return self.is_number and is_int(self.name)
def is_star(self) -> bool:
"""Checks whether an expression is a star."""
return isinstance(self, Star) or (isinstance(self, Column) and isinstance(self.this, Star))
def alias(self) -> str:
"""
Returns the alias of the expression, or an empty string if it's not aliased.
"""
if isinstance(self.args.get("alias"), TableAlias):
return self.args["alias"].name
return self.text("alias")
def alias_column_names(self) -> t.List[str]:
table_alias = self.args.get("alias")
if not table_alias:
return []
return [c.name for c in table_alias.args.get("columns") or []]
def name(self) -> str:
return self.text("this")
def alias_or_name(self) -> str:
return self.alias or self.name
def output_name(self) -> str:
"""
Name of the output column if this expression is a selection.
If the Expression has no output name, an empty string is returned.
Example:
>>> from sqlglot import parse_one
>>> parse_one("SELECT a").expressions[0].output_name
'a'
>>> parse_one("SELECT b AS c").expressions[0].output_name
'c'
>>> parse_one("SELECT 1 + 2").expressions[0].output_name
''
"""
return ""
def type(self) -> t.Optional[DataType]:
return self._type
def type(self, dtype: t.Optional[DataType | DataType.Type | str]) -> None:
if dtype and not isinstance(dtype, DataType):
dtype = DataType.build(dtype)
self._type = dtype # type: ignore
def is_type(self, *dtypes) -> bool:
return self.type is not None and self.type.is_type(*dtypes)
def is_leaf(self) -> bool:
return not any(isinstance(v, (Expression, list)) for v in self.args.values())
def meta(self) -> t.Dict[str, t.Any]:
if self._meta is None:
self._meta = {}
return self._meta
def __deepcopy__(self, memo):
root = self.__class__()
stack = [(self, root)]
while stack:
node, copy = stack.pop()
if node.comments is not None:
copy.comments = deepcopy(node.comments)
if node._type is not None:
copy._type = deepcopy(node._type)
if node._meta is not None:
copy._meta = deepcopy(node._meta)
if node._hash is not None:
copy._hash = node._hash
for k, vs in node.args.items():
if hasattr(vs, "parent"):
stack.append((vs, vs.__class__()))
copy.set(k, stack[-1][-1])
elif type(vs) is list:
copy.args[k] = []
for v in vs:
if hasattr(v, "parent"):
stack.append((v, v.__class__()))
copy.append(k, stack[-1][-1])
else:
copy.append(k, v)
else:
copy.args[k] = vs
return root
def copy(self):
"""
Returns a deep copy of the expression.
"""
return deepcopy(self)
def add_comments(self, comments: t.Optional[t.List[str]]) -> None:
if self.comments is None:
self.comments = []
if comments:
for comment in comments:
_, *meta = comment.split(SQLGLOT_META)
if meta:
for kv in "".join(meta).split(","):
k, *v = kv.split("=")
value = v[0].strip() if v else True
self.meta[k.strip()] = value
self.comments.append(comment)
def append(self, arg_key: str, value: t.Any) -> None:
"""
Appends value to arg_key if it's a list or sets it as a new list.
Args:
arg_key (str): name of the list expression arg
value (Any): value to append to the list
"""
if type(self.args.get(arg_key)) is not list:
self.args[arg_key] = []
self._set_parent(arg_key, value)
values = self.args[arg_key]
if hasattr(value, "parent"):
value.index = len(values)
values.append(value)
def set(self, arg_key: str, value: t.Any) -> None:
"""
Sets arg_key to value.
Args:
arg_key: name of the expression arg.
value: value to set the arg to.
"""
if value is None:
self.args.pop(arg_key, None)
else:
self.args[arg_key] = value
self._set_parent(arg_key, value)
def _set_parent(self, arg_key: str, value: t.Any, index: t.Optional[int] = None) -> None:
if hasattr(value, "parent"):
value.parent = self
value.arg_key = arg_key
value.index = index
elif type(value) is list:
for index, v in enumerate(value):
if hasattr(v, "parent"):
v.parent = self
v.arg_key = arg_key
v.index = index
def depth(self) -> int:
"""
Returns the depth of this tree.
"""
if self.parent:
return self.parent.depth + 1
return 0
def iter_expressions(self, reverse: bool = False) -> t.Iterator[Expression]:
"""Yields the key and expression for all arguments, exploding list args."""
# remove tuple when python 3.7 is deprecated
for vs in reversed(tuple(self.args.values())) if reverse else self.args.values():
if type(vs) is list:
for v in reversed(vs) if reverse else vs:
if hasattr(v, "parent"):
yield v
else:
if hasattr(vs, "parent"):
yield vs
def find(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Optional[E]:
"""
Returns the first node in this tree which matches at least one of
the specified types.
Args:
expression_types: the expression type(s) to match.
bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
Returns:
The node which matches the criteria or None if no such node was found.
"""
return next(self.find_all(*expression_types, bfs=bfs), None)
def find_all(self, *expression_types: t.Type[E], bfs: bool = True) -> t.Iterator[E]:
"""
Returns a generator object which visits all nodes in this tree and only
yields those that match at least one of the specified expression types.
Args:
expression_types: the expression type(s) to match.
bfs: whether to search the AST using the BFS algorithm (DFS is used if false).
Returns:
The generator object.
"""
for expression in self.walk(bfs=bfs):
if isinstance(expression, expression_types):
yield expression
def find_ancestor(self, *expression_types: t.Type[E]) -> t.Optional[E]:
"""
Returns a nearest parent matching expression_types.
Args:
expression_types: the expression type(s) to match.
Returns:
The parent node.
"""
ancestor = self.parent
while ancestor and not isinstance(ancestor, expression_types):
ancestor = ancestor.parent
return ancestor # type: ignore
def parent_select(self) -> t.Optional[Select]:
"""
Returns the parent select statement.
"""
return self.find_ancestor(Select)
def same_parent(self) -> bool:
"""Returns if the parent is the same class as itself."""
return type(self.parent) is self.__class__
def root(self) -> Expression:
"""
Returns the root expression of this tree.
"""
expression = self
while expression.parent:
expression = expression.parent
return expression
def walk(
self, bfs: bool = True, prune: t.Optional[t.Callable[[Expression], bool]] = None
) -> t.Iterator[Expression]:
"""
Returns a generator object which visits all nodes in this tree.
Args:
bfs (bool): if set to True the BFS traversal order will be applied,
otherwise the DFS traversal will be used instead.
prune ((node, parent, arg_key) -> bool): callable that returns True if
the generator should stop traversing this branch of the tree.
Returns:
the generator object.
"""
if bfs:
yield from self.bfs(prune=prune)
else:
yield from self.dfs(prune=prune)
def dfs(
self, prune: t.Optional[t.Callable[[Expression], bool]] = None
) -> t.Iterator[Expression]:
"""
Returns a generator object which visits all nodes in this tree in
the DFS (Depth-first) order.
Returns:
The generator object.
"""
stack = [self]
while stack:
node = stack.pop()
yield node
if prune and prune(node):
continue
for v in node.iter_expressions(reverse=True):
stack.append(v)
def bfs(
self, prune: t.Optional[t.Callable[[Expression], bool]] = None
) -> t.Iterator[Expression]:
"""
Returns a generator object which visits all nodes in this tree in
the BFS (Breadth-first) order.
Returns:
The generator object.
"""
queue = deque([self])
while queue:
node = queue.popleft()
yield node
if prune and prune(node):
continue
for v in node.iter_expressions():
queue.append(v)
def unnest(self):
"""
Returns the first non parenthesis child or self.
"""
expression = self
while type(expression) is Paren:
expression = expression.this
return expression
def unalias(self):
"""
Returns the inner expression if this is an Alias.
"""
if isinstance(self, Alias):
return self.this
return self
def unnest_operands(self):
"""
Returns unnested operands as a tuple.
"""
return tuple(arg.unnest() for arg in self.iter_expressions())
def flatten(self, unnest=True):
"""
Returns a generator which yields child nodes whose parents are the same class.
A AND B AND C -> [A, B, C]
"""
for node in self.dfs(prune=lambda n: n.parent and type(n) is not self.__class__):
if type(node) is not self.__class__:
yield node.unnest() if unnest and not isinstance(node, Subquery) else node
def __str__(self) -> str:
return self.sql()
def __repr__(self) -> str:
return _to_s(self)
def to_s(self) -> str:
"""
Same as __repr__, but includes additional information which can be useful
for debugging, like empty or missing args and the AST nodes' object IDs.
"""
return _to_s(self, verbose=True)
def sql(self, dialect: DialectType = None, **opts) -> str:
"""
Returns SQL string representation of this tree.
Args:
dialect: the dialect of the output SQL string (eg. "spark", "hive", "presto", "mysql").
opts: other `sqlglot.generator.Generator` options.
Returns:
The SQL string.
"""
from sqlglot.dialects import Dialect
return Dialect.get_or_raise(dialect).generate(self, **opts)
def transform(self, fun: t.Callable, *args: t.Any, copy: bool = True, **kwargs) -> Expression:
"""
Visits all tree nodes (excluding already transformed ones)
and applies the given transformation function to each node.
Args:
fun (function): a function which takes a node as an argument and returns a
new transformed node or the same node without modifications. If the function
returns None, then the corresponding node will be removed from the syntax tree.
copy (bool): if set to True a new tree instance is constructed, otherwise the tree is
modified in place.
Returns:
The transformed tree.
"""
root = None
new_node = None
for node in (self.copy() if copy else self).dfs(prune=lambda n: n is not new_node):
new_node = fun(node, *args, **kwargs)
if root:
if new_node is not node:
node.replace(new_node)
else:
root = new_node
assert root
return root.assert_is(Expression)
def replace(self, expression: E) -> E: ...
def replace(self, expression: None) -> None: ...
def replace(self, expression):
"""
Swap out this expression with a new expression.
For example::
>>> tree = Select().select("x").from_("tbl")
>>> tree.find(Column).replace(column("y"))
Column(
this=Identifier(this=y, quoted=False))
>>> tree.sql()
'SELECT y FROM tbl'
Args:
expression: new node
Returns:
The new expression or expressions.
"""
parent = self.parent
if not parent:
return expression
key = self.arg_key
value = parent.args.get(key)
if isinstance(value, list):
index = self.index
if isinstance(expression, list):
value.pop(index)
value[index:index] = expression
parent._set_parent(key, value)
else:
if expression is None:
value.pop(index)
for v in value[index:]:
v.index = v.index - 1
else:
value[index] = expression
parent._set_parent(key, expression, index=index)
elif value is not None:
if expression is None:
parent.args.pop(key)
else:
parent.set(key, expression)
if expression is not self:
self.parent = None
self.arg_key = None
self.index = None
return expression
def pop(self: E) -> E:
"""
Remove this expression from its AST.
Returns:
The popped expression.
"""
self.replace(None)
return self
def assert_is(self, type_: t.Type[E]) -> E:
"""
Assert that this `Expression` is an instance of `type_`.
If it is NOT an instance of `type_`, this raises an assertion error.
Otherwise, this returns this expression.
Examples:
This is useful for type security in chained expressions:
>>> import sqlglot
>>> sqlglot.parse_one("SELECT x from y").assert_is(Select).select("z").sql()
'SELECT x, z FROM y'
"""
if not isinstance(self, type_):
raise AssertionError(f"{self} is not {type_}.")
return self
def error_messages(self, args: t.Optional[t.Sequence] = None) -> t.List[str]:
"""
Checks if this expression is valid (e.g. all mandatory args are set).
Args:
args: a sequence of values that were used to instantiate a Func expression. This is used
to check that the provided arguments don't exceed the function argument limit.
Returns:
A list of error messages for all possible errors that were found.
"""
errors: t.List[str] = []
for k in self.args:
if k not in self.arg_types:
errors.append(f"Unexpected keyword: '{k}' for {self.__class__}")
for k, mandatory in self.arg_types.items():
v = self.args.get(k)
if mandatory and (v is None or (isinstance(v, list) and not v)):
errors.append(f"Required keyword: '{k}' missing for {self.__class__}")
if (
args
and isinstance(self, Func)
and len(args) > len(self.arg_types)
and not self.is_var_len_args
):
errors.append(
f"The number of provided arguments ({len(args)}) is greater than "
f"the maximum number of supported arguments ({len(self.arg_types)})"
)
return errors
def dump(self):
"""
Dump this Expression to a JSON-serializable dict.
"""
from sqlglot.serde import dump
return dump(self)
def load(cls, obj):
"""
Load a dict (as returned by `Expression.dump`) into an Expression instance.
"""
from sqlglot.serde import load
return load(obj)
def and_(
self,
*expressions: t.Optional[ExpOrStr],
dialect: DialectType = None,
copy: bool = True,
**opts,
) -> Condition:
"""
AND this condition with one or multiple expressions.
Example:
>>> condition("x=1").and_("y=1").sql()
'x = 1 AND y = 1'
Args:
*expressions: the SQL code strings to parse.
If an `Expression` instance is passed, it will be used as-is.
dialect: the dialect used to parse the input expression.
copy: whether to copy the involved expressions (only applies to Expressions).
opts: other options to use to parse the input expressions.
Returns:
The new And condition.
"""
return and_(self, *expressions, dialect=dialect, copy=copy, **opts)
def or_(
self,
*expressions: t.Optional[ExpOrStr],
dialect: DialectType = None,
copy: bool = True,
**opts,
) -> Condition:
"""
OR this condition with one or multiple expressions.
Example:
>>> condition("x=1").or_("y=1").sql()
'x = 1 OR y = 1'
Args:
*expressions: the SQL code strings to parse.
If an `Expression` instance is passed, it will be used as-is.
dialect: the dialect used to parse the input expression.
copy: whether to copy the involved expressions (only applies to Expressions).
opts: other options to use to parse the input expressions.
Returns:
The new Or condition.
"""
return or_(self, *expressions, dialect=dialect, copy=copy, **opts)
def not_(self, copy: bool = True):
"""
Wrap this condition with NOT.
Example:
>>> condition("x=1").not_().sql()
'NOT x = 1'
Args:
copy: whether to copy this object.
Returns:
The new Not instance.
"""
return not_(self, copy=copy)
def as_(
self,
alias: str | Identifier,
quoted: t.Optional[bool] = None,
dialect: DialectType = None,
copy: bool = True,
**opts,
) -> Alias:
return alias_(self, alias, quoted=quoted, dialect=dialect, copy=copy, **opts)
def _binop(self, klass: t.Type[E], other: t.Any, reverse: bool = False) -> E:
this = self.copy()
other = convert(other, copy=True)
if not isinstance(this, klass) and not isinstance(other, klass):
this = _wrap(this, Binary)
other = _wrap(other, Binary)
if reverse:
return klass(this=other, expression=this)
return klass(this=this, expression=other)
def __getitem__(self, other: ExpOrStr | t.Tuple[ExpOrStr]) -> Bracket:
return Bracket(
this=self.copy(), expressions=[convert(e, copy=True) for e in ensure_list(other)]
)
def __iter__(self) -> t.Iterator:
if "expressions" in self.arg_types:
return iter(self.args.get("expressions") or [])
# We define this because __getitem__ converts Expression into an iterable, which is
# problematic because one can hit infinite loops if they do "for x in some_expr: ..."
# See: https://peps.python.org/pep-0234/
raise TypeError(f"'{self.__class__.__name__}' object is not iterable")
def isin(
self,
*expressions: t.Any,
query: t.Optional[ExpOrStr] = None,
unnest: t.Optional[ExpOrStr] | t.Collection[ExpOrStr] = None,
copy: bool = True,
**opts,
) -> In:
return In(
this=maybe_copy(self, copy),
expressions=[convert(e, copy=copy) for e in expressions],
query=maybe_parse(query, copy=copy, **opts) if query else None,
unnest=(
Unnest(
expressions=[
maybe_parse(t.cast(ExpOrStr, e), copy=copy, **opts)
for e in ensure_list(unnest)
]
)
if unnest
else None
),
)
def between(self, low: t.Any, high: t.Any, copy: bool = True, **opts) -> Between:
return Between(
this=maybe_copy(self, copy),
low=convert(low, copy=copy, **opts),
high=convert(high, copy=copy, **opts),
)
def is_(self, other: ExpOrStr) -> Is:
return self._binop(Is, other)
def like(self, other: ExpOrStr) -> Like:
return self._binop(Like, other)
def ilike(self, other: ExpOrStr) -> ILike:
return self._binop(ILike, other)
def eq(self, other: t.Any) -> EQ:
return self._binop(EQ, other)
def neq(self, other: t.Any) -> NEQ:
return self._binop(NEQ, other)
def rlike(self, other: ExpOrStr) -> RegexpLike:
return self._binop(RegexpLike, other)
def div(self, other: ExpOrStr, typed: bool = False, safe: bool = False) -> Div:
div = self._binop(Div, other)
div.args["typed"] = typed
div.args["safe"] = safe
return div
def desc(self, nulls_first: bool = False) -> Ordered:
return Ordered(this=self.copy(), desc=True, nulls_first=nulls_first)
def __lt__(self, other: t.Any) -> LT:
return self._binop(LT, other)
def __le__(self, other: t.Any) -> LTE:
return self._binop(LTE, other)
def __gt__(self, other: t.Any) -> GT:
return self._binop(GT, other)
def __ge__(self, other: t.Any) -> GTE:
return self._binop(GTE, other)
def __add__(self, other: t.Any) -> Add:
return self._binop(Add, other)
def __radd__(self, other: t.Any) -> Add:
return self._binop(Add, other, reverse=True)
def __sub__(self, other: t.Any) -> Sub:
return self._binop(Sub, other)
def __rsub__(self, other: t.Any) -> Sub:
return self._binop(Sub, other, reverse=True)
def __mul__(self, other: t.Any) -> Mul:
return self._binop(Mul, other)
def __rmul__(self, other: t.Any) -> Mul:
return self._binop(Mul, other, reverse=True)
def __truediv__(self, other: t.Any) -> Div:
return self._binop(Div, other)
def __rtruediv__(self, other: t.Any) -> Div:
return self._binop(Div, other, reverse=True)
def __floordiv__(self, other: t.Any) -> IntDiv:
return self._binop(IntDiv, other)
def __rfloordiv__(self, other: t.Any) -> IntDiv:
return self._binop(IntDiv, other, reverse=True)
def __mod__(self, other: t.Any) -> Mod:
return self._binop(Mod, other)
def __rmod__(self, other: t.Any) -> Mod:
return self._binop(Mod, other, reverse=True)
def __pow__(self, other: t.Any) -> Pow:
return self._binop(Pow, other)
def __rpow__(self, other: t.Any) -> Pow:
return self._binop(Pow, other, reverse=True)
def __and__(self, other: t.Any) -> And:
return self._binop(And, other)
def __rand__(self, other: t.Any) -> And:
return self._binop(And, other, reverse=True)
def __or__(self, other: t.Any) -> Or:
return self._binop(Or, other)
def __ror__(self, other: t.Any) -> Or:
return self._binop(Or, other, reverse=True)
def __neg__(self) -> Neg:
return Neg(this=_wrap(self.copy(), Binary))
def __invert__(self) -> Not:
return not_(self.copy())
def annotate_types(
expression: E,
schema: t.Optional[t.Dict | Schema] = None,
annotators: t.Optional[t.Dict[t.Type[E], t.Callable[[TypeAnnotator, E], E]]] = None,
coerces_to: t.Optional[t.Dict[exp.DataType.Type, t.Set[exp.DataType.Type]]] = None,
) -> E:
"""
Infers the types of an expression, annotating its AST accordingly.
Example:
>>> import sqlglot
>>> schema = {"y": {"cola": "SMALLINT"}}
>>> sql = "SELECT x.cola + 2.5 AS cola FROM (SELECT y.cola AS cola FROM y AS y) AS x"
>>> annotated_expr = annotate_types(sqlglot.parse_one(sql), schema=schema)
>>> annotated_expr.expressions[0].type.this # Get the type of "x.cola + 2.5 AS cola"
<Type.DOUBLE: 'DOUBLE'>
Args:
expression: Expression to annotate.
schema: Database schema.
annotators: Maps expression type to corresponding annotation function.
coerces_to: Maps expression type to set of types that it can be coerced into.
Returns:
The expression annotated with types.
"""
schema = ensure_schema(schema)
return TypeAnnotator(schema, annotators, coerces_to).annotate(expression)
def simplify(
expression: exp.Expression, constant_propagation: bool = False, dialect: DialectType = None
):
"""
Rewrite sqlglot AST to simplify expressions.
Example:
>>> import sqlglot
>>> expression = sqlglot.parse_one("TRUE AND TRUE")
>>> simplify(expression).sql()
'TRUE'
Args:
expression (sqlglot.Expression): expression to simplify
constant_propagation: whether the constant propagation rule should be used
Returns:
sqlglot.Expression: simplified expression
"""
dialect = Dialect.get_or_raise(dialect)
def _simplify(expression, root=True):
if expression.meta.get(FINAL):
return expression
# group by expressions cannot be simplified, for example
# select x + 1 + 1 FROM y GROUP BY x + 1 + 1
# the projection must exactly match the group by key
group = expression.args.get("group")
if group and hasattr(expression, "selects"):
groups = set(group.expressions)
group.meta[FINAL] = True
for e in expression.selects:
for node in e.walk():
if node in groups:
e.meta[FINAL] = True
break
having = expression.args.get("having")
if having:
for node in having.walk():
if node in groups:
having.meta[FINAL] = True
break
# Pre-order transformations
node = expression
node = rewrite_between(node)
node = uniq_sort(node, root)
node = absorb_and_eliminate(node, root)
node = simplify_concat(node)
node = simplify_conditionals(node)
if constant_propagation:
node = propagate_constants(node, root)
exp.replace_children(node, lambda e: _simplify(e, False))
# Post-order transformations
node = simplify_not(node)
node = flatten(node)
node = simplify_connectors(node, root)
node = remove_complements(node, root)
node = simplify_coalesce(node)
node.parent = expression.parent
node = simplify_literals(node, root)
node = simplify_equality(node)
node = simplify_parens(node)
node = simplify_datetrunc(node, dialect)
node = sort_comparison(node)
node = simplify_startswith(node)
if root:
expression.replace(node)
return node
expression = while_changing(expression, _simplify)
remove_where_true(expression)
return expression
The provided code snippet includes necessary dependencies for implementing the `apply_index_offset` function. Write a Python function `def apply_index_offset( this: exp.Expression, expressions: t.List[E], offset: int, ) -> t.List[E]` to solve the following problem:
Applies an offset to a given integer literal expression. Args: this: The target of the index. expressions: The expression the offset will be applied to, wrapped in a list. offset: The offset that will be applied. Returns: The original expression with the offset applied to it, wrapped in a list. If the provided `expressions` argument contains more than one expression, it's returned unaffected.
Here is the function:
def apply_index_offset(
this: exp.Expression,
expressions: t.List[E],
offset: int,
) -> t.List[E]:
"""
Applies an offset to a given integer literal expression.
Args:
this: The target of the index.
expressions: The expression the offset will be applied to, wrapped in a list.
offset: The offset that will be applied.
Returns:
The original expression with the offset applied to it, wrapped in a list. If the provided
`expressions` argument contains more than one expression, it's returned unaffected.
"""
if not offset or len(expressions) != 1:
return expressions
expression = expressions[0]
from sqlglot import exp
from sqlglot.optimizer.annotate_types import annotate_types
from sqlglot.optimizer.simplify import simplify
if not this.type:
annotate_types(this)
if t.cast(exp.DataType, this.type).this not in (
exp.DataType.Type.UNKNOWN,
exp.DataType.Type.ARRAY,
):
return expressions
if not expression.type:
annotate_types(expression)
if t.cast(exp.DataType, expression.type).this in exp.DataType.INTEGER_TYPES:
logger.warning("Applying array index offset (%s)", offset)
expression = simplify(expression + offset)
return [expression]
return expressions | Applies an offset to a given integer literal expression. Args: this: The target of the index. expressions: The expression the offset will be applied to, wrapped in a list. offset: The offset that will be applied. Returns: The original expression with the offset applied to it, wrapped in a list. If the provided `expressions` argument contains more than one expression, it's returned unaffected. |
152,976 | from __future__ import annotations
import datetime
import inspect
import logging
import re
import sys
import typing as t
from collections.abc import Collection, Set
from contextlib import contextmanager
from copy import copy
from enum import Enum
from itertools import count
CAMEL_CASE_PATTERN = re.compile("(?<!^)(?=[A-Z])")
The provided code snippet includes necessary dependencies for implementing the `camel_to_snake_case` function. Write a Python function `def camel_to_snake_case(name: str) -> str` to solve the following problem:
Converts `name` from camelCase to snake_case and returns the result.
Here is the function:
def camel_to_snake_case(name: str) -> str:
"""Converts `name` from camelCase to snake_case and returns the result."""
return CAMEL_CASE_PATTERN.sub("_", name).upper() | Converts `name` from camelCase to snake_case and returns the result. |
152,977 | from __future__ import annotations
import datetime
import inspect
import logging
import re
import sys
import typing as t
from collections.abc import Collection, Set
from contextlib import contextmanager
from copy import copy
from enum import Enum
from itertools import count
if t.TYPE_CHECKING:
from sqlglot import exp
from sqlglot._typing import A, E, T
from sqlglot.expressions import Expression
The provided code snippet includes necessary dependencies for implementing the `object_to_dict` function. Write a Python function `def object_to_dict(obj: t.Any, **kwargs) -> t.Dict` to solve the following problem:
Returns a dictionary created from an object's attributes.
Here is the function:
def object_to_dict(obj: t.Any, **kwargs) -> t.Dict:
"""Returns a dictionary created from an object's attributes."""
return {
**{k: v.copy() if hasattr(v, "copy") else copy(v) for k, v in vars(obj).items()},
**kwargs,
} | Returns a dictionary created from an object's attributes. |
152,978 | from __future__ import annotations
import datetime
import inspect
import logging
import re
import sys
import typing as t
from collections.abc import Collection, Set
from contextlib import contextmanager
from copy import copy
from enum import Enum
from itertools import count
if t.TYPE_CHECKING:
from sqlglot import exp
from sqlglot._typing import A, E, T
from sqlglot.expressions import Expression
The provided code snippet includes necessary dependencies for implementing the `split_num_words` function. Write a Python function `def split_num_words( value: str, sep: str, min_num_words: int, fill_from_start: bool = True ) -> t.List[t.Optional[str]]` to solve the following problem:
Perform a split on a value and return N words as a result with `None` used for words that don't exist. Args: value: The value to be split. sep: The value to use to split on. min_num_words: The minimum number of words that are going to be in the result. fill_from_start: Indicates that if `None` values should be inserted at the start or end of the list. Examples: >>> split_num_words("db.table", ".", 3) [None, 'db', 'table'] >>> split_num_words("db.table", ".", 3, fill_from_start=False) ['db', 'table', None] >>> split_num_words("db.table", ".", 1) ['db', 'table'] Returns: The list of words returned by `split`, possibly augmented by a number of `None` values.
Here is the function:
def split_num_words(
value: str, sep: str, min_num_words: int, fill_from_start: bool = True
) -> t.List[t.Optional[str]]:
"""
Perform a split on a value and return N words as a result with `None` used for words that don't exist.
Args:
value: The value to be split.
sep: The value to use to split on.
min_num_words: The minimum number of words that are going to be in the result.
fill_from_start: Indicates that if `None` values should be inserted at the start or end of the list.
Examples:
>>> split_num_words("db.table", ".", 3)
[None, 'db', 'table']
>>> split_num_words("db.table", ".", 3, fill_from_start=False)
['db', 'table', None]
>>> split_num_words("db.table", ".", 1)
['db', 'table']
Returns:
The list of words returned by `split`, possibly augmented by a number of `None` values.
"""
words = value.split(sep)
if fill_from_start:
return [None] * (min_num_words - len(words)) + words
return words + [None] * (min_num_words - len(words)) | Perform a split on a value and return N words as a result with `None` used for words that don't exist. Args: value: The value to be split. sep: The value to use to split on. min_num_words: The minimum number of words that are going to be in the result. fill_from_start: Indicates that if `None` values should be inserted at the start or end of the list. Examples: >>> split_num_words("db.table", ".", 3) [None, 'db', 'table'] >>> split_num_words("db.table", ".", 3, fill_from_start=False) ['db', 'table', None] >>> split_num_words("db.table", ".", 1) ['db', 'table'] Returns: The list of words returned by `split`, possibly augmented by a number of `None` values. |
152,979 | import typing as t
from sqlglot import expressions as exp
def replace_id_value(node, replacement_mapping: t.Dict[exp.Identifier, exp.Identifier]):
if isinstance(node, exp.Identifier) and node in replacement_mapping:
node = node.replace(replacement_mapping[node].copy())
return node | null |
152,980 | from __future__ import annotations
import typing as t
from sqlglot import expressions as exp
from sqlglot.dataframe.sql import types
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import SchemaInput
SchemaInput = t.Union[str, t.List[str], StructType, t.Dict[str, t.Optional[str]]]
def get_column_mapping_from_schema_input(schema: SchemaInput) -> t.Dict[str, t.Optional[str]]:
if isinstance(schema, dict):
return schema
elif isinstance(schema, str):
col_name_type_strs = [x.strip() for x in schema.split(",")]
return {
name_type_str.split(":")[0].strip(): name_type_str.split(":")[1].strip()
for name_type_str in col_name_type_strs
}
elif isinstance(schema, types.StructType):
return {struct_field.name: struct_field.dataType.simpleString() for struct_field in schema}
return {x.strip(): None for x in schema} # type: ignore | null |
152,981 | from __future__ import annotations
import typing as t
from sqlglot import expressions as exp
from sqlglot.dataframe.sql.column import Column
from sqlglot.dataframe.sql.util import get_tables_from_expression_with_join
from sqlglot.helper import ensure_list
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql.session import SparkSession
NORMALIZE_INPUT = t.TypeVar("NORMALIZE_INPUT", bound=t.Union[str, exp.Expression, Column])
def replace_alias_name_with_cte_name(
spark: SparkSession, expression_context: exp.Select, id: exp.Identifier
):
def replace_branch_and_sequence_ids_with_cte_name(
spark: SparkSession, expression_context: exp.Select, id: exp.Identifier
):
def _ensure_expressions(values: t.List[NORMALIZE_INPUT]) -> t.List[exp.Expression]:
def ensure_list(value: t.Collection[T]) -> t.List[T]:
def ensure_list(value: T) -> t.List[T]:
def ensure_list(value):
class SparkSession:
def __init__(self):
def __new__(cls, *args, **kwargs) -> SparkSession:
def read(self) -> DataFrameReader:
def table(self, tableName: str) -> DataFrame:
def createDataFrame(
self,
data: t.Sequence[t.Union[t.Dict[str, ColumnLiterals], t.List[ColumnLiterals], t.Tuple]],
schema: t.Optional[SchemaInput] = None,
samplingRatio: t.Optional[float] = None,
verifySchema: bool = False,
) -> DataFrame:
def _optimize(
self, expression: exp.Expression, dialect: t.Optional[Dialect] = None
) -> exp.Expression:
def sql(self, sqlQuery: str) -> DataFrame:
def _auto_incrementing_name(self) -> str:
def _random_branch_id(self) -> str:
def _random_sequence_id(self):
def _random_id(self) -> str:
def _join_hint_names(self) -> t.Set[str]:
def _add_alias_to_mapping(self, name: str, sequence_id: str):
def __init__(self):
def __getattr__(self, item) -> SparkSession.Builder:
def __call__(self, *args, **kwargs):
def config(
self,
key: t.Optional[str] = None,
value: t.Optional[t.Any] = None,
*,
map: t.Optional[t.Dict[str, t.Any]] = None,
**kwargs: t.Any,
) -> SparkSession.Builder:
def getOrCreate(self) -> SparkSession:
def builder(cls) -> Builder:
def normalize(spark: SparkSession, expression_context: exp.Select, expr: t.List[NORMALIZE_INPUT]):
expr = ensure_list(expr)
expressions = _ensure_expressions(expr)
for expression in expressions:
identifiers = expression.find_all(exp.Identifier)
for identifier in identifiers:
identifier.transform(spark.dialect.normalize_identifier)
replace_alias_name_with_cte_name(spark, expression_context, identifier)
replace_branch_and_sequence_ids_with_cte_name(spark, expression_context, identifier) | null |
152,982 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def col(column_name: t.Union[ColumnOrName, t.Any]) -> Column:
return Column(column_name) | null |
152,983 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def greatest(*cols: ColumnOrName) -> Column:
if len(cols) > 1:
return Column.invoke_expression_over_column(
cols[0], expression.Greatest, expressions=cols[1:]
)
return Column.invoke_expression_over_column(cols[0], expression.Greatest) | null |
152,984 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def least(*cols: ColumnOrName) -> Column:
if len(cols) > 1:
return Column.invoke_expression_over_column(cols[0], expression.Least, expressions=cols[1:])
return Column.invoke_expression_over_column(cols[0], expression.Least) | null |
152,985 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
def count_distinct(col: ColumnOrName, *cols: ColumnOrName) -> Column:
columns = [Column.ensure_col(x) for x in [col] + list(cols)]
return Column(
expression.Count(this=expression.Distinct(expressions=[x.expression for x in columns]))
)
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def countDistinct(col: ColumnOrName, *cols: ColumnOrName) -> Column:
return count_distinct(col, *cols) | null |
152,986 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
def lit(value: t.Optional[t.Any] = None) -> Column:
if isinstance(value, str):
return Column(expression.Literal.string(str(value)))
return Column(value)
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
def when(condition: Column, value: t.Any) -> Column:
true_value = value if isinstance(value, Column) else lit(value)
return Column(
expression.Case(
ifs=[expression.If(this=condition.column_expression, true=true_value.column_expression)]
)
) | null |
152,987 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def asc(col: ColumnOrName) -> Column:
return Column.ensure_col(col).asc() | null |
152,988 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def desc(col: ColumnOrName):
return Column.ensure_col(col).desc() | null |
152,989 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class DataFrame:
def __init__(
self,
spark: SparkSession,
expression: exp.Select,
branch_id: t.Optional[str] = None,
sequence_id: t.Optional[str] = None,
last_op: Operation = Operation.INIT,
pending_hints: t.Optional[t.List[exp.Expression]] = None,
output_expression_container: t.Optional[OutputExpressionContainer] = None,
**kwargs,
):
self.spark = spark
self.expression = expression
self.branch_id = branch_id or self.spark._random_branch_id
self.sequence_id = sequence_id or self.spark._random_sequence_id
self.last_op = last_op
self.pending_hints = pending_hints or []
self.output_expression_container = output_expression_container or exp.Select()
def __getattr__(self, column_name: str) -> Column:
return self[column_name]
def __getitem__(self, column_name: str) -> Column:
column_name = f"{self.branch_id}.{column_name}"
return Column(column_name)
def __copy__(self):
return self.copy()
def sparkSession(self):
return self.spark
def write(self):
return DataFrameWriter(self)
def latest_cte_name(self) -> str:
if not self.expression.ctes:
from_exp = self.expression.args["from"]
if from_exp.alias_or_name:
return from_exp.alias_or_name
table_alias = from_exp.find(exp.TableAlias)
if not table_alias:
raise RuntimeError(
f"Could not find an alias name for this expression: {self.expression}"
)
return table_alias.alias_or_name
return self.expression.ctes[-1].alias
def pending_join_hints(self):
return [hint for hint in self.pending_hints if isinstance(hint, exp.JoinHint)]
def pending_partition_hints(self):
return [hint for hint in self.pending_hints if isinstance(hint, exp.Anonymous)]
def columns(self) -> t.List[str]:
return self.expression.named_selects
def na(self) -> DataFrameNaFunctions:
return DataFrameNaFunctions(self)
def _replace_cte_names_with_hashes(self, expression: exp.Select):
replacement_mapping = {}
for cte in expression.ctes:
old_name_id = cte.args["alias"].this
new_hashed_id = exp.to_identifier(
self._create_hash_from_expression(cte.this), quoted=old_name_id.args["quoted"]
)
replacement_mapping[old_name_id] = new_hashed_id
expression = expression.transform(replace_id_value, replacement_mapping).assert_is(
exp.Select
)
return expression
def _create_cte_from_expression(
self,
expression: exp.Expression,
branch_id: t.Optional[str] = None,
sequence_id: t.Optional[str] = None,
**kwargs,
) -> t.Tuple[exp.CTE, str]:
name = self._create_hash_from_expression(expression)
expression_to_cte = expression.copy()
expression_to_cte.set("with", None)
cte = exp.Select().with_(name, as_=expression_to_cte, **kwargs).ctes[0]
cte.set("branch_id", branch_id or self.branch_id)
cte.set("sequence_id", sequence_id or self.sequence_id)
return cte, name
def _ensure_list_of_columns(self, cols: t.Collection[ColumnOrLiteral]) -> t.List[Column]: ...
def _ensure_list_of_columns(self, cols: ColumnOrLiteral) -> t.List[Column]: ...
def _ensure_list_of_columns(self, cols):
return Column.ensure_cols(ensure_list(cols))
def _ensure_and_normalize_cols(self, cols, expression: t.Optional[exp.Select] = None):
cols = self._ensure_list_of_columns(cols)
normalize(self.spark, expression or self.expression, cols)
return cols
def _ensure_and_normalize_col(self, col):
col = Column.ensure_col(col)
normalize(self.spark, self.expression, col)
return col
def _convert_leaf_to_cte(self, sequence_id: t.Optional[str] = None) -> DataFrame:
df = self._resolve_pending_hints()
sequence_id = sequence_id or df.sequence_id
expression = df.expression.copy()
cte_expression, cte_name = df._create_cte_from_expression(
expression=expression, sequence_id=sequence_id
)
new_expression = df._add_ctes_to_expression(
exp.Select(), expression.ctes + [cte_expression]
)
sel_columns = df._get_outer_select_columns(cte_expression)
new_expression = new_expression.from_(cte_name).select(
*[x.alias_or_name for x in sel_columns]
)
return df.copy(expression=new_expression, sequence_id=sequence_id)
def _resolve_pending_hints(self) -> DataFrame:
df = self.copy()
if not self.pending_hints:
return df
expression = df.expression
hint_expression = expression.args.get("hint") or exp.Hint(expressions=[])
for hint in df.pending_partition_hints:
hint_expression.append("expressions", hint)
df.pending_hints.remove(hint)
join_aliases = {
join_table.alias_or_name
for join_table in get_tables_from_expression_with_join(expression)
}
if join_aliases:
for hint in df.pending_join_hints:
for sequence_id_expression in hint.expressions:
sequence_id_or_name = sequence_id_expression.alias_or_name
sequence_ids_to_match = [sequence_id_or_name]
if sequence_id_or_name in df.spark.name_to_sequence_id_mapping:
sequence_ids_to_match = df.spark.name_to_sequence_id_mapping[
sequence_id_or_name
]
matching_ctes = [
cte
for cte in reversed(expression.ctes)
if cte.args["sequence_id"] in sequence_ids_to_match
]
for matching_cte in matching_ctes:
if matching_cte.alias_or_name in join_aliases:
sequence_id_expression.set("this", matching_cte.args["alias"].this)
df.pending_hints.remove(hint)
break
hint_expression.append("expressions", hint)
if hint_expression.expressions:
expression.set("hint", hint_expression)
return df
def _hint(self, hint_name: str, args: t.List[Column]) -> DataFrame:
hint_name = hint_name.upper()
hint_expression = (
exp.JoinHint(
this=hint_name,
expressions=[exp.to_table(parameter.alias_or_name) for parameter in args],
)
if hint_name in JOIN_HINTS
else exp.Anonymous(
this=hint_name, expressions=[parameter.expression for parameter in args]
)
)
new_df = self.copy()
new_df.pending_hints.append(hint_expression)
return new_df
def _set_operation(self, klass: t.Callable, other: DataFrame, distinct: bool):
other_df = other._convert_leaf_to_cte()
base_expression = self.expression.copy()
base_expression = self._add_ctes_to_expression(base_expression, other_df.expression.ctes)
all_ctes = base_expression.ctes
other_df.expression.set("with", None)
base_expression.set("with", None)
operation = klass(this=base_expression, distinct=distinct, expression=other_df.expression)
operation.set("with", exp.With(expressions=all_ctes))
return self.copy(expression=operation)._convert_leaf_to_cte()
def _cache(self, storage_level: str):
df = self._convert_leaf_to_cte()
df.expression.ctes[-1].set("cache_storage_level", storage_level)
return df
def _add_ctes_to_expression(cls, expression: exp.Select, ctes: t.List[exp.CTE]) -> exp.Select:
expression = expression.copy()
with_expression = expression.args.get("with")
if with_expression:
existing_ctes = with_expression.expressions
existsing_cte_names = {x.alias_or_name for x in existing_ctes}
for cte in ctes:
if cte.alias_or_name not in existsing_cte_names:
existing_ctes.append(cte)
else:
existing_ctes = ctes
expression.set("with", exp.With(expressions=existing_ctes))
return expression
def _get_outer_select_columns(cls, item: t.Union[exp.Expression, DataFrame]) -> t.List[Column]:
expression = item.expression if isinstance(item, DataFrame) else item
return [Column(x) for x in (expression.find(exp.Select) or exp.Select()).expressions]
def _create_hash_from_expression(cls, expression: exp.Expression) -> str:
from sqlglot.dataframe.sql.session import SparkSession
value = expression.sql(dialect=SparkSession().dialect).encode("utf-8")
return f"t{zlib.crc32(value)}"[:6]
def _get_select_expressions(
self,
) -> t.List[t.Tuple[t.Union[t.Type[exp.Cache], OutputExpressionContainer], exp.Select]]:
select_expressions: t.List[
t.Tuple[t.Union[t.Type[exp.Cache], OutputExpressionContainer], exp.Select]
] = []
main_select_ctes: t.List[exp.CTE] = []
for cte in self.expression.ctes:
cache_storage_level = cte.args.get("cache_storage_level")
if cache_storage_level:
select_expression = cte.this.copy()
select_expression.set("with", exp.With(expressions=copy(main_select_ctes)))
select_expression.set("cte_alias_name", cte.alias_or_name)
select_expression.set("cache_storage_level", cache_storage_level)
select_expressions.append((exp.Cache, select_expression))
else:
main_select_ctes.append(cte)
main_select = self.expression.copy()
if main_select_ctes:
main_select.set("with", exp.With(expressions=main_select_ctes))
expression_select_pair = (type(self.output_expression_container), main_select)
select_expressions.append(expression_select_pair) # type: ignore
return select_expressions
def sql(self, dialect: DialectType = None, optimize: bool = True, **kwargs) -> t.List[str]:
from sqlglot.dataframe.sql.session import SparkSession
dialect = Dialect.get_or_raise(dialect or SparkSession().dialect)
df = self._resolve_pending_hints()
select_expressions = df._get_select_expressions()
output_expressions: t.List[t.Union[exp.Select, exp.Cache, exp.Drop]] = []
replacement_mapping: t.Dict[exp.Identifier, exp.Identifier] = {}
for expression_type, select_expression in select_expressions:
select_expression = select_expression.transform(
replace_id_value, replacement_mapping
).assert_is(exp.Select)
if optimize:
select_expression = t.cast(
exp.Select, self.spark._optimize(select_expression, dialect=dialect)
)
select_expression = df._replace_cte_names_with_hashes(select_expression)
expression: t.Union[exp.Select, exp.Cache, exp.Drop]
if expression_type == exp.Cache:
cache_table_name = df._create_hash_from_expression(select_expression)
cache_table = exp.to_table(cache_table_name)
original_alias_name = select_expression.args["cte_alias_name"]
replacement_mapping[exp.to_identifier(original_alias_name)] = exp.to_identifier( # type: ignore
cache_table_name
)
sqlglot.schema.add_table(
cache_table_name,
{
expression.alias_or_name: expression.type.sql(dialect=dialect)
for expression in select_expression.expressions
},
dialect=dialect,
)
cache_storage_level = select_expression.args["cache_storage_level"]
options = [
exp.Literal.string("storageLevel"),
exp.Literal.string(cache_storage_level),
]
expression = exp.Cache(
this=cache_table, expression=select_expression, lazy=True, options=options
)
# We will drop the "view" if it exists before running the cache table
output_expressions.append(exp.Drop(this=cache_table, exists=True, kind="VIEW"))
elif expression_type == exp.Create:
expression = df.output_expression_container.copy()
expression.set("expression", select_expression)
elif expression_type == exp.Insert:
expression = df.output_expression_container.copy()
select_without_ctes = select_expression.copy()
select_without_ctes.set("with", None)
expression.set("expression", select_without_ctes)
if select_expression.ctes:
expression.set("with", exp.With(expressions=select_expression.ctes))
elif expression_type == exp.Select:
expression = select_expression
else:
raise ValueError(f"Invalid expression type: {expression_type}")
output_expressions.append(expression)
return [expression.sql(dialect=dialect, **kwargs) for expression in output_expressions]
def copy(self, **kwargs) -> DataFrame:
return DataFrame(**object_to_dict(self, **kwargs))
def select(self, *cols, **kwargs) -> DataFrame:
cols = self._ensure_and_normalize_cols(cols)
kwargs["append"] = kwargs.get("append", False)
if self.expression.args.get("joins"):
ambiguous_cols = [
col
for col in cols
if isinstance(col.column_expression, exp.Column) and not col.column_expression.table
]
if ambiguous_cols:
join_table_identifiers = [
x.this for x in get_tables_from_expression_with_join(self.expression)
]
cte_names_in_join = [x.this for x in join_table_identifiers]
# If we have columns that resolve to multiple CTE expressions then we want to use each CTE left-to-right
# and therefore we allow multiple columns with the same name in the result. This matches the behavior
# of Spark.
resolved_column_position: t.Dict[Column, int] = {col: -1 for col in ambiguous_cols}
for ambiguous_col in ambiguous_cols:
ctes_with_column = [
cte
for cte in self.expression.ctes
if cte.alias_or_name in cte_names_in_join
and ambiguous_col.alias_or_name in cte.this.named_selects
]
# Check if there is a CTE with this column that we haven't used before. If so, use it. Otherwise,
# use the same CTE we used before
cte = seq_get(ctes_with_column, resolved_column_position[ambiguous_col] + 1)
if cte:
resolved_column_position[ambiguous_col] += 1
else:
cte = ctes_with_column[resolved_column_position[ambiguous_col]]
ambiguous_col.expression.set("table", cte.alias_or_name)
return self.copy(
expression=self.expression.select(*[x.expression for x in cols], **kwargs), **kwargs
)
def alias(self, name: str, **kwargs) -> DataFrame:
new_sequence_id = self.spark._random_sequence_id
df = self.copy()
for join_hint in df.pending_join_hints:
for expression in join_hint.expressions:
if expression.alias_or_name == self.sequence_id:
expression.set("this", Column.ensure_col(new_sequence_id).expression)
df.spark._add_alias_to_mapping(name, new_sequence_id)
return df._convert_leaf_to_cte(sequence_id=new_sequence_id)
def where(self, column: t.Union[Column, bool], **kwargs) -> DataFrame:
col = self._ensure_and_normalize_col(column)
return self.copy(expression=self.expression.where(col.expression))
filter = where
def groupBy(self, *cols, **kwargs) -> GroupedData:
columns = self._ensure_and_normalize_cols(cols)
return GroupedData(self, columns, self.last_op)
def agg(self, *exprs, **kwargs) -> DataFrame:
cols = self._ensure_and_normalize_cols(exprs)
return self.groupBy().agg(*cols)
def join(
self,
other_df: DataFrame,
on: t.Union[str, t.List[str], Column, t.List[Column]],
how: str = "inner",
**kwargs,
) -> DataFrame:
other_df = other_df._convert_leaf_to_cte()
join_columns = self._ensure_list_of_columns(on)
# We will determine actual "join on" expression later so we don't provide it at first
join_expression = self.expression.join(
other_df.latest_cte_name, join_type=how.replace("_", " ")
)
join_expression = self._add_ctes_to_expression(join_expression, other_df.expression.ctes)
self_columns = self._get_outer_select_columns(join_expression)
other_columns = self._get_outer_select_columns(other_df)
# Determines the join clause and select columns to be used passed on what type of columns were provided for
# the join. The columns returned changes based on how the on expression is provided.
if isinstance(join_columns[0].expression, exp.Column):
"""
Unique characteristics of join on column names only:
* The column names are put at the front of the select list
* The column names are deduplicated across the entire select list and only the column names (other dups are allowed)
"""
table_names = [
table.alias_or_name
for table in get_tables_from_expression_with_join(join_expression)
]
potential_ctes = [
cte
for cte in join_expression.ctes
if cte.alias_or_name in table_names
and cte.alias_or_name != other_df.latest_cte_name
]
# Determine the table to reference for the left side of the join by checking each of the left side
# tables and see if they have the column being referenced.
join_column_pairs = []
for join_column in join_columns:
num_matching_ctes = 0
for cte in potential_ctes:
if join_column.alias_or_name in cte.this.named_selects:
left_column = join_column.copy().set_table_name(cte.alias_or_name)
right_column = join_column.copy().set_table_name(other_df.latest_cte_name)
join_column_pairs.append((left_column, right_column))
num_matching_ctes += 1
if num_matching_ctes > 1:
raise ValueError(
f"Column {join_column.alias_or_name} is ambiguous. Please specify the table name."
)
elif num_matching_ctes == 0:
raise ValueError(
f"Column {join_column.alias_or_name} does not exist in any of the tables."
)
join_clause = functools.reduce(
lambda x, y: x & y,
[left_column == right_column for left_column, right_column in join_column_pairs],
)
join_column_names = [left_col.alias_or_name for left_col, _ in join_column_pairs]
# To match spark behavior only the join clause gets deduplicated and it gets put in the front of the column list
select_column_names = [
(
column.alias_or_name
if not isinstance(column.expression.this, exp.Star)
else column.sql()
)
for column in self_columns + other_columns
]
select_column_names = [
column_name
for column_name in select_column_names
if column_name not in join_column_names
]
select_column_names = join_column_names + select_column_names
else:
"""
Unique characteristics of join on expressions:
* There is no deduplication of the results.
* The left join dataframe columns go first and right come after. No sort preference is given to join columns
"""
join_columns = self._ensure_and_normalize_cols(join_columns, join_expression)
if len(join_columns) > 1:
join_columns = [functools.reduce(lambda x, y: x & y, join_columns)]
join_clause = join_columns[0]
select_column_names = [column.alias_or_name for column in self_columns + other_columns]
# Update the on expression with the actual join clause to replace the dummy one from before
join_expression.args["joins"][-1].set("on", join_clause.expression)
new_df = self.copy(expression=join_expression)
new_df.pending_join_hints.extend(self.pending_join_hints)
new_df.pending_hints.extend(other_df.pending_hints)
new_df = new_df.select.__wrapped__(new_df, *select_column_names)
return new_df
def orderBy(
self,
*cols: t.Union[str, Column],
ascending: t.Optional[t.Union[t.Any, t.List[t.Any]]] = None,
) -> DataFrame:
"""
This implementation lets any ordered columns take priority over whatever is provided in `ascending`. Spark
has irregular behavior and can result in runtime errors. Users shouldn't be mixing the two anyways so this
is unlikely to come up.
"""
columns = self._ensure_and_normalize_cols(cols)
pre_ordered_col_indexes = [
i for i, col in enumerate(columns) if isinstance(col.expression, exp.Ordered)
]
if ascending is None:
ascending = [True] * len(columns)
elif not isinstance(ascending, list):
ascending = [ascending] * len(columns)
ascending = [bool(x) for i, x in enumerate(ascending)]
assert len(columns) == len(
ascending
), "The length of items in ascending must equal the number of columns provided"
col_and_ascending = list(zip(columns, ascending))
order_by_columns = [
(
exp.Ordered(this=col.expression, desc=not asc)
if i not in pre_ordered_col_indexes
else columns[i].column_expression
)
for i, (col, asc) in enumerate(col_and_ascending)
]
return self.copy(expression=self.expression.order_by(*order_by_columns))
sort = orderBy
def union(self, other: DataFrame) -> DataFrame:
return self._set_operation(exp.Union, other, False)
unionAll = union
def unionByName(self, other: DataFrame, allowMissingColumns: bool = False):
l_columns = self.columns
r_columns = other.columns
if not allowMissingColumns:
l_expressions = l_columns
r_expressions = l_columns
else:
l_expressions = []
r_expressions = []
r_columns_unused = copy(r_columns)
for l_column in l_columns:
l_expressions.append(l_column)
if l_column in r_columns:
r_expressions.append(l_column)
r_columns_unused.remove(l_column)
else:
r_expressions.append(exp.alias_(exp.Null(), l_column, copy=False))
for r_column in r_columns_unused:
l_expressions.append(exp.alias_(exp.Null(), r_column, copy=False))
r_expressions.append(r_column)
r_df = (
other.copy()._convert_leaf_to_cte().select(*self._ensure_list_of_columns(r_expressions))
)
l_df = self.copy()
if allowMissingColumns:
l_df = l_df._convert_leaf_to_cte().select(*self._ensure_list_of_columns(l_expressions))
return l_df._set_operation(exp.Union, r_df, False)
def intersect(self, other: DataFrame) -> DataFrame:
return self._set_operation(exp.Intersect, other, True)
def intersectAll(self, other: DataFrame) -> DataFrame:
return self._set_operation(exp.Intersect, other, False)
def exceptAll(self, other: DataFrame) -> DataFrame:
return self._set_operation(exp.Except, other, False)
def distinct(self) -> DataFrame:
return self.copy(expression=self.expression.distinct())
def dropDuplicates(self, subset: t.Optional[t.List[str]] = None):
if not subset:
return self.distinct()
column_names = ensure_list(subset)
window = Window.partitionBy(*column_names).orderBy(*column_names)
return (
self.copy()
.withColumn("row_num", F.row_number().over(window))
.where(F.col("row_num") == F.lit(1))
.drop("row_num")
)
def dropna(
self,
how: str = "any",
thresh: t.Optional[int] = None,
subset: t.Optional[t.Union[str, t.Tuple[str, ...], t.List[str]]] = None,
) -> DataFrame:
minimum_non_null = thresh or 0 # will be determined later if thresh is null
new_df = self.copy()
all_columns = self._get_outer_select_columns(new_df.expression)
if subset:
null_check_columns = self._ensure_and_normalize_cols(subset)
else:
null_check_columns = all_columns
if thresh is None:
minimum_num_nulls = 1 if how == "any" else len(null_check_columns)
else:
minimum_num_nulls = len(null_check_columns) - minimum_non_null + 1
if minimum_num_nulls > len(null_check_columns):
raise RuntimeError(
f"The minimum num nulls for dropna must be less than or equal to the number of columns. "
f"Minimum num nulls: {minimum_num_nulls}, Num Columns: {len(null_check_columns)}"
)
if_null_checks = [
F.when(column.isNull(), F.lit(1)).otherwise(F.lit(0)) for column in null_check_columns
]
nulls_added_together = functools.reduce(lambda x, y: x + y, if_null_checks)
num_nulls = nulls_added_together.alias("num_nulls")
new_df = new_df.select(num_nulls, append=True)
filtered_df = new_df.where(F.col("num_nulls") < F.lit(minimum_num_nulls))
final_df = filtered_df.select(*all_columns)
return final_df
def fillna(
self,
value: t.Union[ColumnLiterals],
subset: t.Optional[t.Union[str, t.Tuple[str, ...], t.List[str]]] = None,
) -> DataFrame:
"""
Functionality Difference: If you provide a value to replace a null and that type conflicts
with the type of the column then PySpark will just ignore your replacement.
This will try to cast them to be the same in some cases. So they won't always match.
Best to not mix types so make sure replacement is the same type as the column
Possibility for improvement: Use `typeof` function to get the type of the column
and check if it matches the type of the value provided. If not then make it null.
"""
from sqlglot.dataframe.sql.functions import lit
values = None
columns = None
new_df = self.copy()
all_columns = self._get_outer_select_columns(new_df.expression)
all_column_mapping = {column.alias_or_name: column for column in all_columns}
if isinstance(value, dict):
values = list(value.values())
columns = self._ensure_and_normalize_cols(list(value))
if not columns:
columns = self._ensure_and_normalize_cols(subset) if subset else all_columns
if not values:
values = [value] * len(columns)
value_columns = [lit(value) for value in values]
null_replacement_mapping = {
column.alias_or_name: (
F.when(column.isNull(), value).otherwise(column).alias(column.alias_or_name)
)
for column, value in zip(columns, value_columns)
}
null_replacement_mapping = {**all_column_mapping, **null_replacement_mapping}
null_replacement_columns = [
null_replacement_mapping[column.alias_or_name] for column in all_columns
]
new_df = new_df.select(*null_replacement_columns)
return new_df
def replace(
self,
to_replace: t.Union[bool, int, float, str, t.List, t.Dict],
value: t.Optional[t.Union[bool, int, float, str, t.List]] = None,
subset: t.Optional[t.Collection[ColumnOrName] | ColumnOrName] = None,
) -> DataFrame:
from sqlglot.dataframe.sql.functions import lit
old_values = None
new_df = self.copy()
all_columns = self._get_outer_select_columns(new_df.expression)
all_column_mapping = {column.alias_or_name: column for column in all_columns}
columns = self._ensure_and_normalize_cols(subset) if subset else all_columns
if isinstance(to_replace, dict):
old_values = list(to_replace)
new_values = list(to_replace.values())
elif not old_values and isinstance(to_replace, list):
assert isinstance(value, list), "value must be a list since the replacements are a list"
assert len(to_replace) == len(
value
), "the replacements and values must be the same length"
old_values = to_replace
new_values = value
else:
old_values = [to_replace] * len(columns)
new_values = [value] * len(columns)
old_values = [lit(value) for value in old_values]
new_values = [lit(value) for value in new_values]
replacement_mapping = {}
for column in columns:
expression = Column(None)
for i, (old_value, new_value) in enumerate(zip(old_values, new_values)):
if i == 0:
expression = F.when(column == old_value, new_value)
else:
expression = expression.when(column == old_value, new_value) # type: ignore
replacement_mapping[column.alias_or_name] = expression.otherwise(column).alias(
column.expression.alias_or_name
)
replacement_mapping = {**all_column_mapping, **replacement_mapping}
replacement_columns = [replacement_mapping[column.alias_or_name] for column in all_columns]
new_df = new_df.select(*replacement_columns)
return new_df
def withColumn(self, colName: str, col: Column) -> DataFrame:
col = self._ensure_and_normalize_col(col)
existing_col_names = self.expression.named_selects
existing_col_index = (
existing_col_names.index(colName) if colName in existing_col_names else None
)
if existing_col_index:
expression = self.expression.copy()
expression.expressions[existing_col_index] = col.expression
return self.copy(expression=expression)
return self.copy().select(col.alias(colName), append=True)
def withColumnRenamed(self, existing: str, new: str):
expression = self.expression.copy()
existing_columns = [
expression
for expression in expression.expressions
if expression.alias_or_name == existing
]
if not existing_columns:
raise ValueError("Tried to rename a column that doesn't exist")
for existing_column in existing_columns:
if isinstance(existing_column, exp.Column):
existing_column.replace(exp.alias_(existing_column, new))
else:
existing_column.set("alias", exp.to_identifier(new))
return self.copy(expression=expression)
def drop(self, *cols: t.Union[str, Column]) -> DataFrame:
all_columns = self._get_outer_select_columns(self.expression)
drop_cols = self._ensure_and_normalize_cols(cols)
new_columns = [
col
for col in all_columns
if col.alias_or_name not in [drop_column.alias_or_name for drop_column in drop_cols]
]
return self.copy().select(*new_columns, append=False)
def limit(self, num: int) -> DataFrame:
return self.copy(expression=self.expression.limit(num))
def hint(self, name: str, *parameters: t.Optional[t.Union[str, int]]) -> DataFrame:
parameter_list = ensure_list(parameters)
parameter_columns = (
self._ensure_list_of_columns(parameter_list)
if parameters
else Column.ensure_cols([self.sequence_id])
)
return self._hint(name, parameter_columns)
def repartition(
self, numPartitions: t.Union[int, ColumnOrName], *cols: ColumnOrName
) -> DataFrame:
num_partition_cols = self._ensure_list_of_columns(numPartitions)
columns = self._ensure_and_normalize_cols(cols)
args = num_partition_cols + columns
return self._hint("repartition", args)
def coalesce(self, numPartitions: int) -> DataFrame:
num_partitions = Column.ensure_cols([numPartitions])
return self._hint("coalesce", num_partitions)
def cache(self) -> DataFrame:
return self._cache(storage_level="MEMORY_AND_DISK")
def persist(self, storageLevel: str = "MEMORY_AND_DISK_SER") -> DataFrame:
"""
Storage Level Options: https://spark.apache.org/docs/3.0.0-preview/sql-ref-syntax-aux-cache-cache-table.html
"""
return self._cache(storageLevel)
def broadcast(df: DataFrame) -> DataFrame:
return df.hint("broadcast") | null |
152,990 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def sqrt(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Sqrt) | null |
152,991 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def abs(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Abs) | null |
152,992 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def max(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Max) | null |
152,993 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def min(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Min) | null |
152,994 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def max_by(col: ColumnOrName, ord: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.ArgMax, expression=ord) | null |
152,995 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def min_by(col: ColumnOrName, ord: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.ArgMin, expression=ord) | null |
152,996 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def count(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Count) | null |
152,997 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def sum(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Sum) | null |
152,998 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def avg(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Avg) | null |
152,999 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def mean(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "MEAN") | null |
153,000 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
def sum_distinct(col: ColumnOrName) -> Column:
raise NotImplementedError("Sum distinct is not currently implemented")
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def sumDistinct(col: ColumnOrName) -> Column:
return sum_distinct(col) | null |
153,001 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def product(col: ColumnOrName) -> Column:
raise NotImplementedError("Product is not currently implemented") | null |
153,002 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def acos(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "ACOS") | null |
153,003 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def acosh(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "ACOSH") | null |
153,004 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def asin(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "ASIN") | null |
153,005 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def asinh(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "ASINH") | null |
153,006 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def atan(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "ATAN") | null |
153,007 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def atan2(col1: t.Union[ColumnOrName, float], col2: t.Union[ColumnOrName, float]) -> Column:
return Column.invoke_anonymous_function(col1, "ATAN2", col2) | null |
153,008 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def atanh(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "ATANH") | null |
153,009 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def cbrt(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Cbrt) | null |
153,010 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def ceil(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Ceil) | null |
153,011 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def cos(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "COS") | null |
153,012 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def cosh(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "COSH") | null |
153,013 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def cot(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "COT") | null |
153,014 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def csc(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "CSC") | null |
153,015 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def exp(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Exp) | null |
153,016 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def expm1(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "EXPM1") | null |
153,017 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def floor(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Floor) | null |
153,018 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
def lit(value: t.Optional[t.Any] = None) -> Column:
if isinstance(value, str):
return Column(expression.Literal.string(str(value)))
return Column(value)
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def log10(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(lit(10), expression.Log, expression=col) | null |
153,019 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def log1p(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "LOG1P") | null |
153,020 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
def lit(value: t.Optional[t.Any] = None) -> Column:
if isinstance(value, str):
return Column(expression.Literal.string(str(value)))
return Column(value)
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def log2(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(lit(2), expression.Log, expression=col) | null |
153,021 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def log(arg1: t.Union[ColumnOrName, float], arg2: t.Optional[ColumnOrName] = None) -> Column:
if arg2 is None:
return Column.invoke_expression_over_column(arg1, expression.Ln)
return Column.invoke_expression_over_column(arg1, expression.Log, expression=arg2) | null |
153,022 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def rint(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "RINT") | null |
153,023 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def sec(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "SEC") | null |
153,024 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def signum(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Sign) | null |
153,025 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def sin(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "SIN") | null |
153,026 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def sinh(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "SINH") | null |
153,027 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def tan(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "TAN") | null |
153,028 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def tanh(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "TANH") | null |
153,029 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
def degrees(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "DEGREES")
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def toDegrees(col: ColumnOrName) -> Column:
return degrees(col) | null |
153,030 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
def radians(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "RADIANS")
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def toRadians(col: ColumnOrName) -> Column:
return radians(col) | null |
153,031 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
def bitwise_not(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.BitwiseNot)
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def bitwiseNOT(col: ColumnOrName) -> Column:
return bitwise_not(col) | null |
153,032 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def asc_nulls_first(col: ColumnOrName) -> Column:
return Column.ensure_col(col).asc_nulls_first() | null |
153,033 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def asc_nulls_last(col: ColumnOrName) -> Column:
return Column.ensure_col(col).asc_nulls_last() | null |
153,034 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def desc_nulls_first(col: ColumnOrName) -> Column:
return Column.ensure_col(col).desc_nulls_first() | null |
153,035 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def desc_nulls_last(col: ColumnOrName) -> Column:
return Column.ensure_col(col).desc_nulls_last() | null |
153,036 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def stddev(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Stddev) | null |
153,037 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def stddev_samp(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.StddevSamp) | null |
153,038 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def stddev_pop(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.StddevPop) | null |
153,039 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def variance(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Variance) | null |
153,040 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def var_samp(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Variance) | null |
153,041 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def var_pop(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.VariancePop) | null |
153,042 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def skewness(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "SKEWNESS") | null |
153,043 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def kurtosis(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "KURTOSIS") | null |
153,044 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def collect_list(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.ArrayAgg) | null |
153,045 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def collect_set(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.ArrayUniqueAgg) | null |
153,046 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def hypot(col1: t.Union[ColumnOrName, float], col2: t.Union[ColumnOrName, float]) -> Column:
return Column.invoke_anonymous_function(col1, "HYPOT", col2) | null |
153,047 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def pow(col1: t.Union[ColumnOrName, float], col2: t.Union[ColumnOrName, float]) -> Column:
return Column.invoke_expression_over_column(col1, expression.Pow, expression=col2) | null |
153,048 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
def row_number() -> Column:
return Column(expression.Anonymous(this="ROW_NUMBER")) | null |
153,049 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
def dense_rank() -> Column:
return Column(expression.Anonymous(this="DENSE_RANK")) | null |
153,050 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
def rank() -> Column:
return Column(expression.Anonymous(this="RANK")) | null |
153,051 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
def cume_dist() -> Column:
return Column(expression.Anonymous(this="CUME_DIST")) | null |
153,052 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
def percent_rank() -> Column:
return Column(expression.Anonymous(this="PERCENT_RANK")) | null |
153,053 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
def approx_count_distinct(col: ColumnOrName, rsd: t.Optional[float] = None) -> Column:
if rsd is None:
return Column.invoke_expression_over_column(col, expression.ApproxDistinct)
return Column.invoke_expression_over_column(col, expression.ApproxDistinct, accuracy=rsd)
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def approxCountDistinct(col: ColumnOrName, rsd: t.Optional[float] = None) -> Column:
return approx_count_distinct(col, rsd) | null |
153,054 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def coalesce(*cols: ColumnOrName) -> Column:
if len(cols) > 1:
return Column.invoke_expression_over_column(
cols[0], expression.Coalesce, expressions=cols[1:]
)
return Column.invoke_expression_over_column(cols[0], expression.Coalesce) | null |
153,055 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def corr(col1: ColumnOrName, col2: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col1, "CORR", col2) | null |
153,056 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def covar_pop(col1: ColumnOrName, col2: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col1, "COVAR_POP", col2) | null |
153,057 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def covar_samp(col1: ColumnOrName, col2: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col1, "COVAR_SAMP", col2) | null |
153,058 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def first(col: ColumnOrName, ignorenulls: t.Optional[bool] = None) -> Column:
this = Column.invoke_expression_over_column(col, expression.First)
if ignorenulls:
return Column.invoke_expression_over_column(this, expression.IgnoreNulls)
return this | null |
153,059 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def grouping_id(*cols: ColumnOrName) -> Column:
if not cols:
return Column.invoke_anonymous_function(None, "GROUPING_ID")
if len(cols) == 1:
return Column.invoke_anonymous_function(cols[0], "GROUPING_ID")
return Column.invoke_anonymous_function(cols[0], "GROUPING_ID", *cols[1:]) | null |
153,060 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
def input_file_name() -> Column:
return Column.invoke_anonymous_function(None, "INPUT_FILE_NAME") | null |
153,061 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def isnan(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.IsNan) | null |
153,062 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def isnull(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "ISNULL") | null |
153,063 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def last(col: ColumnOrName, ignorenulls: t.Optional[bool] = None) -> Column:
this = Column.invoke_expression_over_column(col, expression.Last)
if ignorenulls:
return Column.invoke_expression_over_column(this, expression.IgnoreNulls)
return this | null |
153,064 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
def monotonically_increasing_id() -> Column:
return Column.invoke_anonymous_function(None, "MONOTONICALLY_INCREASING_ID") | null |
153,065 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def nanvl(col1: ColumnOrName, col2: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col1, "NANVL", col2) | null |
153,066 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
def lit(value: t.Optional[t.Any] = None) -> Column:
if isinstance(value, str):
return Column(expression.Literal.string(str(value)))
return Column(value)
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
ColumnOrLiteral = t.Union[
Column, str, float, int, bool, t.List, t.Tuple, datetime.date, datetime.datetime
]
def percentile_approx(
col: ColumnOrName,
percentage: t.Union[ColumnOrLiteral, t.List[float], t.Tuple[float]],
accuracy: t.Optional[t.Union[ColumnOrLiteral, int]] = None,
) -> Column:
if accuracy:
return Column.invoke_expression_over_column(
col, expression.ApproxQuantile, quantile=lit(percentage), accuracy=accuracy
)
return Column.invoke_expression_over_column(
col, expression.ApproxQuantile, quantile=lit(percentage)
) | null |
153,067 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrLiteral = t.Union[
Column, str, float, int, bool, t.List, t.Tuple, datetime.date, datetime.datetime
]
def rand(seed: t.Optional[ColumnOrLiteral] = None) -> Column:
return Column.invoke_expression_over_column(seed, expression.Rand) | null |
153,068 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrLiteral = t.Union[
Column, str, float, int, bool, t.List, t.Tuple, datetime.date, datetime.datetime
]
def randn(seed: t.Optional[ColumnOrLiteral] = None) -> Column:
return Column.invoke_expression_over_column(seed, expression.Randn) | null |
153,069 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def round(col: ColumnOrName, scale: t.Optional[int] = None) -> Column:
if scale is not None:
return Column.invoke_expression_over_column(col, expression.Round, decimals=scale)
return Column.invoke_expression_over_column(col, expression.Round) | null |
153,070 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
if t.TYPE_CHECKING:
from sqlglot.dataframe.sql._typing import ColumnOrLiteral, ColumnOrName
from sqlglot.dataframe.sql.dataframe import DataFrame
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
def __repr__(self):
def __hash__(self):
def __eq__(self, other: ColumnOrLiteral) -> Column:
def __ne__(self, other: ColumnOrLiteral) -> Column:
def __gt__(self, other: ColumnOrLiteral) -> Column:
def __ge__(self, other: ColumnOrLiteral) -> Column:
def __lt__(self, other: ColumnOrLiteral) -> Column:
def __le__(self, other: ColumnOrLiteral) -> Column:
def __and__(self, other: ColumnOrLiteral) -> Column:
def __or__(self, other: ColumnOrLiteral) -> Column:
def __mod__(self, other: ColumnOrLiteral) -> Column:
def __add__(self, other: ColumnOrLiteral) -> Column:
def __sub__(self, other: ColumnOrLiteral) -> Column:
def __mul__(self, other: ColumnOrLiteral) -> Column:
def __truediv__(self, other: ColumnOrLiteral) -> Column:
def __div__(self, other: ColumnOrLiteral) -> Column:
def __neg__(self) -> Column:
def __radd__(self, other: ColumnOrLiteral) -> Column:
def __rsub__(self, other: ColumnOrLiteral) -> Column:
def __rmul__(self, other: ColumnOrLiteral) -> Column:
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
def __rmod__(self, other: ColumnOrLiteral) -> Column:
def __pow__(self, power: ColumnOrLiteral, modulo=None):
def __rpow__(self, power: ColumnOrLiteral):
def __invert__(self):
def __rand__(self, other: ColumnOrLiteral) -> Column:
def __ror__(self, other: ColumnOrLiteral) -> Column:
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
def _lit(cls, value: ColumnOrLiteral) -> Column:
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
def is_alias(self):
def is_column(self):
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
def alias_or_name(self) -> str:
def ensure_literal(cls, value) -> Column:
def copy(self) -> Column:
def set_table_name(self, table_name: str, copy=False) -> Column:
def sql(self, **kwargs) -> str:
def alias(self, name: str) -> Column:
def asc(self) -> Column:
def desc(self) -> Column:
def asc_nulls_last(self) -> Column:
def desc_nulls_first(self) -> Column:
def when(self, condition: Column, value: t.Any) -> Column:
def otherwise(self, value: t.Any) -> Column:
def isNull(self) -> Column:
def isNotNull(self) -> Column:
def cast(self, dataType: t.Union[str, DataType]) -> Column:
def startswith(self, value: t.Union[str, Column]) -> Column:
def endswith(self, value: t.Union[str, Column]) -> Column:
def rlike(self, regexp: str) -> Column:
def like(self, other: str):
def ilike(self, other: str):
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
def over(self, window: WindowSpec) -> Column:
ColumnOrName = t.Union[Column, str]
def bround(col: ColumnOrName, scale: t.Optional[int] = None) -> Column:
if scale is not None:
return Column.invoke_anonymous_function(col, "BROUND", scale)
return Column.invoke_anonymous_function(col, "BROUND") | null |
153,071 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
def shiftleft(col: ColumnOrName, numBits: int) -> Column:
return Column.invoke_expression_over_column(
col, expression.BitwiseLeftShift, expression=numBits
)
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def shiftLeft(col: ColumnOrName, numBits: int) -> Column:
return shiftleft(col, numBits) | null |
153,072 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
def shiftright(col: ColumnOrName, numBits: int) -> Column:
return Column.invoke_expression_over_column(
col, expression.BitwiseRightShift, expression=numBits
)
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def shiftRight(col: ColumnOrName, numBits: int) -> Column:
return shiftright(col, numBits) | null |
153,073 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
def shiftrightunsigned(col: ColumnOrName, numBits: int) -> Column:
return Column.invoke_anonymous_function(col, "SHIFTRIGHTUNSIGNED", numBits)
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
ColumnOrName = t.Union[Column, str]
def shiftRightUnsigned(col: ColumnOrName, numBits: int) -> Column:
return shiftrightunsigned(col, numBits) | null |
153,074 | from __future__ import annotations
import typing as t
from sqlglot import exp as expression
from sqlglot.dataframe.sql.column import Column
from sqlglot.helper import ensure_list, flatten as _flatten
class Column:
def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]):
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(expression, Column):
expression = expression.expression # type: ignore
elif expression is None or not isinstance(expression, (str, exp.Expression)):
expression = self._lit(expression).expression # type: ignore
elif not isinstance(expression, exp.Column):
expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform(
SparkSession().dialect.normalize_identifier, copy=False
)
if expression is None:
raise ValueError(f"Could not parse {expression}")
self.expression: exp.Expression = expression # type: ignore
def __repr__(self):
return repr(self.expression)
def __hash__(self):
return hash(self.expression)
def __eq__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.EQ, other)
def __ne__(self, other: ColumnOrLiteral) -> Column: # type: ignore
return self.binary_op(exp.NEQ, other)
def __gt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GT, other)
def __ge__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.GTE, other)
def __lt__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LT, other)
def __le__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.LTE, other)
def __and__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.And, other)
def __or__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Or, other)
def __mod__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mod, other)
def __add__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Add, other)
def __sub__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Sub, other)
def __mul__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Mul, other)
def __truediv__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __div__(self, other: ColumnOrLiteral) -> Column:
return self.binary_op(exp.Div, other)
def __neg__(self) -> Column:
return self.unary_op(exp.Neg)
def __radd__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Add, other)
def __rsub__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Sub, other)
def __rmul__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mul, other)
def __rdiv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rtruediv__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Div, other)
def __rmod__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Mod, other)
def __pow__(self, power: ColumnOrLiteral, modulo=None):
return Column(exp.Pow(this=self.expression, expression=Column(power).expression))
def __rpow__(self, power: ColumnOrLiteral):
return Column(exp.Pow(this=Column(power).expression, expression=self.expression))
def __invert__(self):
return self.unary_op(exp.Not)
def __rand__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.And, other)
def __ror__(self, other: ColumnOrLiteral) -> Column:
return self.inverse_binary_op(exp.Or, other)
def ensure_col(cls, value: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]) -> Column:
return cls(value)
def ensure_cols(cls, args: t.List[t.Union[ColumnOrLiteral, exp.Expression]]) -> t.List[Column]:
return [cls.ensure_col(x) if not isinstance(x, Column) else x for x in args]
def _lit(cls, value: ColumnOrLiteral) -> Column:
if isinstance(value, dict):
columns = [cls._lit(v).alias(k).expression for k, v in value.items()]
return cls(exp.Struct(expressions=columns))
return cls(exp.convert(value))
def invoke_anonymous_function(
cls, column: t.Optional[ColumnOrLiteral], func_name: str, *args: t.Optional[ColumnOrLiteral]
) -> Column:
columns = [] if column is None else [cls.ensure_col(column)]
column_args = [cls.ensure_col(arg) for arg in args]
expressions = [x.expression for x in columns + column_args]
new_expression = exp.Anonymous(this=func_name.upper(), expressions=expressions)
return Column(new_expression)
def invoke_expression_over_column(
cls, column: t.Optional[ColumnOrLiteral], callable_expression: t.Callable, **kwargs
) -> Column:
ensured_column = None if column is None else cls.ensure_col(column)
ensure_expression_values = {
k: (
[Column.ensure_col(x).expression for x in v]
if is_iterable(v)
else Column.ensure_col(v).expression
)
for k, v in kwargs.items()
if v is not None
}
new_expression = (
callable_expression(**ensure_expression_values)
if ensured_column is None
else callable_expression(
this=ensured_column.column_expression, **ensure_expression_values
)
)
return Column(new_expression)
def binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=self.column_expression, expression=Column(other).column_expression, **kwargs)
)
def inverse_binary_op(self, klass: t.Callable, other: ColumnOrLiteral, **kwargs) -> Column:
return Column(
klass(this=Column(other).column_expression, expression=self.column_expression, **kwargs)
)
def unary_op(self, klass: t.Callable, **kwargs) -> Column:
return Column(klass(this=self.column_expression, **kwargs))
def is_alias(self):
return isinstance(self.expression, exp.Alias)
def is_column(self):
return isinstance(self.expression, exp.Column)
def column_expression(self) -> t.Union[exp.Column, exp.Literal]:
return self.expression.unalias()
def alias_or_name(self) -> str:
return self.expression.alias_or_name
def ensure_literal(cls, value) -> Column:
from sqlglot.dataframe.sql.functions import lit
if isinstance(value, cls):
value = value.expression
if not isinstance(value, exp.Literal):
return lit(value)
return Column(value)
def copy(self) -> Column:
return Column(self.expression.copy())
def set_table_name(self, table_name: str, copy=False) -> Column:
expression = self.expression.copy() if copy else self.expression
expression.set("table", exp.to_identifier(table_name))
return Column(expression)
def sql(self, **kwargs) -> str:
from sqlglot.dataframe.sql.session import SparkSession
return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs})
def alias(self, name: str) -> Column:
from sqlglot.dataframe.sql.session import SparkSession
dialect = SparkSession().dialect
alias: exp.Expression = sqlglot.maybe_parse(name, dialect=dialect)
new_expression = exp.alias_(
self.column_expression,
alias.this if isinstance(alias, exp.Column) else name,
dialect=dialect,
)
return Column(new_expression)
def asc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=True)
return Column(new_expression)
def desc(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=False)
return Column(new_expression)
asc_nulls_first = asc
def asc_nulls_last(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=False, nulls_first=False)
return Column(new_expression)
def desc_nulls_first(self) -> Column:
new_expression = exp.Ordered(this=self.column_expression, desc=True, nulls_first=True)
return Column(new_expression)
desc_nulls_last = desc
def when(self, condition: Column, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import when
column_with_if = when(condition, value)
if not isinstance(self.expression, exp.Case):
return column_with_if
new_column = self.copy()
new_column.expression.args["ifs"].extend(column_with_if.expression.args["ifs"])
return new_column
def otherwise(self, value: t.Any) -> Column:
from sqlglot.dataframe.sql.functions import lit
true_value = value if isinstance(value, Column) else lit(value)
new_column = self.copy()
new_column.expression.set("default", true_value.column_expression)
return new_column
def isNull(self) -> Column:
new_expression = exp.Is(this=self.column_expression, expression=exp.Null())
return Column(new_expression)
def isNotNull(self) -> Column:
new_expression = exp.Not(this=exp.Is(this=self.column_expression, expression=exp.Null()))
return Column(new_expression)
def cast(self, dataType: t.Union[str, DataType]) -> Column:
"""
Functionality Difference: PySpark cast accepts a datatype instance of the datatype class
Sqlglot doesn't currently replicate this class so it only accepts a string
"""
from sqlglot.dataframe.sql.session import SparkSession
if isinstance(dataType, DataType):
dataType = dataType.simpleString()
return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect))
def startswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "STARTSWITH", value)
def endswith(self, value: t.Union[str, Column]) -> Column:
value = self._lit(value) if not isinstance(value, Column) else value
return self.invoke_anonymous_function(self, "ENDSWITH", value)
def rlike(self, regexp: str) -> Column:
return self.invoke_expression_over_column(
column=self, callable_expression=exp.RegexpLike, expression=self._lit(regexp).expression
)
def like(self, other: str):
return self.invoke_expression_over_column(
self, exp.Like, expression=self._lit(other).expression
)
def ilike(self, other: str):
return self.invoke_expression_over_column(
self, exp.ILike, expression=self._lit(other).expression
)
def substr(self, startPos: t.Union[int, Column], length: t.Union[int, Column]) -> Column:
startPos = self._lit(startPos) if not isinstance(startPos, Column) else startPos
length = self._lit(length) if not isinstance(length, Column) else length
return Column.invoke_expression_over_column(
self, exp.Substring, start=startPos.expression, length=length.expression
)
def isin(self, *cols: t.Union[ColumnOrLiteral, t.Iterable[ColumnOrLiteral]]):
columns = flatten(cols) if isinstance(cols[0], (list, set, tuple)) else cols # type: ignore
expressions = [self._lit(x).expression for x in columns]
return Column.invoke_expression_over_column(self, exp.In, expressions=expressions) # type: ignore
def between(
self,
lowerBound: t.Union[ColumnOrLiteral],
upperBound: t.Union[ColumnOrLiteral],
) -> Column:
lower_bound_exp = (
self._lit(lowerBound) if not isinstance(lowerBound, Column) else lowerBound
)
upper_bound_exp = (
self._lit(upperBound) if not isinstance(upperBound, Column) else upperBound
)
return Column(
exp.Between(
this=self.column_expression,
low=lower_bound_exp.expression,
high=upper_bound_exp.expression,
)
)
def over(self, window: WindowSpec) -> Column:
window_expression = window.expression.copy()
window_expression.set("this", self.column_expression)
return Column(window_expression)
def expr(str: str) -> Column:
return Column(str) | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.