SNOW-2022698: Rename the relaxed_ordering parameter into enforce_ordering

Author: sfc-gh-helmeleegy

src/snowflake/snowpark/dataframe.py

@@ -1283,7 +1283,7 @@ def to_snowpark_pandas(
         self,
         index_col: Optional[Union[str, List[str]]] = None,
         columns: Optional[List[str]] = None,
-        relaxed_ordering: bool = False,
+        enforce_ordering: bool = False,
         _emit_ast: bool = True,
     ) -> "modin.pandas.DataFrame":
         """
@@ -1293,7 +1293,7 @@ def to_snowpark_pandas(
             index_col: A column name or a list of column names to use as index.
             columns: A list of column names for the columns to select from the Snowpark DataFrame. If not specified, select
                 all columns except ones configured in index_col.
-            relaxed_ordering: If True, Snowpark pandas will provide relaxed consistency and ordering guarantees for the returned
+            enforce_ordering: If False, Snowpark pandas will provide relaxed consistency and ordering guarantees for the returned
                 DataFrame object. Otherwise, strict consistency and ordering guarantees are provided. Please refer to the
                 documentation of :func:`~modin.pandas.read_snowflake` for more details.
 
@@ -1378,7 +1378,7 @@ def to_snowpark_pandas(
             if columns is not None:
                 ast.columns.extend(columns if isinstance(columns, list) else [columns])
 
-        if not relaxed_ordering:
+        if enforce_ordering:
             # create a temporary table out of the current snowpark dataframe
             temporary_table_name = random_name_for_temp_object(
                 TempObjectType.TABLE
@@ -1399,14 +1399,14 @@ def to_snowpark_pandas(
         else:
             if len(self.queries["queries"]) > 1:
                 raise NotImplementedError(
-                    "Setting 'relaxed_ordering=True' in 'to_snowpark_pandas' is not supported when the input "
-                    "dataframe includes DDL or DML operations. Please use 'relaxed_ordering=False' instead."
+                    "Setting 'enforce_ordering=False' in 'to_snowpark_pandas' is not supported when the input "
+                    "dataframe includes DDL or DML operations. Please use 'enforce_ordering=True' instead."
                 )
             snowpandas_df = pd.read_snowflake(
                 name_or_query=self.queries["queries"][0],
                 index_col=index_col,
                 columns=columns,
-                relaxed_ordering=True,
+                enforce_ordering=False,
             )  # pragma: no cover
 
         if _emit_ast:

src/snowflake/snowpark/modin/plugin/_internal/utils.py

@@ -318,7 +318,7 @@ def _create_read_only_table(
 
 def create_initial_ordered_dataframe(
     table_name_or_query: Union[str, Iterable[str]],
-    relaxed_ordering: bool,
+    enforce_ordering: bool,
 ) -> tuple[OrderedDataFrame, str]:
     """
     create read only temp table on top of the existing table or Snowflake query if required, and create a OrderedDataFrame
