sqlframe 1.9.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

sqlframe/base/mixins/dataframe_mixins.py

@@ -1,3 +1,5 @@
+import logging
+import sys
 import typing as t
 
 from sqlglot import exp
@@ -12,11 +14,30 @@ from sqlframe.base.dataframe import (
     _BaseDataFrame,
 )
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
 
-class PrintSchemaFromTempObjectsMixin(
+
+logger = logging.getLogger(__name__)
+
+
+class NoCachePersistSupportMixin(_BaseDataFrame, t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
+    def cache(self) -> Self:
+        logger.warning("This engine does not support caching. Ignoring cache() call.")
+        return self
+
+    def persist(self) -> Self:
+        logger.warning("This engine does not support persist. Ignoring persist() call.")
+        return self
+
+
+class TypedColumnsFromTempViewMixin(
     _BaseDataFrame, t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]
 ):
-    def _get_columns_from_temp_object(self) -> t.List[Column]:
+    @property
+    def _typed_columns(self) -> t.List[Column]:
         table = exp.to_table(self.session._random_id)
         self.session._execute(
             exp.Create(
@@ -27,37 +48,7 @@ class PrintSchemaFromTempObjectsMixin(
                 expression=self.expression,
             )
         )
+
         return self.session.catalog.listColumns(
             table.sql(dialect=self.session.input_dialect), include_temp=True
         )
-
-    def printSchema(self, level: t.Optional[int] = None) -> None:
-        def print_schema(
-            column_name: str, column_type: exp.DataType, nullable: bool, current_level: int
-        ):
-            if level and current_level >= level:
-                return
-            if current_level > 0:
-                print(" |   " * current_level, end="")
-            print(
-                f" |-- {column_name}: {column_type.sql(self.session.output_dialect).lower()} (nullable = {str(nullable).lower()})"
-            )
-            if column_type.this == exp.DataType.Type.STRUCT:
-                for column_def in column_type.expressions:
-                    print_schema(column_def.name, column_def.args["kind"], True, current_level + 1)
-            if column_type.this == exp.DataType.Type.ARRAY:
-                for data_type in column_type.expressions:
-                    print_schema("element", data_type, True, current_level + 1)
-            if column_type.this == exp.DataType.Type.MAP:
-                print_schema("key", column_type.expressions[0], True, current_level + 1)
-                print_schema("value", column_type.expressions[1], True, current_level + 1)
-
-        columns = self._get_columns_from_temp_object()
-        print("root")
-        for column in columns:
-            print_schema(
-                column.name,
-                exp.DataType.build(column.dataType, dialect=self.session.output_dialect),
-                column.nullable,
-                0,
-            )

sqlframe/base/session.py

@@ -442,12 +442,12 @@ class _BaseSession(t.Generic[CATALOG, READER, WRITER, DF, CONN]):
 
     @classmethod
     def _to_row(cls, columns: t.List[str], values: t.Iterable[t.Any]) -> Row:
-        from sqlframe.base.types import Row
+        from sqlframe.base.types import Row, _create_row
 
         converted_values = []
         for value in values:
             converted_values.append(cls._to_value(value))
-        return Row(**dict(zip(columns, converted_values)))
+        return _create_row(columns, converted_values)
 
     def _fetch_rows(
         self, sql: t.Union[str, exp.Expression], *, quote_identifiers: bool = True

sqlframe/base/types.py

@@ -22,14 +22,14 @@ class DataType:
         return not self.__eq__(other)
 
     def __str__(self) -> str:
-        return self.typeName()
+        return self.simpleString()
 
     @classmethod
     def typeName(cls) -> str:
         return cls.__name__[:-4].lower()
 
     def simpleString(self) -> str:
-        return str(self)
+        return self.typeName()
 
     def jsonValue(self) -> t.Union[str, t.Dict[str, t.Any]]:
         return str(self)
@@ -222,7 +222,7 @@ class StructType(DataType):
 def _create_row(
     fields: t.Union[Row, t.List[str]], values: t.Union[t.Tuple[t.Any, ...], t.List[t.Any]]
 ) -> Row:
-    row = Row(*values)
+    row = Row(*[float(x) if isinstance(x, Decimal) else x for x in values])
     row.__fields__ = fields
     return row
 

sqlframe/base/util.py

@@ -71,6 +71,11 @@ def get_column_mapping_from_schema_input(
         col_name_type_strs = [x.strip() for x in schema.split(",")]
         if len(col_name_type_strs) == 1 and len(col_name_type_strs[0].split(" ")) == 1:
             value = {"value": col_name_type_strs[0].strip()}
+        elif schema.startswith("struct<") and schema.endswith(">"):
+            value = {
+                name_type_str.split(":")[0].strip(): name_type_str.split(":")[1].strip()
+                for name_type_str in schema[7:-1].split(",")
+            }
         else:
             value = {
                 name_type_str.split(" ")[0].strip(): name_type_str.split(" ")[1].strip()
@@ -286,3 +291,54 @@ def quote_preserving_alias_or_name(col: t.Union[exp.Column, exp.Alias]) -> str:
         return col.sql(dialect=_BaseSession().input_dialect)
     # We may get things like `Null()` expression or maybe literals so we just return the alias or name in those cases
     return col.alias_or_name
+
+
+def sqlglot_to_spark(sqlglot_dtype: exp.DataType) -> types.DataType:
+    from sqlframe.base import types
+
+    primitive_mapping = {
+        exp.DataType.Type.VARCHAR: types.VarcharType,
+        exp.DataType.Type.CHAR: types.CharType,
+        exp.DataType.Type.TEXT: types.StringType,
+        exp.DataType.Type.BINARY: types.BinaryType,
+        exp.DataType.Type.BOOLEAN: types.BooleanType,
+        exp.DataType.Type.INT: types.IntegerType,
+        exp.DataType.Type.BIGINT: types.LongType,
+        exp.DataType.Type.SMALLINT: types.ShortType,
+        exp.DataType.Type.FLOAT: types.FloatType,
+        exp.DataType.Type.DOUBLE: types.DoubleType,
+        exp.DataType.Type.DECIMAL: types.DecimalType,
+        exp.DataType.Type.TIMESTAMP: types.TimestampType,
+        exp.DataType.Type.TIMESTAMPTZ: types.TimestampType,
+        exp.DataType.Type.TIMESTAMPLTZ: types.TimestampType,
+        exp.DataType.Type.TIMESTAMPNTZ: types.TimestampType,
+        exp.DataType.Type.DATE: types.DateType,
+    }
+    if sqlglot_dtype.this in primitive_mapping:
+        pyspark_class = primitive_mapping[sqlglot_dtype.this]
+        if issubclass(pyspark_class, types.DataTypeWithLength) and sqlglot_dtype.expressions:
+            return pyspark_class(length=int(sqlglot_dtype.expressions[0].this.this))
+        elif issubclass(pyspark_class, types.DecimalType) and sqlglot_dtype.expressions:
+            return pyspark_class(
+                precision=int(sqlglot_dtype.expressions[0].this.this),
+                scale=int(sqlglot_dtype.expressions[1].this.this),
+            )
+        return pyspark_class()
+    if sqlglot_dtype.this == exp.DataType.Type.ARRAY:
+        return types.ArrayType(sqlglot_to_spark(sqlglot_dtype.expressions[0]))
+    elif sqlglot_dtype.this == exp.DataType.Type.MAP:
+        return types.MapType(
+            sqlglot_to_spark(sqlglot_dtype.expressions[0]),
+            sqlglot_to_spark(sqlglot_dtype.expressions[1]),
+        )
+    elif sqlglot_dtype.this in (exp.DataType.Type.STRUCT, exp.DataType.Type.OBJECT):
+        return types.StructType(
+            [
+                types.StructField(
+                    name=field.this.alias_or_name,
+                    dataType=sqlglot_to_spark(field.args["kind"]),
+                )
+                for field in sqlglot_dtype.expressions
+            ]
+        )
+    raise NotImplementedError(f"Unsupported data type: {sqlglot_dtype}")

sqlframe/bigquery/dataframe.py

@@ -1,21 +1,17 @@
 from __future__ import annotations
 
 import logging
-import sys
 import typing as t
 
+from sqlframe.base.catalog import Column as CatalogColumn
 from sqlframe.base.dataframe import (
     _BaseDataFrame,
     _BaseDataFrameNaFunctions,
     _BaseDataFrameStatFunctions,
 )
+from sqlframe.base.mixins.dataframe_mixins import NoCachePersistSupportMixin
 from sqlframe.bigquery.group import BigQueryGroupedData
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
 if t.TYPE_CHECKING:
     from sqlframe.bigquery.readwriter import BigQueryDataFrameWriter
     from sqlframe.bigquery.session import BigQuerySession
@@ -33,22 +29,46 @@ class BigQueryDataFrameStatFunctions(_BaseDataFrameStatFunctions["BigQueryDataFr
 
 
 class BigQueryDataFrame(
+    NoCachePersistSupportMixin,
     _BaseDataFrame[
         "BigQuerySession",
         "BigQueryDataFrameWriter",
         "BigQueryDataFrameNaFunctions",
         "BigQueryDataFrameStatFunctions",
         "BigQueryGroupedData",
-    ]
+    ],
 ):
     _na = BigQueryDataFrameNaFunctions
     _stat = BigQueryDataFrameStatFunctions
     _group_data = BigQueryGroupedData
 
-    def cache(self) -> Self:
-        logger.warning("BigQuery does not support caching. Ignoring cache() call.")
-        return self
+    @property
+    def _typed_columns(self) -> t.List[CatalogColumn]:
+        from google.cloud import bigquery
+
+        def field_to_column(field: bigquery.SchemaField) -> CatalogColumn:
+            if field.field_type == "RECORD":
+                data_type = "STRUCT<"
+                for subfield in field.fields:
+                    column = field_to_column(subfield)
+                    data_type += f"{column.name} {column.dataType},"
+                data_type += ">"
+            elif field.field_type == "INTEGER":
+                data_type = "INT64"
+            else:
+                data_type = field.field_type
+            if field.mode == "REPEATED":
+                data_type = f"ARRAY<{data_type}>"
+            return CatalogColumn(
+                name=field.name,
+                dataType=data_type,
+                nullable=field.is_nullable,
+                description=None,
+                isPartition=False,
+                isBucket=False,
+            )
 
-    def persist(self) -> Self:
-        logger.warning("BigQuery does not support persist. Ignoring persist() call.")
-        return self
+        job_config = bigquery.QueryJobConfig(dry_run=True, use_query_cache=False)
+        sql = self.session._to_sql(self.expression)
+        query_job = self.session._client.query(sql, job_config=job_config)
+        return [field_to_column(field) for field in query_job.schema]

sqlframe/bigquery/functions.py

@@ -26,8 +26,11 @@ globals().update(
 
 
 from sqlframe.base.function_alternatives import (  # noqa
+    any_value_ignore_nulls_not_supported as any_value,
+    current_user_from_session_user as current_user,
     e_literal as e,
     expm1_from_exp as expm1,
+    extract_convert_to_var as extract,
     factorial_from_case_statement as factorial,
     log1p_from_log as log1p,
     rint_from_round as rint,
@@ -63,6 +66,7 @@ from sqlframe.base.function_alternatives import (  # noqa
     element_at_using_brackets as element_at,
     array_union_using_array_concat as array_union,
     sequence_from_generate_array as sequence,
+    position_as_strpos as position,
 )
 
 

sqlframe/bigquery/functions.pyi

@@ -1,6 +1,9 @@
 import typing as t
 
 from sqlframe.base.column import Column as Column
+from sqlframe.base.function_alternatives import (  # noqa
+    any_value_ignore_nulls_not_supported as any_value,
+)
 from sqlframe.base.function_alternatives import (
     array_union_using_array_concat as array_union,
 )
@@ -16,6 +19,9 @@ from sqlframe.base.function_alternatives import (
 from sqlframe.base.function_alternatives import (
     concat_ws_from_array_to_string as concat_ws,
 )
+from sqlframe.base.function_alternatives import (
+    current_user_from_session_user as current_user,
+)
 from sqlframe.base.function_alternatives import (
     dayofmonth_from_extract_with_day as dayofmonth,
 )
@@ -25,7 +31,7 @@ from sqlframe.base.function_alternatives import (
 from sqlframe.base.function_alternatives import (
     dayofyear_from_extract as dayofyear,
 )
-from sqlframe.base.function_alternatives import (  # noqa
+from sqlframe.base.function_alternatives import (
     e_literal as e,
 )
 from sqlframe.base.function_alternatives import (
@@ -34,6 +40,9 @@ from sqlframe.base.function_alternatives import (
 from sqlframe.base.function_alternatives import (
     expm1_from_exp as expm1,
 )
+from sqlframe.base.function_alternatives import (
+    extract_convert_to_var as extract,
+)
 from sqlframe.base.function_alternatives import (
     factorial_from_case_statement as factorial,
 )
@@ -79,6 +88,9 @@ from sqlframe.base.function_alternatives import (
 from sqlframe.base.function_alternatives import (
     percentile_approx_without_accuracy_and_plural as percentile_approx,
 )
+from sqlframe.base.function_alternatives import (
+    position_as_strpos as position,
+)
 from sqlframe.base.function_alternatives import (
     quarter_from_extract as quarter,
 )
@@ -133,9 +145,13 @@ from sqlframe.base.functions import atanh as atanh
 from sqlframe.base.functions import avg as avg
 from sqlframe.base.functions import bitwise_not as bitwise_not
 from sqlframe.base.functions import bitwiseNOT as bitwiseNOT
+from sqlframe.base.functions import bool_and as bool_and
+from sqlframe.base.functions import bool_or as bool_or
+from sqlframe.base.functions import call_function as call_function
 from sqlframe.base.functions import cbrt as cbrt
 from sqlframe.base.functions import ceil as ceil
 from sqlframe.base.functions import ceiling as ceiling
+from sqlframe.base.functions import char as char
 from sqlframe.base.functions import coalesce as coalesce
 from sqlframe.base.functions import col as col
 from sqlframe.base.functions import collect_list as collect_list
@@ -145,6 +161,7 @@ from sqlframe.base.functions import cos as cos
 from sqlframe.base.functions import cosh as cosh
 from sqlframe.base.functions import cot as cot
 from sqlframe.base.functions import count as count
+from sqlframe.base.functions import count_if as count_if
 from sqlframe.base.functions import covar_pop as covar_pop
 from sqlframe.base.functions import covar_samp as covar_samp
 from sqlframe.base.functions import csc as csc
@@ -156,6 +173,8 @@ from sqlframe.base.functions import date_diff as date_diff
 from sqlframe.base.functions import date_format as date_format
 from sqlframe.base.functions import date_sub as date_sub
 from sqlframe.base.functions import date_trunc as date_trunc
+from sqlframe.base.functions import dateadd as dateadd
+from sqlframe.base.functions import datediff as datediff
 from sqlframe.base.functions import dense_rank as dense_rank
 from sqlframe.base.functions import desc as desc
 from sqlframe.base.functions import desc_nulls_first as desc_nulls_first
@@ -167,14 +186,18 @@ from sqlframe.base.functions import expr as expr
 from sqlframe.base.functions import floor as floor
 from sqlframe.base.functions import get_json_object as get_json_object
 from sqlframe.base.functions import greatest as greatest
+from sqlframe.base.functions import ifnull as ifnull
 from sqlframe.base.functions import initcap as initcap
 from sqlframe.base.functions import input_file_name as input_file_name
 from sqlframe.base.functions import isnan as isnan
 from sqlframe.base.functions import lag as lag
+from sqlframe.base.functions import lcase as lcase
 from sqlframe.base.functions import lead as lead
 from sqlframe.base.functions import least as least
+from sqlframe.base.functions import left as left
 from sqlframe.base.functions import length as length
 from sqlframe.base.functions import lit as lit
+from sqlframe.base.functions import ln as ln
 from sqlframe.base.functions import log as log
 from sqlframe.base.functions import log2 as log2
 from sqlframe.base.functions import log10 as log10
@@ -187,33 +210,43 @@ from sqlframe.base.functions import md5 as md5
 from sqlframe.base.functions import mean as mean
 from sqlframe.base.functions import min as min
 from sqlframe.base.functions import min_by as min_by
+from sqlframe.base.functions import now as now
 from sqlframe.base.functions import nth_value as nth_value
 from sqlframe.base.functions import ntile as ntile
 from sqlframe.base.functions import nullif as nullif
+from sqlframe.base.functions import nvl as nvl
+from sqlframe.base.functions import nvl2 as nvl2
 from sqlframe.base.functions import octet_length as octet_length
 from sqlframe.base.functions import percent_rank as percent_rank
 from sqlframe.base.functions import posexplode as posexplode
 from sqlframe.base.functions import posexplode_outer as posexplode_outer
 from sqlframe.base.functions import pow as pow
+from sqlframe.base.functions import power as power
 from sqlframe.base.functions import rank as rank
+from sqlframe.base.functions import regexp_like as regexp_like
 from sqlframe.base.functions import regexp_replace as regexp_replace
 from sqlframe.base.functions import repeat as repeat
 from sqlframe.base.functions import reverse as reverse
+from sqlframe.base.functions import right as right
+from sqlframe.base.functions import rlike as rlike
 from sqlframe.base.functions import round as round
 from sqlframe.base.functions import row_number as row_number
 from sqlframe.base.functions import rpad as rpad
 from sqlframe.base.functions import rtrim as rtrim
 from sqlframe.base.functions import sec as sec
+from sqlframe.base.functions import sha as sha
 from sqlframe.base.functions import shiftLeft as shiftLeft
 from sqlframe.base.functions import shiftleft as shiftleft
 from sqlframe.base.functions import shiftRight as shiftRight
 from sqlframe.base.functions import shiftright as shiftright
+from sqlframe.base.functions import sign as sign
 from sqlframe.base.functions import signum as signum
 from sqlframe.base.functions import sin as sin
 from sqlframe.base.functions import sinh as sinh
 from sqlframe.base.functions import size as size
 from sqlframe.base.functions import soundex as soundex
 from sqlframe.base.functions import sqrt as sqrt
+from sqlframe.base.functions import startswith as startswith
 from sqlframe.base.functions import stddev as stddev
 from sqlframe.base.functions import stddev_pop as stddev_pop
 from sqlframe.base.functions import stddev_samp as stddev_samp
@@ -231,9 +264,12 @@ from sqlframe.base.functions import toRadians as toRadians
 from sqlframe.base.functions import translate as translate
 from sqlframe.base.functions import trim as trim
 from sqlframe.base.functions import trunc as trunc
+from sqlframe.base.functions import ucase as ucase
 from sqlframe.base.functions import unbase64 as unbase64
 from sqlframe.base.functions import unhex as unhex
+from sqlframe.base.functions import unix_date as unix_date
 from sqlframe.base.functions import upper as upper
+from sqlframe.base.functions import user as user
 from sqlframe.base.functions import var_pop as var_pop
 from sqlframe.base.functions import var_samp as var_samp
 from sqlframe.base.functions import variance as variance

sqlframe/duckdb/dataframe.py

@@ -9,14 +9,12 @@ from sqlframe.base.dataframe import (
     _BaseDataFrameNaFunctions,
     _BaseDataFrameStatFunctions,
 )
-from sqlframe.base.mixins.dataframe_mixins import PrintSchemaFromTempObjectsMixin
+from sqlframe.base.mixins.dataframe_mixins import (
+    NoCachePersistSupportMixin,
+    TypedColumnsFromTempViewMixin,
+)
 from sqlframe.duckdb.group import DuckDBGroupedData
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
 if t.TYPE_CHECKING:
     from sqlframe.duckdb.session import DuckDBSession  # noqa
     from sqlframe.duckdb.readwriter import DuckDBDataFrameWriter  # noqa
@@ -35,7 +33,8 @@ class DuckDBDataFrameStatFunctions(_BaseDataFrameStatFunctions["DuckDBDataFrame"
 
 
 class DuckDBDataFrame(
-    PrintSchemaFromTempObjectsMixin,
+    NoCachePersistSupportMixin,
+    TypedColumnsFromTempViewMixin,
     _BaseDataFrame[
         "DuckDBSession",
         "DuckDBDataFrameWriter",
@@ -47,11 +46,3 @@ class DuckDBDataFrame(
     _na = DuckDBDataFrameNaFunctions
     _stat = DuckDBDataFrameStatFunctions
     _group_data = DuckDBGroupedData
-
-    def cache(self) -> Self:
-        logger.warning("DuckDB does not support caching. Ignoring cache() call.")
-        return self
-
-    def persist(self) -> Self:
-        logger.warning("DuckDB does not support persist. Ignoring persist() call.")
-        return self

sqlframe/duckdb/functions.py

@@ -18,6 +18,7 @@ globals().update(
 
 
 from sqlframe.base.function_alternatives import (  # noqa
+    any_value_always_ignore_nulls as any_value,
     e_literal as e,
     expm1_from_exp as expm1,
     log1p_from_log as log1p,
@@ -44,4 +45,6 @@ from sqlframe.base.function_alternatives import (  # noqa
     array_min_from_sort as array_min,
     array_max_from_sort as array_max,
     sequence_from_generate_series as sequence,
+    try_element_at_zero_based as try_element_at,
+    to_unix_timestamp_include_default_format as to_unix_timestamp,
 )

sqlframe/duckdb/functions.pyi

@@ -1,4 +1,5 @@
 from sqlframe.base.function_alternatives import (  # noqa
+    any_value_always_ignore_nulls as any_value,
     e_literal as e,
     expm1_from_exp as expm1,
     log1p_from_log as log1p,
@@ -25,6 +26,8 @@ from sqlframe.base.function_alternatives import (  # noqa
     array_min_from_sort as array_min,
     array_max_from_sort as array_max,
     sequence_from_generate_series as sequence,
+    try_element_at_zero_based as try_element_at,
+    to_unix_timestamp_include_default_format as to_unix_timestamp,
 )
 from sqlframe.base.functions import (
     abs as abs,
@@ -50,9 +53,13 @@ from sqlframe.base.functions import (
     bit_length as bit_length,
     bitwiseNOT as bitwiseNOT,
     bitwise_not as bitwise_not,
+    bool_and as bool_and,
+    bool_or as bool_or,
+    call_function as call_function,
     cbrt as cbrt,
     ceil as ceil,
     ceiling as ceiling,
+    char as char,
     coalesce as coalesce,
     col as col,
     collect_list as collect_list,
@@ -64,17 +71,21 @@ from sqlframe.base.functions import (
     count as count,
     countDistinct as countDistinct,
     count_distinct as count_distinct,
+    count_if as count_if,
     covar_pop as covar_pop,
     covar_samp as covar_samp,
     create_map as create_map,
     cume_dist as cume_dist,
     current_date as current_date,
     current_timestamp as current_timestamp,
+    current_user as current_user,
     date_add as date_add,
     date_diff as date_diff,
     date_format as date_format,
     date_sub as date_sub,
     date_trunc as date_trunc,
+    dateadd as dateadd,
+    datediff as datediff,
     dayofmonth as dayofmonth,
     dayofweek as dayofweek,
     dayofyear as dayofyear,
@@ -87,6 +98,7 @@ from sqlframe.base.functions import (
     exp as exp,
     explode as explode,
     expr as expr,
+    extract as extract,
     flatten as flatten,
     floor as floor,
     from_unixtime as from_unixtime,
@@ -96,16 +108,20 @@ from sqlframe.base.functions import (
     hash as hash,
     hex as hex,
     hour as hour,
+    ifnull as ifnull,
     input_file_name as input_file_name,
     instr as instr,
     isnan as isnan,
     lag as lag,
     last as last,
+    lcase as lcase,
     lead as lead,
     least as least,
+    left as left,
     length as length,
     levenshtein as levenshtein,
     lit as lit,
+    ln as ln,
     locate as locate,
     log as log,
     log10 as log10,
@@ -124,19 +140,27 @@ from sqlframe.base.functions import (
     minute as minute,
     month as month,
     months_between as months_between,
+    now as now,
     nth_value as nth_value,
     ntile as ntile,
     nullif as nullif,
+    nvl as nvl,
+    nvl2 as nvl2,
     percent_rank as percent_rank,
     percentile as percentile,
+    position as position,
     pow as pow,
+    power as power,
     quarter as quarter,
     radians as radians,
     rank as rank,
     regexp_extract as regexp_extract,
+    regexp_like as regexp_like,
     regexp_replace as regexp_replace,
     repeat as repeat,
     reverse as reverse,
+    right as right,
+    rlike as rlike,
     round as round,
     row_number as row_number,
     rpad as rpad,
@@ -146,6 +170,7 @@ from sqlframe.base.functions import (
     shiftRight as shiftRight,
     shiftleft as shiftleft,
     shiftright as shiftright,
+    sign as sign,
     signum as signum,
     sin as sin,
     size as size,
@@ -153,6 +178,7 @@ from sqlframe.base.functions import (
     sort_array as sort_array,
     soundex as soundex,
     sqrt as sqrt,
+    startswith as startswith,
     stddev as stddev,
     stddev_pop as stddev_pop,
     stddev_samp as stddev_samp,
@@ -171,10 +197,13 @@ from sqlframe.base.functions import (
     trim as trim,
     trunc as trunc,
     typeof as typeof,
+    ucase as ucase,
     unbase64 as unbase64,
     unhex as unhex,
+    unix_date as unix_date,
     unix_timestamp as unix_timestamp,
     upper as upper,
+    user as user,
     var_pop as var_pop,
     var_samp as var_samp,
     variance as variance,