sqlframe 3.26.0__tar.gz → 3.27.1__tar.gz

{sqlframe-3.26.0 → sqlframe-3.27.1}/PKG-INFO

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

{sqlframe-3.26.0 → sqlframe-3.27.1}/docs/duckdb.md

@@ -417,6 +417,7 @@ See something that you would like to see supported? [Open an issue](https://gith
 * [percent_rank](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.percent_rank.html)
 * [percentile](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.percentile.html)
 * [percentile_approx](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.percentile_approx.html)
+* [product](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.product.html)
 * [position](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.position.html)
 * [pow](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.pow.html)
 * [quarter](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.quarter.html)

{sqlframe-3.26.0 → sqlframe-3.27.1}/sqlframe/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.26.0'
-__version_tuple__ = version_tuple = (3, 26, 0)
+__version__ = version = '3.27.1'
+__version_tuple__ = version_tuple = (3, 27, 1)

{sqlframe-3.26.0 → sqlframe-3.27.1}/sqlframe/base/functions.py

@@ -4944,7 +4944,7 @@ def printf(format: ColumnOrName, *cols: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(format, "printf", *cols)
 
 
-@meta(unsupported_engines=["*", "spark", "databricks"])
+@meta(unsupported_engines=["bigquery", "postgres", "redshift", "snowflake", "spark", "databricks"])
 def product(col: ColumnOrName) -> Column:
     """
     Aggregate function: returns the product of the values in a group.

{sqlframe-3.26.0 → sqlframe-3.27.1}/sqlframe/base/readerwriter.py

@@ -38,6 +38,7 @@ class _BaseDataFrameReader(t.Generic[SESSION, DF, TABLE]):
     def __init__(self, spark: SESSION):
         self._session = spark
         self.state_format_to_read: t.Optional[str] = None
+        self.state_options: t.Dict[str, OptionalPrimitiveType] = {}
 
     @property
     def session(self) -> SESSION:
@@ -107,6 +108,88 @@ class _BaseDataFrameReader(t.Generic[SESSION, DF, TABLE]):
         self.state_format_to_read = source
         return self
 
+    def options(self, **options: OptionalPrimitiveType) -> "Self":
+        """Adds input options for the underlying data source.
+
+        .. versionadded:: 1.4.0
+
+        .. versionchanged:: 3.4.0
+            Supports Spark Connect.
+
+        Parameters
+        ----------
+        **options : dict
+            The dictionary of string keys and primitive-type values.
+
+        Examples
+        --------
+        >>> spark.read.options(inferSchema=True, header=True)
+        <...readwriter.DataFrameReader object ...>
+
+        Specify the option 'nullValue' and 'header' with reading a CSV file.
+
+        >>> import tempfile
+        >>> with tempfile.TemporaryDirectory() as d:
+        ...     # Write a DataFrame into a CSV file with a header.
+        ...     df = spark.createDataFrame([{"age": 100, "name": "Hyukjin Kwon"}])
+        ...     df.write.option("header", True).mode("overwrite").format("csv").save(d)
+        ...
+        ...     # Read the CSV file as a DataFrame with 'nullValue' option set to 'Hyukjin Kwon',
+        ...     # and 'header' option set to `True`.
+        ...     spark.read.options(
+        ...         nullValue="Hyukjin Kwon",
+        ...         header=True
+        ...     ).format('csv').load(d).show()
+        +---+----+
+        |age|name|
+        +---+----+
+        |100|NULL|
+        +---+----+
+        """
+
+        self.state_options = {**self.state_options, **options}
+        return self
+
+    def option(self, key: str, value: OptionalPrimitiveType) -> "Self":
+        """Adds an input option for the underlying data source.
+
+        .. versionadded:: 1.4.0
+
+        .. versionchanged:: 3.4.0
+            Supports Spark Connect.
+
+        Parameters
+        ----------
+        key : str
+            The key of the option.
+        value :
+            The value of the option.
+
+        Examples
+        --------
+        >>> spark.read.option("inferSchema", True)
+        <...readwriter.DataFrameReader object ...>
+
+        Specify the option 'nullValue' and 'header' with reading a CSV file.
+
+        >>> import tempfile
+        >>> with tempfile.TemporaryDirectory() as d:
+        ...     # Write a DataFrame into a CSV file with a header.
+        ...     df = spark.createDataFrame([{"age": 100, "name": "Hyukjin Kwon"}])
+        ...     df.write.option("header", True).mode("overwrite").format("csv").save(d)
+        ...
+        ...     # Read the CSV file as a DataFrame with 'nullValue' option set to 'Hyukjin Kwon',
+        ...     # and 'header' option set to `True`.
+        ...     spark.read.option("nullValue", "Hyukjin Kwon").option("header", True).format('csv').load(d).show()
+        +---+----+
+        |age|name|
+        +---+----+
+        |100|NULL|
+        +---+----+
+        """
+        self.state_options[key] = value
+        return self
+
     def load(
         self,
         path: t.Optional[PathOrPaths] = None,
@@ -220,7 +303,9 @@ class _BaseDataFrameReader(t.Generic[SESSION, DF, TABLE]):
             modifiedAfter=modifiedAfter,
             allowNonNumericNumbers=allowNonNumericNumbers,
         )
-        return self.load(path=path, format="json", schema=schema, **options)
+        # Apply previously set options, with method-specific options taking precedence
+        all_options = {**self.state_options, **{k: v for k, v in options.items() if v is not None}}
+        return self.load(path=path, format="json", schema=schema, **all_options)
 
     def parquet(self, *paths: str, **options: OptionalPrimitiveType) -> DF:
         """
@@ -263,7 +348,8 @@ class _BaseDataFrameReader(t.Generic[SESSION, DF, TABLE]):
         |100|Hyukjin Kwon|
         +---+------------+
         """
-        dfs = [self.load(path=path, format="parquet", **options) for path in paths]  # type: ignore
+        all_options = {**self.state_options, **{k: v for k, v in options.items() if v is not None}}
+        dfs = [self.load(path=path, format="parquet", **all_options) for path in paths]  # type: ignore
         return reduce(lambda a, b: a.union(b), dfs)
 
     def csv(
@@ -384,7 +470,9 @@ class _BaseDataFrameReader(t.Generic[SESSION, DF, TABLE]):
             modifiedAfter=modifiedAfter,
             unescapedQuoteHandling=unescapedQuoteHandling,
         )
-        return self.load(path=path, format="csv", schema=schema, **options)
+        # Apply previously set options, with method-specific options taking precedence
+        all_options = {**self.state_options, **{k: v for k, v in options.items() if v is not None}}
+        return self.load(path=path, format="csv", schema=schema, **all_options)
 
 
 class _BaseDataFrameWriter(t.Generic[SESSION, DF]):

{sqlframe-3.26.0 → sqlframe-3.27.1}/sqlframe/base/session.py

@@ -193,22 +193,21 @@ class _BaseSession(t.Generic[CATALOG, READER, WRITER, DF, TABLE, CONN, UDF_REGIS
     def getActiveSession(self) -> Self:
         return self
 
-    def range(self, *args):
-        start = 0
-        step = 1
-        numPartitions = None
-        if len(args) == 1:
-            end = args[0]
-        elif len(args) == 2:
-            start, end = args
-        elif len(args) == 3:
-            start, end, step = args
-        elif len(args) == 4:
-            start, end, step, numPartitions = args
-        else:
-            raise ValueError(
-                "range() takes 1 to 4 positional arguments but {} were given".format(len(args))
-            )
+    def range(
+        self,
+        start: int,
+        end: t.Optional[int] = None,
+        step: int = 1,
+        numPartitions: t.Optional[int] = None,
+    ):
+        # Ensure end is provided by either args or kwargs
+        if end is None:
+            if start:
+                end = start
+                start = 0
+            else:
+                raise ValueError("range() requires an 'end' value")
+
         if numPartitions is not None:
             logger.warning("numPartitions is not supported")
         return self.createDataFrame([[x] for x in range(start, end, step)], schema={"id": "long"})

{sqlframe-3.26.0 → sqlframe-3.27.1}/sqlframe/databricks/readwriter.py

@@ -94,11 +94,15 @@ class DatabricksDataFrameReader(
         """
         assert path is not None, "path is required"
         assert isinstance(path, str), "path must be a string"
+
+        # Merge state_options with provided options, with provided options taking precedence
+        merged_options = {**self.state_options, **options}
+
         format = format or self.state_format_to_read or _infer_format(path)
         fs_prefix, filepath = split_filepath(path)
 
         if fs_prefix == "":
-            return super().load(path, format, schema, **options)
+            return super().load(path, format, schema, **merged_options)
 
         if schema:
             column_mapping = ensure_column_mapping(schema)
@@ -116,7 +120,7 @@ class DatabricksDataFrameReader(
             paths = ",".join([f"{path}" for path in ensure_list(path)])
 
             format_options: dict[str, OptionalPrimitiveType] = {
-                k: v for k, v in options.items() if v is not None
+                k: v for k, v in merged_options.items() if v is not None
             }
             format_options["format"] = format
             format_options["schemaEvolutionMode"] = "none"
@@ -137,7 +141,7 @@ class DatabricksDataFrameReader(
             qualify=False,
         )
         if select_columns == [exp.Star()] and df.schema:
-            return self.load(path=path, format=format, schema=df.schema, **options)
+            return self.load(path=path, format=format, schema=df.schema, **merged_options)
         self.session._last_loaded_file = path  # type: ignore
         return df
 

{sqlframe-3.26.0 → sqlframe-3.27.1}/sqlframe/duckdb/functions.pyi

@@ -148,6 +148,7 @@ from sqlframe.base.functions import percentile_approx as percentile_approx
 from sqlframe.base.functions import position as position
 from sqlframe.base.functions import pow as pow
 from sqlframe.base.functions import power as power
+from sqlframe.base.functions import product as product
 from sqlframe.base.functions import quarter as quarter
 from sqlframe.base.functions import radians as radians
 from sqlframe.base.functions import rand as rand

{sqlframe-3.26.0 → sqlframe-3.27.1}/sqlframe/duckdb/readwriter.py

@@ -75,31 +75,34 @@ class DuckDBDataFrameReader(
         |100|NULL|
         +---+----+
         """
+        # Merge state_options with provided options, with provided options taking precedence
+        merged_options = {**self.state_options, **options}
+
         format = format or self.state_format_to_read
         if schema:
             column_mapping = ensure_column_mapping(schema)
             select_column_mapping = column_mapping.copy()
-            if options.get("filename"):
+            if merged_options.get("filename"):
                 select_column_mapping["filename"] = "VARCHAR"
             select_columns = [x.expression for x in self._to_casted_columns(select_column_mapping)]
             if format == "csv":
                 duckdb_columns = ", ".join(
                     [f"'{column}': '{dtype}'" for column, dtype in column_mapping.items()]
                 )
-                options["columns"] = "{" + duckdb_columns + "}"
+                merged_options["columns"] = "{" + duckdb_columns + "}"
         else:
             select_columns = [exp.Star()]
         if format == "delta":
             from_clause = f"delta_scan('{path}')"
         elif format:
-            options.pop("inferSchema", None)
+            merged_options.pop("inferSchema", None)
             paths = ",".join([f"'{path}'" for path in ensure_list(path)])
-            from_clause = f"read_{format}([{paths}], {to_csv(options)})"
+            from_clause = f"read_{format}([{paths}], {to_csv(merged_options)})"
         else:
             from_clause = f"'{path}'"
         df = self.session.sql(exp.select(*select_columns).from_(from_clause), qualify=False)
         if select_columns == [exp.Star()]:
-            return self.load(path=path, format=format, schema=df.schema, **options)
+            return self.load(path=path, format=format, schema=df.schema, **merged_options)
         self.session._last_loaded_file = path  # type: ignore
         return df
 

{sqlframe-3.26.0 → sqlframe-3.27.1}/sqlframe/spark/readwriter.py

@@ -78,6 +78,10 @@ class SparkDataFrameReader(
         """
         assert path is not None, "path is required"
         assert isinstance(path, str), "path must be a string"
+
+        # Merge state_options with provided options, with provided options taking precedence
+        merged_options = {**self.state_options, **options}
+
         format = format or self.state_format_to_read or _infer_format(path)
         if schema:
             column_mapping = ensure_column_mapping(schema)
@@ -93,11 +97,13 @@ class SparkDataFrameReader(
             from_clause = f"delta.`{path}`"
         elif format:
             paths = ",".join([f"{path}" for path in ensure_list(path)])
-            tmp_view_key = options.get("_tmp_view_key_", f"{generate_random_identifier()}_vw")
-            options["_tmp_view_key_"] = tmp_view_key
+            tmp_view_key = merged_options.get(
+                "_tmp_view_key_", f"{generate_random_identifier()}_vw"
+            )
+            merged_options["_tmp_view_key_"] = tmp_view_key
 
             format_options: dict[str, OptionalPrimitiveType] = {
-                k: v for k, v in options.items() if v is not None
+                k: v for k, v in merged_options.items() if v is not None
             }
             format_options.pop("_tmp_view_key_")
             format_options["path"] = paths
@@ -121,7 +127,7 @@ class SparkDataFrameReader(
             qualify=False,
         )
         if select_columns == [exp.Star()] and df.schema:
-            return self.load(path=path, format=format, schema=df.schema, **options)
+            return self.load(path=path, format=format, schema=df.schema, **merged_options)
         self.session._last_loaded_file = path  # type: ignore
         return df
 

{sqlframe-3.26.0 → sqlframe-3.27.1}/sqlframe.egg-info/PKG-INFO

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

{sqlframe-3.26.0 → sqlframe-3.27.1}/sqlframe.egg-info/SOURCES.txt

@@ -41,13 +41,9 @@ docs/docs/duckdb.md
 docs/docs/postgres.md
 docs/docs/images/SF.png
 docs/docs/images/favicon.png
-docs/docs/images/favicon_old.png
-docs/docs/images/sqlframe_diagram.png
 docs/docs/images/sqlframe_logo.png
 docs/images/SF.png
 docs/images/favicon.png
-docs/images/favicon_old.png
-docs/images/sqlframe_diagram.png
 docs/images/sqlframe_logo.png
 docs/stylesheets/extra.css
 sqlframe/LICENSE
@@ -359,6 +355,7 @@ tests/integration/engines/spark/test_spark_dataframe.py
 tests/unit/__init__.py
 tests/unit/conftest.py
 tests/unit/test_activate.py
+tests/unit/test_base_reader_options.py
 tests/unit/test_util.py
 tests/unit/bigquery/__init__.py
 tests/unit/bigquery/test_activate.py
@@ -366,6 +363,7 @@ tests/unit/databricks/__init__.py
 tests/unit/databricks/test_activate.py
 tests/unit/duck/__init__.py
 tests/unit/duck/test_activate.py
+tests/unit/duck/test_reader_options.py
 tests/unit/postgres/__init__.py
 tests/unit/postgres/test_activate.py
 tests/unit/redshift/__init__.py
@@ -374,6 +372,7 @@ tests/unit/snowflake/__init__.py
 tests/unit/snowflake/test_activate.py
 tests/unit/spark/__init__.py
 tests/unit/spark/test_activate.py
+tests/unit/spark/test_reader_options.py
 tests/unit/standalone/__init__.py
 tests/unit/standalone/fixtures.py
 tests/unit/standalone/test_activate.py

sqlframe-3.27.1/tests/unit/duck/test_reader_options.py

@@ -0,0 +1,116 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from sqlframe.base.readerwriter import _BaseDataFrameReader
+from sqlframe.duckdb import DuckDBDataFrameReader
+
+
+@pytest.fixture
+def mock_duckdb_session():
+    """Create a mock DuckDBSession for testing."""
+    session = MagicMock()
+    session.input_dialect = "duckdb"
+    session.sql = MagicMock()
+    session._last_loaded_file = None
+    return session
+
+
+@pytest.fixture
+def reader(mock_duckdb_session):
+    """Create a DataFrameReader instance for testing."""
+    return DuckDBDataFrameReader(mock_duckdb_session)
+
+
+def test_options_initialization(reader):
+    """Test that options are correctly initialized."""
+    assert reader.state_options == {}
+
+
+def test_options_method(reader):
+    """Test that the options method correctly stores options."""
+    reader.options(inferSchema=True, header=True)
+    assert reader.state_options == {"inferSchema": True, "header": True}
+
+
+def test_option_method(reader):
+    """Test that the option method correctly stores a single option."""
+    reader.option("inferSchema", True)
+    assert reader.state_options == {"inferSchema": True}
+
+
+def test_options_and_option_methods_together(reader):
+    """Test that option and options methods can be used together."""
+    reader.options(inferSchema=True, header=True)
+    reader.option("delimiter", ",")
+    assert reader.state_options == {"inferSchema": True, "header": True, "delimiter": ","}
+
+
+def test_options_override(reader):
+    """Test that options override previous values with the same key."""
+    reader.options(inferSchema=True, header=True)
+    reader.options(inferSchema=False, nullValue="NULL")
+    assert reader.state_options == {"inferSchema": False, "header": True, "nullValue": "NULL"}
+
+
+def test_option_override(reader):
+    """Test that option overrides previous values with the same key."""
+    reader.option("inferSchema", True)
+    reader.option("inferSchema", False)
+    assert reader.state_options == {"inferSchema": False}
+
+
+@patch.object(DuckDBDataFrameReader, "load")
+def test_csv_uses_options(mock_load, reader):
+    """Test that the csv method uses the stored options."""
+    # Setup
+    mock_load.return_value = MagicMock()
+    reader.options(inferSchema=True, header=True, delimiter=",")
+
+    # Execute
+    reader.csv("test.csv", sep="|")
+
+    # Assert
+    call_args = mock_load.call_args
+    assert call_args.kwargs["format"] == "csv"
+    assert call_args.kwargs["path"] == "test.csv"
+    assert call_args.kwargs["inferSchema"] is True
+    assert call_args.kwargs["header"] is True
+    assert call_args.kwargs["sep"] == "|"  # Method-specific overrides global
+    assert call_args.kwargs["delimiter"] == ","
+
+
+@patch.object(DuckDBDataFrameReader, "load")
+def test_parquet_uses_options(mock_load, reader):
+    """Test that the parquet method uses the stored options."""
+    # Setup
+    mock_load.return_value = MagicMock()
+    reader.options(compression="snappy", row_group_size=1000)
+
+    # Execute
+    reader.parquet("test.parquet")
+
+    # Assert
+    call_args = mock_load.call_args
+    assert call_args.kwargs["format"] == "parquet"
+    assert call_args.kwargs["path"] == "test.parquet"
+    assert call_args.kwargs["compression"] == "snappy"
+    assert call_args.kwargs["row_group_size"] == 1000
+
+
+@patch.object(DuckDBDataFrameReader, "load")
+def test_method_specific_options_override_global_options(mock_load, reader):
+    """Test that method-specific options override global options."""
+    # Setup
+    mock_load.return_value = MagicMock()
+    reader.options(header=True, delimiter=",")
+
+    # Execute
+    reader.csv("test.csv", header=False)
+
+    # Assert
+    call_args = mock_load.call_args
+    assert call_args.kwargs["header"] is False  # Method-specific overrides global
+    assert call_args.kwargs["delimiter"] == ","
+    assert call_args.kwargs["format"] == "csv"
+    assert call_args.kwargs["path"] == "test.csv"

sqlframe-3.27.1/tests/unit/spark/test_reader_options.py

@@ -0,0 +1,152 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from sqlframe.base.readerwriter import _BaseDataFrameReader
+from sqlframe.spark import SparkDataFrameReader, SparkSession
+
+
+@pytest.fixture
+def mock_spark_session():
+    """Create a mock SparkSession for testing."""
+    session = MagicMock()
+    session.input_dialect = "spark"
+    session.spark_session = MagicMock()
+    session.sql = MagicMock()
+    session._last_loaded_file = None
+    return session
+
+
+@pytest.fixture
+def reader(mock_spark_session):
+    """Create a DataFrameReader instance for testing."""
+    return SparkDataFrameReader(mock_spark_session)
+
+
+def test_options_initialization(reader):
+    """Test that options are correctly initialized."""
+    assert reader.state_options == {}
+
+
+def test_options_method(reader):
+    """Test that the options method correctly stores options."""
+    reader.options(inferSchema=True, header=True)
+    assert reader.state_options == {"inferSchema": True, "header": True}
+
+
+def test_option_method(reader):
+    """Test that the option method correctly stores a single option."""
+    reader.option("inferSchema", True)
+    assert reader.state_options == {"inferSchema": True}
+
+
+def test_options_and_option_methods_together(reader):
+    """Test that option and options methods can be used together."""
+    reader.options(inferSchema=True, header=True)
+    reader.option("delimiter", ",")
+    assert reader.state_options == {"inferSchema": True, "header": True, "delimiter": ","}
+
+
+def test_options_override(reader):
+    """Test that options override previous values with the same key."""
+    reader.options(inferSchema=True, header=True)
+    reader.options(inferSchema=False, nullValue="NULL")
+    assert reader.state_options == {"inferSchema": False, "header": True, "nullValue": "NULL"}
+
+
+def test_option_override(reader):
+    """Test that option overrides previous values with the same key."""
+    reader.option("inferSchema", True)
+    reader.option("inferSchema", False)
+    assert reader.state_options == {"inferSchema": False}
+
+
+@patch("sqlframe.spark.readwriter.SparkDataFrameReader.load")
+def test_json_uses_options(mock_load, reader):
+    """Test that the json method uses the stored options."""
+    reader.options(inferSchema=True, header=True)
+    reader.json("test.json")
+
+    # Get the actual call arguments from the mock
+    # The call_args is a tuple (args, kwargs)
+    call_args = mock_load.call_args
+
+    # Check that the method was called with the correct options
+    assert call_args.kwargs["inferSchema"] is True
+    assert call_args.kwargs["header"] is True
+    assert call_args.kwargs["format"] == "json"
+    assert call_args.kwargs["path"] == "test.json"
+
+
+@patch("sqlframe.spark.readwriter.SparkDataFrameReader.load")
+def test_csv_uses_options(mock_load, reader):
+    """Test that the csv method uses the stored options."""
+    reader.options(inferSchema=True, header=True)
+    reader.csv("test.csv", comment="TEST_COMMENT")
+
+    # Get the actual call arguments from the mock
+    call_args = mock_load.call_args
+
+    # Check that the method was called with the correct options
+    assert call_args.kwargs["inferSchema"] is True
+    assert call_args.kwargs["header"] is True
+    assert call_args.kwargs["comment"] == "TEST_COMMENT"
+    assert call_args.kwargs["format"] == "csv"
+    assert call_args.kwargs["path"] == "test.csv"
+
+
+@patch("sqlframe.spark.readwriter.SparkDataFrameReader.load")
+def test_parquet_uses_options(mock_load, reader):
+    """Test that the parquet method uses the stored options."""
+    reader.options(inferSchema=True)
+    reader.parquet("test.parquet")
+
+    # Get the actual call arguments from the mock
+    call_args = mock_load.call_args
+
+    # Check that the method was called with the correct options
+    assert call_args.kwargs["inferSchema"] is True
+    assert call_args.kwargs["format"] == "parquet"
+    assert call_args.kwargs["path"] == "test.parquet"
+
+
+@patch("sqlframe.spark.readwriter.SparkDataFrameReader.load")
+def test_method_specific_options_override_global_options(mock_load, reader):
+    """Test that method-specific options override global options."""
+    reader.options(inferSchema=True, header=True)
+    reader.csv("test.csv", inferSchema=False, sep="|")
+
+    # Get the actual call arguments from the mock
+    call_args = mock_load.call_args
+
+    # Check that the method was called with the correct options
+    # Method-specific options should take precedence
+    assert call_args.kwargs["inferSchema"] is False
+    assert call_args.kwargs["header"] is True
+    assert call_args.kwargs["sep"] == "|"
+    assert call_args.kwargs["format"] == "csv"
+    assert call_args.kwargs["path"] == "test.csv"
+
+
+def test_load_merges_options(reader):
+    """Test that the load method merges options from state_options."""
+    reader.options(inferSchema=True, header=True)
+
+    # Need to patch at a different level since we're testing the actual load method
+    with patch.object(reader.session, "sql") as mock_sql:
+        mock_sql.return_value = MagicMock()
+        mock_sql.return_value.schema = None
+
+        reader.load("test.csv", format="csv", nullValue="NULL")
+
+        # Get the actual SQL that would be executed
+        # The SQL should include the options from both state_options and method arguments
+        mock_session_sql_call = reader.session.spark_session.sql.call_args[0][0]
+
+        # Check that all options are included in the SQL
+        assert "inferSchema" in mock_session_sql_call
+        assert "header" in mock_session_sql_call
+        assert "nullValue" in mock_session_sql_call
+        assert "path" in mock_session_sql_call
+        assert "USING csv" in mock_session_sql_call
+        assert "test.csv" in mock_session_sql_call