id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
153,075 | 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)
def ensure_list(value: t.Collection[T]) -> t.List[T]: ...
def ensure_list(value: T) -> t.List[T]: ...
def ensure_list(value):
"""
Ensures that a value is a list, otherwise casts or wraps it into one.
Args:
value: The value of interest.
Returns:
The value cast as a list if it's a list or a tuple, or else the value wrapped in a list.
"""
if value is None:
return []
if isinstance(value, (list, tuple)):
return list(value)
return [value]
ColumnOrName = t.Union[Column, str]
def struct(col: t.Union[ColumnOrName, t.Iterable[ColumnOrName]], *cols: ColumnOrName) -> Column:
columns = ensure_list(col) + list(cols)
return Column.invoke_expression_over_column(None, expression.Struct, expressions=columns) | null |
153,076 | 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 conv(col: ColumnOrName, fromBase: int, toBase: int) -> Column:
return Column.invoke_anonymous_function(col, "CONV", fromBase, toBase) | null |
153,077 | 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 factorial(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "FACTORIAL") | null |
153,078 | 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]
ColumnOrLiteral = t.Union[
Column, str, float, int, bool, t.List, t.Tuple, datetime.date, datetime.datetime
]
def lag(
col: ColumnOrName, offset: t.Optional[int] = 1, default: t.Optional[ColumnOrLiteral] = None
) -> Column:
return Column.invoke_expression_over_column(
col, expression.Lag, offset=None if offset == 1 else offset, default=default
) | null |
153,079 | 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 lead(
col: ColumnOrName, offset: t.Optional[int] = 1, default: t.Optional[t.Any] = None
) -> Column:
return Column.invoke_expression_over_column(
col, expression.Lead, offset=None if offset == 1 else offset, default=default
) | null |
153,080 | 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 nth_value(
col: ColumnOrName, offset: t.Optional[int] = 1, ignoreNulls: t.Optional[bool] = None
) -> Column:
this = Column.invoke_expression_over_column(
col, expression.NthValue, offset=None if offset == 1 else offset
)
if ignoreNulls is not None:
return Column.invoke_expression_over_column(this, expression.IgnoreNulls)
return this | null |
153,081 | 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 ntile(n: int) -> Column:
return Column.invoke_anonymous_function(None, "NTILE", n) | null |
153,082 | 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:
def current_date() -> Column:
return Column.invoke_expression_over_column(None, expression.CurrentDate) | null |
153,083 | 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 current_timestamp() -> Column:
return Column.invoke_expression_over_column(None, expression.CurrentTimestamp) | null |
153,084 | 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 date_format(col: ColumnOrName, format: str) -> Column:
return Column.invoke_expression_over_column(col, expression.TimeToStr, format=lit(format)) | null |
153,085 | 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 year(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Year) | null |
153,086 | 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 quarter(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "QUARTER") | null |
153,087 | 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 month(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Month) | null |
153,088 | 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 dayofweek(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.DayOfWeek) | null |
153,089 | 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 dayofmonth(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.DayOfMonth) | null |
153,090 | 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 dayofyear(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.DayOfYear) | null |
153,091 | 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 hour(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "HOUR") | null |
153,092 | 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 minute(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "MINUTE") | null |
153,093 | 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 second(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "SECOND") | null |
153,094 | 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 weekofyear(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.WeekOfYear) | null |
153,095 | 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 make_date(year: ColumnOrName, month: ColumnOrName, day: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(year, "MAKE_DATE", month, day) | null |
153,096 | 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 date_add(col: ColumnOrName, days: t.Union[ColumnOrName, int]) -> Column:
return Column.invoke_expression_over_column(
col, expression.DateAdd, expression=days, unit=expression.Var(this="DAY")
) | null |
153,097 | 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 date_sub(col: ColumnOrName, days: t.Union[ColumnOrName, int]) -> Column:
return Column.invoke_expression_over_column(
col, expression.DateSub, expression=days, unit=expression.Var(this="DAY")
) | null |
153,098 | 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 date_diff(end: ColumnOrName, start: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(end, expression.DateDiff, expression=start) | null |
153,099 | 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 add_months(start: ColumnOrName, months: t.Union[ColumnOrName, int]) -> Column:
return Column.invoke_expression_over_column(start, expression.AddMonths, expression=months) | null |
153,100 | 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 months_between(
date1: ColumnOrName, date2: ColumnOrName, roundOff: t.Optional[bool] = None
) -> Column:
if roundOff is None:
return Column.invoke_expression_over_column(
date1, expression.MonthsBetween, expression=date2
)
return Column.invoke_expression_over_column(
date1, expression.MonthsBetween, expression=date2, roundoff=roundOff
) | null |
153,101 | 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]
def to_date(col: ColumnOrName, format: t.Optional[str] = None) -> Column:
if format is not None:
return Column.invoke_expression_over_column(
col, expression.TsOrDsToDate, format=lit(format)
)
return Column.invoke_expression_over_column(col, expression.TsOrDsToDate) | null |
153,102 | 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:
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 to_timestamp(col: ColumnOrName, format: t.Optional[str] = None) -> Column:
if format is not None:
return Column.invoke_expression_over_column(col, expression.StrToTime, format=lit(format))
return Column.ensure_col(col).cast("timestamp") | null |
153,103 | 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 trunc(col: ColumnOrName, format: str) -> Column:
return Column.invoke_expression_over_column(col, expression.DateTrunc, unit=lit(format)) | null |
153,104 | 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 date_trunc(format: str, timestamp: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(
timestamp, expression.TimestampTrunc, unit=lit(format)
) | null |
153,105 | 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 next_day(col: ColumnOrName, dayOfWeek: str) -> Column:
return Column.invoke_anonymous_function(col, "NEXT_DAY", lit(dayOfWeek)) | null |
153,106 | 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 last_day(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.LastDay) | null |
153,107 | 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]
def from_unixtime(col: ColumnOrName, format: t.Optional[str] = None) -> Column:
if format is not None:
return Column.invoke_expression_over_column(col, expression.UnixToStr, format=lit(format))
return Column.invoke_expression_over_column(col, expression.UnixToStr) | null |
153,108 | 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]
def unix_timestamp(
timestamp: t.Optional[ColumnOrName] = None, format: t.Optional[str] = None
) -> Column:
if format is not None:
return Column.invoke_expression_over_column(
timestamp, expression.StrToUnix, format=lit(format)
)
return Column.invoke_expression_over_column(timestamp, expression.StrToUnix) | null |
153,109 | 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 from_utc_timestamp(timestamp: ColumnOrName, tz: ColumnOrName) -> Column:
tz_column = tz if isinstance(tz, Column) else lit(tz)
return Column.invoke_expression_over_column(timestamp, expression.AtTimeZone, zone=tz_column) | null |
153,110 | 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:
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 to_utc_timestamp(timestamp: ColumnOrName, tz: ColumnOrName) -> Column:
tz_column = tz if isinstance(tz, Column) else lit(tz)
return Column.invoke_expression_over_column(timestamp, expression.FromTimeZone, zone=tz_column) | null |
153,111 | 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 timestamp_seconds(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "TIMESTAMP_SECONDS") | null |
153,112 | 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]
def window(
timeColumn: ColumnOrName,
windowDuration: str,
slideDuration: t.Optional[str] = None,
startTime: t.Optional[str] = None,
) -> Column:
if slideDuration is not None and startTime is not None:
return Column.invoke_anonymous_function(
timeColumn, "WINDOW", lit(windowDuration), lit(slideDuration), lit(startTime)
)
if slideDuration is not None:
return Column.invoke_anonymous_function(
timeColumn, "WINDOW", lit(windowDuration), lit(slideDuration)
)
if startTime is not None:
return Column.invoke_anonymous_function(
timeColumn, "WINDOW", lit(windowDuration), lit(windowDuration), lit(startTime)
)
return Column.invoke_anonymous_function(timeColumn, "WINDOW", lit(windowDuration)) | null |
153,113 | 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 session_window(timeColumn: ColumnOrName, gapDuration: ColumnOrName) -> Column:
gap_duration_column = gapDuration if isinstance(gapDuration, Column) else lit(gapDuration)
return Column.invoke_anonymous_function(timeColumn, "SESSION_WINDOW", gap_duration_column) | null |
153,114 | 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 crc32(col: ColumnOrName) -> Column:
column = col if isinstance(col, Column) else lit(col)
return Column.invoke_anonymous_function(column, "CRC32") | null |
153,115 | 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 md5(col: ColumnOrName) -> Column:
column = col if isinstance(col, Column) else lit(col)
return Column.invoke_expression_over_column(column, expression.MD5) | null |
153,116 | 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:
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 sha1(col: ColumnOrName) -> Column:
column = col if isinstance(col, Column) else lit(col)
return Column.invoke_expression_over_column(column, expression.SHA) | null |
153,117 | 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)
def length(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Length)
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 sha2(col: ColumnOrName, numBits: int) -> Column:
column = col if isinstance(col, Column) else lit(col)
return Column.invoke_expression_over_column(column, expression.SHA2, length=lit(numBits)) | null |
153,118 | 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 hash(*cols: ColumnOrName) -> Column:
args = cols[1:] if len(cols) > 1 else []
return Column.invoke_anonymous_function(cols[0], "HASH", *args) | null |
153,119 | 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 xxhash64(*cols: ColumnOrName) -> Column:
args = cols[1:] if len(cols) > 1 else []
return Column.invoke_anonymous_function(cols[0], "XXHASH64", *args) | null |
153,120 | 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]
def assert_true(col: ColumnOrName, errorMsg: t.Optional[ColumnOrName] = None) -> Column:
if errorMsg is not None:
error_msg_col = errorMsg if isinstance(errorMsg, Column) else lit(errorMsg)
return Column.invoke_anonymous_function(col, "ASSERT_TRUE", error_msg_col)
return Column.invoke_anonymous_function(col, "ASSERT_TRUE") | null |
153,121 | 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 raise_error(errorMsg: ColumnOrName) -> Column:
error_msg_col = errorMsg if isinstance(errorMsg, Column) else lit(errorMsg)
return Column.invoke_anonymous_function(error_msg_col, "RAISE_ERROR") | null |
153,122 | 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 upper(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Upper) | null |
153,123 | 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 lower(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Lower) | null |
153,124 | 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)
ColumnOrLiteral = t.Union[
Column, str, float, int, bool, t.List, t.Tuple, datetime.date, datetime.datetime
]
def ascii(col: ColumnOrLiteral) -> Column:
return Column.invoke_anonymous_function(col, "ASCII") | null |
153,125 | 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)
ColumnOrLiteral = t.Union[
Column, str, float, int, bool, t.List, t.Tuple, datetime.date, datetime.datetime
]
def base64(col: ColumnOrLiteral) -> Column:
return Column.invoke_expression_over_column(col, expression.ToBase64) | null |
153,126 | 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)
ColumnOrLiteral = t.Union[
Column, str, float, int, bool, t.List, t.Tuple, datetime.date, datetime.datetime
]
def unbase64(col: ColumnOrLiteral) -> Column:
return Column.invoke_expression_over_column(col, expression.FromBase64) | null |
153,127 | 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 ltrim(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "LTRIM") | null |
153,128 | 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 rtrim(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "RTRIM") | null |
153,129 | 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 trim(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Trim) | null |
153,130 | 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 concat_ws(sep: str, *cols: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(
None, expression.ConcatWs, expressions=[lit(sep)] + list(cols)
) | null |
153,131 | 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 decode(col: ColumnOrName, charset: str) -> Column:
return Column.invoke_expression_over_column(
col, expression.Decode, charset=expression.Literal.string(charset)
) | null |
153,132 | 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 encode(col: ColumnOrName, charset: str) -> Column:
return Column.invoke_expression_over_column(
col, expression.Encode, charset=expression.Literal.string(charset)
) | null |
153,133 | 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 format_number(col: ColumnOrName, d: int) -> Column:
return Column.invoke_anonymous_function(col, "FORMAT_NUMBER", lit(d)) | null |
153,134 | 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 format_string(format: str, *cols: ColumnOrName) -> Column:
format_col = lit(format)
columns = [Column.ensure_col(x) for x in cols]
return Column.invoke_anonymous_function(format_col, "FORMAT_STRING", *columns) | null |
153,135 | 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 instr(col: ColumnOrName, substr: str) -> Column:
return Column.invoke_anonymous_function(col, "INSTR", lit(substr)) | null |
153,136 | 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 overlay(
src: ColumnOrName,
replace: ColumnOrName,
pos: t.Union[ColumnOrName, int],
len: t.Optional[t.Union[ColumnOrName, int]] = None,
) -> Column:
if len is not None:
return Column.invoke_anonymous_function(src, "OVERLAY", replace, pos, len)
return Column.invoke_anonymous_function(src, "OVERLAY", replace, pos) | null |
153,137 | 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]
def sentences(
string: ColumnOrName,
language: t.Optional[ColumnOrName] = None,
country: t.Optional[ColumnOrName] = None,
) -> Column:
if language is not None and country is not None:
return Column.invoke_anonymous_function(string, "SENTENCES", language, country)
if language is not None:
return Column.invoke_anonymous_function(string, "SENTENCES", language)
if country is not None:
return Column.invoke_anonymous_function(string, "SENTENCES", lit("en"), country)
return Column.invoke_anonymous_function(string, "SENTENCES") | null |
153,138 | 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 substring(str: ColumnOrName, pos: int, len: int) -> Column:
return Column.ensure_col(str).substr(pos, len) | null |
153,139 | 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:
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 substring_index(str: ColumnOrName, delim: str, count: int) -> Column:
return Column.invoke_anonymous_function(str, "SUBSTRING_INDEX", lit(delim), lit(count)) | null |
153,140 | 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 levenshtein(left: ColumnOrName, right: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(left, expression.Levenshtein, expression=right) | null |
153,141 | 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]
def locate(substr: str, str: ColumnOrName, pos: t.Optional[int] = None) -> Column:
substr_col = lit(substr)
if pos is not None:
return Column.invoke_expression_over_column(
str, expression.StrPosition, substr=substr_col, position=pos
)
return Column.invoke_expression_over_column(str, expression.StrPosition, substr=substr_col) | null |
153,142 | 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 lpad(col: ColumnOrName, len: int, pad: str) -> Column:
return Column.invoke_anonymous_function(col, "LPAD", lit(len), lit(pad)) | null |
153,143 | 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 rpad(col: ColumnOrName, len: int, pad: str) -> Column:
return Column.invoke_anonymous_function(col, "RPAD", lit(len), lit(pad)) | null |
153,144 | 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 repeat(col: ColumnOrName, n: int) -> Column:
return Column.invoke_expression_over_column(col, expression.Repeat, times=lit(n)) | null |
153,145 | 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]
def split(str: ColumnOrName, pattern: str, limit: t.Optional[int] = None) -> Column:
if limit is not None:
return Column.invoke_expression_over_column(
str, expression.RegexpSplit, expression=lit(pattern).expression, limit=limit
)
return Column.invoke_expression_over_column(
str, expression.RegexpSplit, expression=lit(pattern)
) | null |
153,146 | 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]
def regexp_extract(str: ColumnOrName, pattern: str, idx: t.Optional[int] = None) -> Column:
return Column.invoke_expression_over_column(
str,
expression.RegexpExtract,
expression=lit(pattern),
group=idx,
) | null |
153,147 | 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:
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 regexp_replace(
str: ColumnOrName, pattern: str, replacement: str, position: t.Optional[int] = None
) -> Column:
return Column.invoke_expression_over_column(
str,
expression.RegexpReplace,
expression=lit(pattern),
replacement=lit(replacement),
position=position,
) | null |
153,148 | 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 initcap(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Initcap) | null |
153,149 | 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 soundex(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "SOUNDEX") | null |
153,150 | 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 bin(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "BIN") | null |
153,151 | 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 hex(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Hex) | null |
153,152 | 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 unhex(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Unhex) | null |
153,153 | 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 octet_length(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "OCTET_LENGTH") | null |
153,154 | 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 bit_length(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "BIT_LENGTH") | null |
153,155 | 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:
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 translate(srcCol: ColumnOrName, matching: str, replace: str) -> Column:
return Column.invoke_anonymous_function(srcCol, "TRANSLATE", lit(matching), lit(replace)) | null |
153,156 | 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 map_from_arrays(col1: ColumnOrName, col2: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(None, expression.Map, keys=col1, values=col2) | null |
153,157 | 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]
ColumnOrLiteral = t.Union[
Column, str, float, int, bool, t.List, t.Tuple, datetime.date, datetime.datetime
]
def array_contains(col: ColumnOrName, value: ColumnOrLiteral) -> Column:
value_col = value if isinstance(value, Column) else lit(value)
return Column.invoke_expression_over_column(
col, expression.ArrayContains, expression=value_col.expression
) | null |
153,158 | 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 arrays_overlap(col1: ColumnOrName, col2: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col1, "ARRAYS_OVERLAP", Column.ensure_col(col2)) | null |
153,159 | 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:
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 slice(
x: ColumnOrName, start: t.Union[ColumnOrName, int], length: t.Union[ColumnOrName, int]
) -> Column:
start_col = start if isinstance(start, Column) else lit(start)
length_col = length if isinstance(length, Column) else lit(length)
return Column.invoke_anonymous_function(x, "SLICE", start_col, length_col) | null |
153,160 | 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]
def array_join(
col: ColumnOrName, delimiter: str, null_replacement: t.Optional[str] = None
) -> Column:
if null_replacement is not None:
return Column.invoke_expression_over_column(
col, expression.ArrayToString, expression=lit(delimiter), null=lit(null_replacement)
)
return Column.invoke_expression_over_column(
col, expression.ArrayToString, expression=lit(delimiter)
) | null |
153,161 | 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 concat(*cols: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(None, expression.Concat, expressions=cols) | null |
153,162 | 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:
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]
ColumnOrLiteral = t.Union[
Column, str, float, int, bool, t.List, t.Tuple, datetime.date, datetime.datetime
]
def array_position(col: ColumnOrName, value: ColumnOrLiteral) -> Column:
value_col = value if isinstance(value, Column) else lit(value)
return Column.invoke_anonymous_function(col, "ARRAY_POSITION", value_col) | null |
153,163 | 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]
ColumnOrLiteral = t.Union[
Column, str, float, int, bool, t.List, t.Tuple, datetime.date, datetime.datetime
]
def element_at(col: ColumnOrName, value: ColumnOrLiteral) -> Column:
value_col = value if isinstance(value, Column) else lit(value)
return Column.invoke_anonymous_function(col, "ELEMENT_AT", value_col) | null |
153,164 | 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]
ColumnOrLiteral = t.Union[
Column, str, float, int, bool, t.List, t.Tuple, datetime.date, datetime.datetime
]
def array_remove(col: ColumnOrName, value: ColumnOrLiteral) -> Column:
value_col = value if isinstance(value, Column) else lit(value)
return Column.invoke_anonymous_function(col, "ARRAY_REMOVE", value_col) | null |
153,165 | 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 array_distinct(col: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col, "ARRAY_DISTINCT") | null |
153,166 | 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 array_intersect(col1: ColumnOrName, col2: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col1, "ARRAY_INTERSECT", Column.ensure_col(col2)) | null |
153,167 | 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 array_union(col1: ColumnOrName, col2: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col1, "ARRAY_UNION", Column.ensure_col(col2)) | null |
153,168 | 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 array_except(col1: ColumnOrName, col2: ColumnOrName) -> Column:
return Column.invoke_anonymous_function(col1, "ARRAY_EXCEPT", Column.ensure_col(col2)) | null |
153,169 | 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 explode(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Explode) | null |
153,170 | 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 posexplode(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.Posexplode) | null |
153,171 | 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 explode_outer(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.ExplodeOuter) | null |
153,172 | 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 posexplode_outer(col: ColumnOrName) -> Column:
return Column.invoke_expression_over_column(col, expression.PosexplodeOuter) | null |
153,173 | 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:
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 get_json_object(col: ColumnOrName, path: str) -> Column:
return Column.invoke_expression_over_column(col, expression.JSONExtract, expression=lit(path)) | null |
153,174 | 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 json_tuple(col: ColumnOrName, *fields: str) -> Column:
return Column.invoke_anonymous_function(col, "JSON_TUPLE", *[lit(field) for field in fields]) | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.