@@ -327,7 +327,7 @@ def create_initial_ordered_dataframe(
     Args:
         table_name_or_query: A string or list of strings that specify the table name or
             fully-qualified object identifier (database name, schema name, and table name) or SQL query.
-        relaxed_ordering: If False, create a read only temp table on top of the existing table or Snowflake query,
+        enforce_ordering: If True, create a read only temp table on top of the existing table or Snowflake query,
             and create the OrderedDataFrame using the read only temp table created.
             Otherwise, directly using the existing table.
 
@@ -350,8 +350,8 @@ def create_initial_ordered_dataframe(
         table_name_or_query
     )
     is_query = not _is_table_name(table_name_or_query)
-    if not is_query or relaxed_ordering:
-        if not relaxed_ordering:
+    if not is_query or not enforce_ordering:
+        if enforce_ordering:
             try:
                 readonly_table_name = _create_read_only_table(
                     table_name=table_name_or_query,
@@ -406,7 +406,7 @@ def create_initial_ordered_dataframe(
 
         initial_ordered_dataframe = OrderedDataFrame(
             DataFrameReference(session.table(readonly_table_name, _emit_ast=False))
-            if not relaxed_ordering
+            if enforce_ordering
             else DataFrameReference(session.sql(table_name_or_query, _emit_ast=False))
             if is_query
             else DataFrameReference(session.table(table_name_or_query, _emit_ast=False))
@@ -424,7 +424,7 @@ def create_initial_ordered_dataframe(
 
         # create snowpark dataframe with columns: row_position_snowflake_quoted_identifier + snowflake_quoted_identifiers
         # if no snowflake_quoted_identifiers is specified, all columns will be selected
-        if not relaxed_ordering:
+        if enforce_ordering:
             row_position_column_str = f"{METADATA_ROW_POSITION_COLUMN} as {row_position_snowflake_quoted_identifier}"
         else:
             row_position_column_str = f"ROW_NUMBER() OVER (ORDER BY 1) - 1 as {row_position_snowflake_quoted_identifier}"
@@ -437,7 +437,7 @@ def create_initial_ordered_dataframe(
         # which creates a view without metadata column, we won't be able to access the metadata columns
         # with the created snowpark dataframe. In order to get the metadata column access in the created
         # dataframe, we create dataframe through sql which access the corresponding metadata column.
-        if not relaxed_ordering:
+        if enforce_ordering:
             dataframe_sql = f"SELECT {columns_to_select} FROM {readonly_table_name}"
         else:
             dataframe_sql = f"SELECT {columns_to_select} FROM ({table_name_or_query})"
@@ -454,7 +454,7 @@ def create_initial_ordered_dataframe(
             row_position_snowflake_quoted_identifier=row_position_snowflake_quoted_identifier,
         )
     else:
-        assert is_query and not relaxed_ordering
+        assert is_query and enforce_ordering
 
         # If the string passed in to `pd.read_snowflake` is a SQL query, we can simply create
         # a Snowpark DataFrame, and convert that to a Snowpark pandas DataFrame, and extract

src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py

@@ -1029,7 +1029,7 @@ def from_snowflake(
         name_or_query: Union[str, Iterable[str]],
         index_col: Optional[Union[str, list[str]]] = None,
         columns: Optional[list[str]] = None,
-        relaxed_ordering: bool = False,
+        enforce_ordering: bool = False,
     ) -> "SnowflakeQueryCompiler":
         """
         See detailed docstring and examples in ``read_snowflake`` in frontend layer:
@@ -1044,7 +1044,7 @@ def from_snowflake(
             row_position_snowflake_quoted_identifier,
         ) = create_initial_ordered_dataframe(
             table_name_or_query=name_or_query,
-            relaxed_ordering=relaxed_ordering,
+            enforce_ordering=enforce_ordering,
         )
         pandas_labels_to_snowflake_quoted_identifiers_map = {
             # pandas labels of resulting Snowpark pandas dataframe will be snowflake identifier
@@ -1228,7 +1228,7 @@ def is_names_set(kwargs: Any) -> bool:
             table_type="temporary",
             use_logical_type=True,
         )
-        qc = cls.from_snowflake(temporary_table_name, relaxed_ordering=False)
+        qc = cls.from_snowflake(temporary_table_name, enforce_ordering=True)
         return cls._post_process_file(qc, filetype="csv", **kwargs)
 
     @classmethod
@@ -1292,7 +1292,7 @@ def from_file_with_snowflake(
         )
 
         qc = cls.from_snowflake(
-            name_or_query=temporary_table_name, relaxed_ordering=False
+            name_or_query=temporary_table_name, enforce_ordering=True
         )
 
         return cls._post_process_file(qc=qc, filetype=filetype, **kwargs)

src/snowflake/snowpark/modin/plugin/extensions/pd_extensions.py

@@ -39,7 +39,7 @@ def read_snowflake(
     name_or_query: Union[str, Iterable[str]],
     index_col: Union[str, list[str], None] = None,
     columns: Optional[list[str]] = None,
-    relaxed_ordering: bool = False,
+    enforce_ordering: bool = False,
 ) -> DataFrame:
     """
     Read a Snowflake table or SQL Query to a Snowpark pandas DataFrame.
@@ -52,8 +52,8 @@ def read_snowflake(
             A column name or a list of column names to use as index.
         columns:
             A list of column names to select from the table. If not specified, select all columns.
-        relaxed_ordering:
-            If True, Snowpark pandas will provide relaxed consistency and ordering guarantees for the returned
+        enforce_ordering:
+            If False, Snowpark pandas will provide relaxed consistency and ordering guarantees for the returned
             DataFrame object. Otherwise, strict consistency and ordering guarantees are provided. See the Notes
             section for more details.
 
@@ -73,7 +73,7 @@ def read_snowflake(
 
         Snowpark pandas provides two modes of consistency and ordering semantics.
 
-        * When `relaxed_ordering` is set to True, Snowpark pandas provides relaxed consistency and ordering guarantees. In particular, the returned DataFrame object will be
+        * When `enforce_ordering` is set to False, Snowpark pandas provides relaxed consistency and ordering guarantees. In particular, the returned DataFrame object will be
           directly based on the source given by `name_or_query`. Consistency and isolation guarantees are relaxed in this case because any changes that happen to the source will be reflected in the
           DataFrame object returned by `pd.read_snowflake`.
 
@@ -87,7 +87,7 @@ def read_snowflake(
           Note that when `name_or_query` is a query with an ORDER BY clause, this will only guarantee that the immediate results of the input query are sorted. But it still gives no guarantees
           on the order of the final results (after applying a sequence of pandas operations to those initial results).
 
-        * When `relaxed_ordering` is set to False, Snowpark pandas provides the same consistency and ordering guarantees for `read_snowflake` as if local files were read.
+        * When `enforce_ordering` is set to True, Snowpark pandas provides the same consistency and ordering guarantees for `read_snowflake` as if local files were read.
           For example, calling `df.head(5)` two consecutive times is guaranteed to result in the exact same set of 5 rows each time and with the same ordering.
           Depending on the type of source, `pd.read_snowflake` will do one of the following
           at the time of calling `pd.read_snowflake`:
@@ -391,7 +391,7 @@ def read_snowflake(
             name_or_query,
             index_col=index_col,
             columns=columns,
-            relaxed_ordering=relaxed_ordering,
+            enforce_ordering=enforce_ordering,
         )
     )
 

src/snowflake/snowpark/modin/plugin/io/snow_io.py

@@ -212,14 +212,14 @@ def read_snowflake(
         name_or_query: Union[str, Iterable[str]],
         index_col: Optional[Union[str, list[str]]] = None,
         columns: Optional[list[str]] = None,
-        relaxed_ordering: bool = False,
+        enforce_ordering: bool = False,
     ):
         """
         See detailed docstring and examples in ``read_snowflake`` in frontend layer:
         src/snowflake/snowpark/modin/plugin/pd_extensions.py
         """
         return cls.query_compiler_cls.from_snowflake(
-            name_or_query, index_col, columns, relaxed_ordering=relaxed_ordering
+            name_or_query, index_col, columns, enforce_ordering=enforce_ordering
         )
 
     @classmethod

tests/integ/modin/frame/test_create_or_replace_dynamic_table.py

@@ -15,20 +15,20 @@
 
 
 @sql_count_checker(query_count=5)
-def test_create_or_replace_dynamic_table_no_relaxed_ordering_raises(session) -> None:
+def test_create_or_replace_dynamic_table_no_enforce_ordering_raises(session) -> None:
     try:
         # create table
         table_name = Utils.random_table_name()
         session.create_dataframe(
             [BASIC_TYPE_DATA1, BASIC_TYPE_DATA2]
         ).write.save_as_table(table_name)
 
-        # create dataframe with relaxed_ordering disabled
+        # create dataframe with enforce_ordering enabled
         snow_dataframe = pd.read_snowflake(
-            f"(((SELECT * FROM {table_name})))", relaxed_ordering=False
+            f"(((SELECT * FROM {table_name})))", enforce_ordering=True
         )
 
-        # creating dynamic_table fails when relaxed_ordering is disabled
+        # creating dynamic_table fails when enforce_ordering is enabled
         # because it cannot depend on a temp table
         dynamic_table_name = Utils.random_name_for_temp_object(
             TempObjectType.DYNAMIC_TABLE
@@ -49,20 +49,20 @@ def test_create_or_replace_dynamic_table_no_relaxed_ordering_raises(session) ->
 
 
 @sql_count_checker(query_count=5)
-def test_create_or_replace_dynamic_table_relaxed_ordering(session) -> None:
+def test_create_or_replace_dynamic_table_enforce_ordering(session) -> None:
     try:
         # create table
         table_name = Utils.random_table_name()
         session.create_dataframe(
             [BASIC_TYPE_DATA1, BASIC_TYPE_DATA2]
         ).write.save_as_table(table_name)
 
-        # create dataframe with relaxed_ordering enabled
+        # create dataframe with enforce_ordering disabled
         snow_dataframe = pd.read_snowflake(
-            f"(((SELECT * FROM {table_name})))", relaxed_ordering=True
+            f"(((SELECT * FROM {table_name})))", enforce_ordering=False
         )
 
-        # creating dynamic_table succeeds when relaxed_ordering is enabled
+        # creating dynamic_table succeeds when enforce_ordering is disabled
         dynamic_table_name = Utils.random_name_for_temp_object(
             TempObjectType.DYNAMIC_TABLE
         )
@@ -85,7 +85,7 @@ def test_create_or_replace_dynamic_table_relaxed_ordering(session) -> None:
 
 
 @sql_count_checker(query_count=4)
-def test_create_or_replace_dynamic_table_multiple_sessions_relaxed_ordering(
+def test_create_or_replace_dynamic_table_multiple_sessions_enforce_ordering(
     session,
     db_parameters,
 ) -> None:
@@ -96,12 +96,12 @@ def test_create_or_replace_dynamic_table_multiple_sessions_relaxed_ordering(
             [BASIC_TYPE_DATA1, BASIC_TYPE_DATA2]
         ).write.save_as_table(table_name)
 
-        # create dataframe with relaxed_ordering enabled
+        # create dataframe with enforce_ordering disabled
         snow_dataframe = pd.read_snowflake(
-            f"(((SELECT * FROM {table_name})))", relaxed_ordering=True
+            f"(((SELECT * FROM {table_name})))", enforce_ordering=False
         )
 
-        # creating dynamic_table succeeds when relaxed_ordering is enabled
+        # creating dynamic_table succeeds when enforce_ordering is disabled
         dynamic_table_name = Utils.random_name_for_temp_object(
             TempObjectType.DYNAMIC_TABLE
         )
@@ -140,9 +140,9 @@ def test_create_or_replace_dynamic_table_index(session, index, index_labels):
             [BASIC_TYPE_DATA1, BASIC_TYPE_DATA2]
         ).write.save_as_table(table_name)
 
-        # create dataframe with relaxed_ordering enabled
+        # create dataframe with enforce_ordering disabled
         snow_dataframe = pd.read_snowflake(
-            f"(((SELECT * FROM {table_name})))", relaxed_ordering=True
+            f"(((SELECT * FROM {table_name})))", enforce_ordering=False
         )
 
         dynamic_table_name = Utils.random_name_for_temp_object(
@@ -183,9 +183,9 @@ def test_create_or_replace_dynamic_table_multiindex(session):
             [BASIC_TYPE_DATA1, BASIC_TYPE_DATA2]
         ).write.save_as_table(table_name)
 
-        # create dataframe with relaxed_ordering enabled
+        # create dataframe with enforce_ordering disabled
         snow_dataframe = pd.read_snowflake(
-            f"(((SELECT * FROM {table_name})))", relaxed_ordering=True
+            f"(((SELECT * FROM {table_name})))", enforce_ordering=False
         )
 
         # make sure dataframe has a multi-index

tests/integ/modin/frame/test_create_or_replace_view.py

@@ -43,7 +43,7 @@ def test_create_or_replace_view_basic(session, native_pandas_df_basic) -> None:
 
 
 @sql_count_checker(query_count=6)
-def test_create_or_replace_view_multiple_sessions_no_relaxed_ordering_raises(
+def test_create_or_replace_view_multiple_sessions_no_enforce_ordering_raises(
     session,
     db_parameters,
 ) -> None:
@@ -54,9 +54,9 @@ def test_create_or_replace_view_multiple_sessions_no_relaxed_ordering_raises(
             [BASIC_TYPE_DATA1, BASIC_TYPE_DATA2]
         ).write.save_as_table(table_name)
 
-        # create dataframe with relaxed_ordering disabled
+        # create dataframe with enforce_ordering enabled
         snow_dataframe = pd.read_snowflake(
-            f"(((SELECT * FROM {table_name})))", relaxed_ordering=False
+            f"(((SELECT * FROM {table_name})))", enforce_ordering=True
         )
 
         # create view
@@ -70,7 +70,7 @@ def test_create_or_replace_view_multiple_sessions_no_relaxed_ordering_raises(
         new_session = Session.builder.configs(db_parameters).create()
         pd.session = session
 
-        # accessing the created view in another session fails when relaxed_ordering is disabled
+        # accessing the created view in another session fails when enforce_ordering is enabled
         with pytest.raises(
             SnowparkSQLException,
             match="Object 'VIEW_NAME' does not exist or not authorized",
@@ -86,7 +86,7 @@ def test_create_or_replace_view_multiple_sessions_no_relaxed_ordering_raises(
 
 
 @sql_count_checker(query_count=4)
-def test_create_or_replace_view_multiple_sessions_relaxed_ordering(
+def test_create_or_replace_view_multiple_sessions_enforce_ordering(
     session,
     db_parameters,
 ) -> None:
@@ -97,9 +97,9 @@ def test_create_or_replace_view_multiple_sessions_relaxed_ordering(
             [BASIC_TYPE_DATA1, BASIC_TYPE_DATA2]
         ).write.save_as_table(table_name)
 
-        # create dataframe with relaxed_ordering enabled
+        # create dataframe with enforce_ordering disabled
         snow_dataframe = pd.read_snowflake(
-            f"(((SELECT * FROM {table_name})))", relaxed_ordering=True
+            f"(((SELECT * FROM {table_name})))", enforce_ordering=False
         )
 
         # create view
@@ -113,7 +113,7 @@ def test_create_or_replace_view_multiple_sessions_relaxed_ordering(
         new_session = Session.builder.configs(db_parameters).create()
         pd.session = new_session
 
-        # accessing the created view in another session succeeds when relaxed_ordering is enabled
+        # accessing the created view in another session succeeds when enforce_ordering is disabled
         res = new_session.sql(f"select * from {view_name}").collect()
         assert len(res) == 2
         new_session.close()
@@ -136,9 +136,9 @@ def test_create_or_replace_view_index(session, index, index_labels):
             [BASIC_TYPE_DATA1, BASIC_TYPE_DATA2]
         ).write.save_as_table(table_name)
 
-        # create dataframe with relaxed_ordering enabled
+        # create dataframe with enforce_ordering disabled
         snow_dataframe = pd.read_snowflake(
-            f"(((SELECT * FROM {table_name})))", relaxed_ordering=True
+            f"(((SELECT * FROM {table_name})))", enforce_ordering=False
         )
 
         view_name = Utils.random_view_name()
@@ -173,9 +173,9 @@ def test_create_or_replace_view_multiindex(session):
             [BASIC_TYPE_DATA1, BASIC_TYPE_DATA2]
         ).write.save_as_table(table_name)
 
-        # create dataframe with relaxed_ordering enabled
+        # create dataframe with enforce_ordering disabled
         snow_dataframe = pd.read_snowflake(
-            f"(((SELECT * FROM {table_name})))", relaxed_ordering=True
+            f"(((SELECT * FROM {table_name})))", enforce_ordering=False
         )
 
         # make sure dataframe has a multi-index