sqlframe 3.22.0__tar.gz → 3.23.0__tar.gz

{sqlframe-3.22.0 → sqlframe-3.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlframe
-Version: 3.22.0
+Version: 3.23.0
 Summary: Turning PySpark Into a Universal DataFrame API
 Home-page: https://github.com/eakmanrq/sqlframe
 Author: Ryan Eakman

{sqlframe-3.22.0 → sqlframe-3.23.0}/setup.py

@@ -20,7 +20,7 @@ setup(
     python_requires=">=3.9",
     install_requires=[
         "prettytable<4",
-        "sqlglot>=24.0.0,<26.7",
+        "sqlglot>=24.0.0,<26.9",
         "typing_extensions",
     ],
     extras_require={
@@ -29,7 +29,7 @@ setup(
             "google-cloud-bigquery-storage>=2,<3",
         ],
         "dev": [
-            "duckdb>=0.9,<1.2",
+            "duckdb>=1.2,<1.3",
             "findspark>=2,<3",
             "mypy>=1.10.0,<1.16",
             "openai>=1.30,<2",
@@ -40,7 +40,7 @@ setup(
             "pyspark>=2,<3.6",
             "pytest>=8.2.0,<8.4",
             "pytest-forked",
-            "pytest-postgresql>=6,<7",
+            "pytest-postgresql>=6,<8",
             "pytest-xdist>=3.6,<3.7",
             "pre-commit>=3.7,<5",
             "ruff>=0.4.4,<0.10",
@@ -54,7 +54,7 @@ setup(
             "pymdown-extensions",
         ],
         "duckdb": [
-            "duckdb>=0.9,<1.2",
+            "duckdb>=1.2,<1.3",
             "pandas>=2,<3",
         ],
         "openai": [
@@ -70,7 +70,7 @@ setup(
             "redshift_connector>=2.1.1,<2.2.0",
         ],
         "snowflake": [
-            "snowflake-connector-python[secure-local-storage]>=3.10.0,<3.14",
+            "snowflake-connector-python[secure-local-storage]>=3.10.0,<3.15",
         ],
         "spark": [
             "pyspark>=2,<3.6",

{sqlframe-3.22.0 → sqlframe-3.23.0}/sqlframe/_version.py

@@ -1,8 +1,13 @@
-# file generated by setuptools_scm
+# file generated by setuptools-scm
 # don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple, Union
+    from typing import Tuple
+    from typing import Union
+
     VERSION_TUPLE = Tuple[Union[int, str], ...]
 else:
     VERSION_TUPLE = object
@@ -12,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.22.0'
-__version_tuple__ = version_tuple = (3, 22, 0)
+__version__ = version = '3.23.0'
+__version_tuple__ = version_tuple = (3, 23, 0)

{sqlframe-3.22.0 → sqlframe-3.23.0}/sqlframe/base/catalog.py

@@ -70,13 +70,16 @@ class _BaseCatalog(t.Generic[SESSION, DF]):
         }
 
     def add_table(
-        self, table: exp.Table | str, column_mapping: t.Optional[ColumnMapping] = None
+        self,
+        table: exp.Table | str,
+        column_mapping: t.Optional[ColumnMapping] = None,
+        **kwargs: t.Any,
     ) -> None:
         # TODO: Making this an update or add
         table = self.ensure_table(table)
         if self._schema.find(table):
             return
-        if not column_mapping:
+        if column_mapping is None:
             try:
                 column_mapping = {
                     normalize_string(
@@ -100,7 +103,7 @@ class _BaseCatalog(t.Generic[SESSION, DF]):
             if column.this.quoted:
                 self._quoted_columns[table].append(column.this.name)
 
-        self._schema.add_table(table, column_mapping, dialect=self.session.input_dialect)
+        self._schema.add_table(table, column_mapping, dialect=self.session.input_dialect, **kwargs)
 
     def getDatabase(self, dbName: str) -> Database:
         """Get the database with the specified name.

{sqlframe-3.22.0 → sqlframe-3.23.0}/sqlframe/base/functions.py

@@ -856,15 +856,21 @@ def expr(str: str) -> Column:
 
 @meta(unsupported_engines=["postgres"])
 def struct(col: t.Union[ColumnOrName, t.Iterable[ColumnOrName]], *cols: ColumnOrName) -> Column:
-    from sqlframe.base.function_alternatives import struct_with_eq
-
     session = _get_session()
-
-    if session._is_snowflake:
-        return struct_with_eq(col, *cols)
-
-    columns = ensure_list(col) + list(cols)
-    return Column.invoke_expression_over_column(None, expression.Struct, expressions=columns)
+    col_func = get_func_from_session("col")
+
+    columns = [col_func(x) for x in ensure_list(col) + list(cols)]
+    expressions = []
+    for column in columns:
+        expressions.append(
+            expression.PropertyEQ(
+                this=expression.parse_identifier(
+                    column.alias_or_name, dialect=session.input_dialect
+                ),
+                expression=column.column_expression,
+            )
+        )
+    return Column(expression.Struct(expressions=expressions))
 
 
 @meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])

{sqlframe-3.22.0 → sqlframe-3.23.0}/sqlframe/base/util.py

@@ -279,15 +279,6 @@ def verify_openai_installed():
         )
 
 
-def verify_numpy_installed():
-    try:
-        import numpy  # noqa
-    except ImportError:
-        raise ImportError(
-            """Numpy is required for this functionality. `pip install "sqlframe[pandas]"` (also include your engine if needed) to install pandas/numpy."""
-        )
-
-
 def quote_preserving_alias_or_name(col: t.Union[exp.Column, exp.Alias]) -> str:
     from sqlframe.base.session import _BaseSession
 

{sqlframe-3.22.0 → sqlframe-3.23.0}/sqlframe/base/window.py

@@ -82,37 +82,26 @@ class WindowSpec:
     def _calc_start_end(
         self, start: int, end: int
     ) -> t.Dict[str, t.Optional[t.Union[str, exp.Expression]]]:
-        kwargs: t.Dict[str, t.Optional[t.Union[str, exp.Expression]]] = {
-            "start_side": None,
-            "end_side": None,
+        def get_value_and_side(x: int) -> t.Tuple[t.Union[str, exp.Expression], t.Optional[str]]:
+            if x == Window.currentRow:
+                return "CURRENT ROW", None
+            if x < 0:
+                side = "PRECEDING"
+                value = "UNBOUNDED" if x <= Window.unboundedPreceding else F.lit(abs(x)).expression
+                return value, side
+            else:
+                side = "FOLLOWING"
+                value = "UNBOUNDED" if x >= Window.unboundedFollowing else F.lit(x).expression
+                return value, side
+
+        start, start_side = get_value_and_side(start)  # type: ignore
+        end, end_side = get_value_and_side(end)  # type: ignore
+        return {
+            "start": start,  # type: ignore
+            "start_side": start_side,
+            "end": end,  # type: ignore
+            "end_side": end_side,
         }
-        if start == Window.currentRow:
-            kwargs["start"] = "CURRENT ROW"
-        else:
-            kwargs = {
-                **kwargs,
-                **{
-                    "start_side": "PRECEDING",
-                    "start": (
-                        "UNBOUNDED"
-                        if start <= Window.unboundedPreceding
-                        else F.lit(start).expression
-                    ),
-                },
-            }
-        if end == Window.currentRow:
-            kwargs["end"] = "CURRENT ROW"
-        else:
-            kwargs = {
-                **kwargs,
-                **{
-                    "end_side": "FOLLOWING",
-                    "end": (
-                        "UNBOUNDED" if end >= Window.unboundedFollowing else F.lit(end).expression
-                    ),
-                },
-            }
-        return kwargs
 
     def rowsBetween(self, start: int, end: int) -> WindowSpec:
         window_spec = self.copy()

{sqlframe-3.22.0 → sqlframe-3.23.0}/sqlframe/duckdb/session.py

@@ -4,7 +4,7 @@ import typing as t
 from functools import cached_property
 
 from sqlframe.base.session import _BaseSession
-from sqlframe.base.util import soundex, verify_numpy_installed
+from sqlframe.base.util import soundex
 from sqlframe.duckdb.catalog import DuckDBCatalog
 from sqlframe.duckdb.dataframe import DuckDBDataFrame
 from sqlframe.duckdb.readwriter import (
@@ -46,8 +46,6 @@ class DuckDBSession(
         if not hasattr(self, "_conn"):
             conn = conn or duckdb.connect()
             try:
-                # Creating a function requires numpy to be installed so if they don't have it, we'll just skip it
-                verify_numpy_installed()
                 conn.create_function("SOUNDEX", lambda x: soundex(x), return_type=VARCHAR)
             except ImportError:
                 pass

{sqlframe-3.22.0 → sqlframe-3.23.0}/sqlframe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlframe
-Version: 3.22.0
+Version: 3.23.0
 Summary: Turning PySpark Into a Universal DataFrame API
 Home-page: https://github.com/eakmanrq/sqlframe
 Author: Ryan Eakman

{sqlframe-3.22.0 → sqlframe-3.23.0}/sqlframe.egg-info/requires.txt

@@ -1,5 +1,5 @@
 prettytable<4
-sqlglot<26.7,>=24.0.0
+sqlglot<26.9,>=24.0.0
 typing_extensions
 
 [bigquery]
@@ -10,7 +10,7 @@ google-cloud-bigquery[pandas]<4,>=3
 databricks-sql-connector<5,>=3.6
 
 [dev]
-duckdb<1.2,>=0.9
+duckdb<1.3,>=1.2
 findspark<3,>=2
 mypy<1.16,>=1.10.0
 openai<2,>=1.30
@@ -21,7 +21,7 @@ psycopg<4,>=3.1
 pyarrow<20,>=10
 pyspark<3.6,>=2
 pytest-forked
-pytest-postgresql<7,>=6
+pytest-postgresql<8,>=6
 pytest-xdist<3.7,>=3.6
 pytest<8.4,>=8.2.0
 ruff<0.10,>=0.4.4
@@ -35,7 +35,7 @@ mkdocs==1.4.2
 pymdown-extensions
 
 [duckdb]
-duckdb<1.2,>=0.9
+duckdb<1.3,>=1.2
 pandas<3,>=2
 
 [openai]
@@ -51,7 +51,7 @@ psycopg2<3,>=2.8
 redshift_connector<2.2.0,>=2.1.1
 
 [snowflake]
-snowflake-connector-python[secure-local-storage]<3.14,>=3.10.0
+snowflake-connector-python[secure-local-storage]<3.15,>=3.10.0
 
 [spark]
 pyspark<3.6,>=2

{sqlframe-3.22.0 → sqlframe-3.23.0}/tests/integration/engines/duck/test_duckdb_catalog.py

@@ -57,25 +57,15 @@ def test_set_current_database(duckdb_session: DuckDBSession):
 
 def test_list_databases(duckdb_session: DuckDBSession):
     assert sorted(duckdb_session.catalog.listDatabases(), key=lambda x: (x.catalog, x.name)) == [
-        Database(name="information_schema", catalog="catalog1", description=None, locationUri=""),
         Database(name="main", catalog="catalog1", description=None, locationUri=""),
-        Database(name="pg_catalog", catalog="catalog1", description=None, locationUri=""),
-        Database(name="information_schema", catalog="catalog2", description=None, locationUri=""),
         Database(name="main", catalog="catalog2", description=None, locationUri=""),
-        Database(name="pg_catalog", catalog="catalog2", description=None, locationUri=""),
         Database(name="db1", catalog="default", description=None, locationUri=""),
-        Database(name="information_schema", catalog="default", description=None, locationUri=""),
         Database(name="main", catalog="default", description=None, locationUri=""),
-        Database(name="pg_catalog", catalog="default", description=None, locationUri=""),
-        Database(name="information_schema", catalog="memory", description=None, locationUri=""),
         Database(name="main", catalog="memory", description=None, locationUri=""),
-        Database(name="pg_catalog", catalog="memory", description=None, locationUri=""),
         Database(name="information_schema", catalog="system", description=None, locationUri=""),
         Database(name="main", catalog="system", description=None, locationUri=""),
         Database(name="pg_catalog", catalog="system", description=None, locationUri=""),
-        Database(name="information_schema", catalog="temp", description=None, locationUri=""),
         Database(name="main", catalog="temp", description=None, locationUri=""),
-        Database(name="pg_catalog", catalog="temp", description=None, locationUri=""),
     ]
 
 
@@ -99,8 +89,8 @@ def test_get_database_name_only(duckdb_session: DuckDBSession):
 
 
 def test_get_database_name_and_catalog(duckdb_session: DuckDBSession):
-    assert duckdb_session.catalog.getDatabase("catalog1.information_schema") == Database(
-        name="information_schema", catalog="catalog1", description=None, locationUri=""
+    assert duckdb_session.catalog.getDatabase("system.information_schema") == Database(
+        name="information_schema", catalog="system", description=None, locationUri=""
     )
 
 

{sqlframe-3.22.0 → sqlframe-3.23.0}/tests/integration/engines/duck/test_duckdb_reader.py

@@ -1,3 +1,7 @@
+import os
+
+import pytest
+
 from sqlframe.base.types import Row
 from sqlframe.duckdb import DuckDBSession
 from sqlframe.duckdb import functions as F
@@ -102,6 +106,10 @@ def test_employee_extra_line_csv_multiple(duckdb_session: DuckDBSession):
 
 
 def test_employee_delta(duckdb_session: DuckDBSession):
+    if os.environ.get("CI"):
+        pytest.skip(
+            "DuckDB Delta is not working in CI with DuckDB 1.2.1. Error: `duckdb.duckdb.Error: An error occurred while trying to automatically install the required extension 'delta'`"
+        )
     df = duckdb_session.read.load(
         "tests/fixtures/employee_delta",
         format="delta",

{sqlframe-3.22.0 → sqlframe-3.23.0}/tests/integration/engines/test_int_functions.py

@@ -1062,8 +1062,23 @@ def test_struct(get_session_and_func):
         if not isinstance(session, SnowflakeSession)
         else [Row(value={"age": 2, "name": "Alice"}), Row(value={"age": 5, "name": "Bob"})]
     )
-    assert df.select(struct("age", "name").alias("struct")).collect() == expected
-    assert df.select(struct([df.age, df.name]).alias("struct")).collect() == expected
+    expected_field_names = ["age", "name"]
+    result = df.select(struct("age", "name").alias("struct")).collect()
+    assert result == expected
+    if isinstance(session, (SparkSession, PySparkSession)):
+        pass
+    elif isinstance(session, SnowflakeSession):
+        assert list(result[0][0]) == expected_field_names
+    else:
+        assert result[0][0]._unique_field_names == expected_field_names
+    result = df.select(struct([df.age, df.name]).alias("struct")).collect()
+    assert result == expected
+    if isinstance(session, (SparkSession, PySparkSession)):
+        pass
+    elif isinstance(session, SnowflakeSession):
+        assert list(result[0][0]) == expected_field_names
+    else:
+        assert result[0][0]._unique_field_names == expected_field_names
 
 
 def test_greatest(get_session_and_func):
@@ -1576,7 +1591,7 @@ def test_hash(get_session_and_func):
     df = session.createDataFrame([("ABC", "DEF")], ["c1", "c2"])
     if isinstance(session, DuckDBSession):
         assert df.select(hash("c1").alias("hash")).first()[0] == 1241521928161919141
-        assert df.select(hash("c1", "c2").alias("hash")).first()[0] == 13305036188712072380
+        assert df.select(hash("c1", "c2").alias("hash")).first()[0] == 7524280102280623017
     # Bigquery only supports hashing a single column
     elif isinstance(session, BigQuerySession):
         assert df.select(hash("c1").alias("hash")).first()[0] == 228873345217803866
@@ -4879,9 +4894,9 @@ def test_try_element_at(get_session_and_func, get_func):
     else:
         assert df.select(try_element_at(df.data, lit(-1)).alias("r")).first()[0] == "c"
     df = session.createDataFrame([({"a": 1.0, "b": 2.0},)], ["data"])
-    if isinstance(session, DuckDBSession):
-        assert df.select(try_element_at(df.data, lit("a")).alias("r")).first()[0] == [1.0]
-    elif isinstance(session, PostgresSession):
+    # if isinstance(session, DuckDBSession):
+    #     assert df.select(try_element_at(df.data, lit("a")).alias("r")).first()[0] == [1.0]
+    if isinstance(session, PostgresSession):
         pass
     else:
         assert df.select(try_element_at(df.data, lit("a")).alias("r")).first()[0] == 1.0

{sqlframe-3.22.0 → sqlframe-3.23.0}/tests/integration/test_int_dataframe.py

@@ -6,8 +6,10 @@ import pandas as pd
 import pytest
 from _pytest.fixtures import FixtureRequest
 from pyspark.sql import DataFrame as PySparkDataFrame
+from pyspark.sql import Window
 from pyspark.sql import functions as F
 
+from sqlframe.standalone import Window as SWindow
 from sqlframe.standalone import functions as SF
 from sqlframe.standalone.dataframe import StandaloneDataFrame
 from tests.integration.fixtures import StandaloneSession, is_snowflake
@@ -2548,3 +2550,87 @@ def test_full_outer_nulls_no_match(
     dfs = dfs_concept_1.join(dfs_concept_2, on="col1", how="outer")
 
     compare_frames(df, dfs, compare_schema=False)
+
+
+# https://github.com/eakmanrq/sqlframe/issues/317
+def test_rows_between_negative_start(
+    pyspark_employee: PySparkDataFrame,
+    get_df: t.Callable[[str], BaseDataFrame],
+    compare_frames: t.Callable,
+):
+    session = pyspark_employee.sparkSession
+    df = session.createDataFrame(
+        pd.DataFrame(
+            {"store": [1, 1, 1, 2, 2, 2, 2], "price": [1, 2, 3, 4, 3, 2, 1], "date": list(range(7))}
+        )
+    )
+    window = Window().partitionBy("store").orderBy("date").rowsBetween(-1, 1)
+    df = df.withColumn("rolling_price", F.mean("price").over(window))
+
+    employee = get_df("employee")
+    sf_session = employee.session
+    dfs = sf_session.createDataFrame(
+        pd.DataFrame(
+            {"store": [1, 1, 1, 2, 2, 2, 2], "price": [1, 2, 3, 4, 3, 2, 1], "date": list(range(7))}
+        )
+    )
+    swindow = SWindow().partitionBy("store").orderBy("date").rowsBetween(-1, 1)
+    dfs = dfs.withColumn("rolling_price", SF.mean("price").over(swindow))
+
+    compare_frames(df, dfs, compare_schema=False)
+
+
+# https://github.com/eakmanrq/sqlframe/issues/317
+def test_rows_between_negative_end(
+    pyspark_employee: PySparkDataFrame,
+    get_df: t.Callable[[str], BaseDataFrame],
+    compare_frames: t.Callable,
+):
+    session = pyspark_employee.sparkSession
+    df = session.createDataFrame(
+        pd.DataFrame(
+            {"store": [1, 1, 1, 2, 2, 2, 2], "price": [1, 2, 3, 4, 3, 2, 1], "date": list(range(7))}
+        )
+    )
+    window = Window().partitionBy("store").orderBy("date").rowsBetween(-2, -1)
+    df = df.withColumn("rolling_price", F.mean("price").over(window))
+
+    employee = get_df("employee")
+    sf_session = employee.session
+    dfs = sf_session.createDataFrame(
+        pd.DataFrame(
+            {"store": [1, 1, 1, 2, 2, 2, 2], "price": [1, 2, 3, 4, 3, 2, 1], "date": list(range(7))}
+        )
+    )
+    swindow = SWindow().partitionBy("store").orderBy("date").rowsBetween(-2, -1)
+    dfs = dfs.withColumn("rolling_price", SF.mean("price").over(swindow))
+
+    compare_frames(df, dfs, compare_schema=False)
+
+
+# https://github.com/eakmanrq/sqlframe/issues/317
+def test_rows_between_positive_both_start_end(
+    pyspark_employee: PySparkDataFrame,
+    get_df: t.Callable[[str], BaseDataFrame],
+    compare_frames: t.Callable,
+):
+    session = pyspark_employee.sparkSession
+    df = session.createDataFrame(
+        pd.DataFrame(
+            {"store": [1, 1, 1, 2, 2, 2, 2], "price": [1, 2, 3, 4, 3, 2, 1], "date": list(range(7))}
+        )
+    )
+    window = Window().partitionBy("store").orderBy("date").rowsBetween(1, 2)
+    df = df.withColumn("rolling_price", F.mean("price").over(window))
+
+    employee = get_df("employee")
+    sf_session = employee.session
+    dfs = sf_session.createDataFrame(
+        pd.DataFrame(
+            {"store": [1, 1, 1, 2, 2, 2, 2], "price": [1, 2, 3, 4, 3, 2, 1], "date": list(range(7))}
+        )
+    )
+    swindow = SWindow().partitionBy("store").orderBy("date").rowsBetween(1, 2)
+    dfs = dfs.withColumn("rolling_price", SF.mean("price").over(swindow))
+
+    compare_frames(df, dfs, compare_schema=False)

{sqlframe-3.22.0 → sqlframe-3.23.0}/tests/unit/standalone/test_column.py

@@ -207,7 +207,9 @@ def test_over():
     assert (
         (
             F.sum("cola").over(
-                Window.partitionBy("colb").orderBy("colc").rowsBetween(1, Window.unboundedFollowing)
+                Window.partitionBy("colb")
+                .orderBy("colc")
+                .rowsBetween(-1, Window.unboundedFollowing)
             )
         ).sql()
         == "SUM(cola) OVER (PARTITION BY colb ORDER BY colc ROWS BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING)"
@@ -217,7 +219,7 @@ def test_over():
             F.sum("cola").over(
                 Window.partitionBy("colb")
                 .orderBy("colc")
-                .rangeBetween(1, Window.unboundedFollowing)
+                .rangeBetween(-1, Window.unboundedFollowing)
             )
         ).sql()
         == "SUM(cola) OVER (PARTITION BY colb ORDER BY colc RANGE BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING)"

{sqlframe-3.22.0 → sqlframe-3.23.0}/tests/unit/standalone/test_functions.py

@@ -1070,10 +1070,13 @@ def test_expr():
 @pytest.mark.parametrize(
     "expression, expected",
     [
-        (SF.struct("cola", "colb", "colc"), "STRUCT(cola, colb, colc)"),
-        (SF.struct(SF.col("cola"), SF.col("colb"), SF.col("colc")), "STRUCT(cola, colb, colc)"),
-        (SF.struct("cola"), "STRUCT(cola)"),
-        (SF.struct(["cola", "colb", "colc"]), "STRUCT(cola, colb, colc)"),
+        (SF.struct("cola", "colb", "colc"), "STRUCT(cola AS cola, colb AS colb, colc AS colc)"),
+        (
+            SF.struct(SF.col("cola"), SF.col("colb"), SF.col("colc")),
+            "STRUCT(cola AS cola, colb AS colb, colc AS colc)",
+        ),
+        (SF.struct("cola"), "STRUCT(cola AS cola)"),
+        (SF.struct(["cola", "colb", "colc"]), "STRUCT(cola AS cola, colb AS colb, colc AS colc)"),
     ],
 )
 def test_struct(expression, expected):

{sqlframe-3.22.0 → sqlframe-3.23.0}/tests/unit/standalone/test_window.py

@@ -11,29 +11,41 @@ from sqlframe.standalone.window import Window, WindowSpec
         (Window.partitionBy(F.col("cola"), F.col("colb")), "OVER (PARTITION BY cola, colb)"),
         (WindowSpec().orderBy("cola", "colb"), "OVER (ORDER BY cola, colb)"),
         (Window.orderBy("cola", "colb"), "OVER (ORDER BY cola, colb)"),
-        (WindowSpec().rowsBetween(3, 5), "OVER (ROWS BETWEEN 3 PRECEDING AND 5 FOLLOWING)"),
-        (Window.rowsBetween(3, 5), "OVER (ROWS BETWEEN 3 PRECEDING AND 5 FOLLOWING)"),
-        (WindowSpec().rangeBetween(3, 5), "OVER (RANGE BETWEEN 3 PRECEDING AND 5 FOLLOWING)"),
-        (Window.rangeBetween(3, 5), "OVER (RANGE BETWEEN 3 PRECEDING AND 5 FOLLOWING)"),
+        (WindowSpec().rowsBetween(3, 5), "OVER (ROWS BETWEEN 3 FOLLOWING AND 5 FOLLOWING)"),
+        (Window.rowsBetween(3, 5), "OVER (ROWS BETWEEN 3 FOLLOWING AND 5 FOLLOWING)"),
+        (WindowSpec().rangeBetween(3, 5), "OVER (RANGE BETWEEN 3 FOLLOWING AND 5 FOLLOWING)"),
+        (Window.rangeBetween(3, 5), "OVER (RANGE BETWEEN 3 FOLLOWING AND 5 FOLLOWING)"),
         (
             Window.rowsBetween(Window.unboundedPreceding, 2),
             "OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND 2 FOLLOWING)",
         ),
         (
             Window.rowsBetween(1, Window.unboundedFollowing),
-            "OVER (ROWS BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING)",
+            "OVER (ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING)",
         ),
         (
             Window.rowsBetween(Window.unboundedPreceding, Window.unboundedFollowing),
             "OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)",
         ),
+        (
+            Window.rowsBetween(-1, Window.currentRow),
+            "OVER (ROWS BETWEEN 1 PRECEDING AND CURRENT ROW)",
+        ),
+        (
+            Window.rowsBetween(-1, 2),
+            "OVER (ROWS BETWEEN 1 PRECEDING AND 2 FOLLOWING)",
+        ),
+        (
+            Window.rowsBetween(-2, -1),
+            "OVER (ROWS BETWEEN 2 PRECEDING AND 1 PRECEDING)",
+        ),
         (
             Window.rangeBetween(Window.unboundedPreceding, 2),
             "OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND 2 FOLLOWING)",
         ),
         (
             Window.rangeBetween(1, Window.unboundedFollowing),
-            "OVER (RANGE BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING)",
+            "OVER (RANGE BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING)",
         ),
         (
             Window.rangeBetween(Window.unboundedPreceding, Window.unboundedFollowing),