self-review

Author: sfc-gh-pczajka

src/snowflake/connector/nanoarrow_cpp/ArrowIterator/CArrowTableIterator.cpp

@@ -657,7 +657,7 @@ void CArrowTableIterator::convertTimestampColumn_nanoarrow(
   ArrowArrayView* epochArray = nullptr;
   ArrowArrayView* fractionArray = nullptr;
   bool has_overflow_to_downscale = false;
-  if (field->type == NANOARROW_TYPE_STRUCT) {
+  if (scale > 6 && field->type == NANOARROW_TYPE_STRUCT) {
     for (int64_t i = 0; i < field->schema->n_children; i++) {
       ArrowSchema* c_schema = field->schema->children[i];
       if (std::strcmp(c_schema->name, internal::FIELD_NAME_EPOCH.c_str()) ==
@@ -670,10 +670,8 @@ void CArrowTableIterator::convertTimestampColumn_nanoarrow(
         // do nothing
       }
     }
-    if (scale > 6) {
-      has_overflow_to_downscale = _checkNanosecondTimestampOverflowAndDownscale(
-          columnArray, epochArray, fractionArray);
-    }
+    has_overflow_to_downscale = _checkNanosecondTimestampOverflowAndDownscale(
+        columnArray, epochArray, fractionArray);
   }
 
   if (scale <= 6) {

test/integ/pandas_it/test_arrow_pandas.py

@@ -1518,84 +1518,3 @@ def test_fetch_with_pandas_nullable_types(conn_cnx):
         df = cursor_table.fetch_pandas_all(types_mapper=dtype_mapping.get)
         pandas._testing.assert_series_equal(df.dtypes, expected_dtypes)
         assert df.to_string() == expected_df_to_string
-
-
-# @pytest.mark.parametrize(
-#     "timestamp_type", ["timestamp_ntz", "timestamp_ltz", "timestamp_tz"]
-# )
-# def test_convert_timestamp_overflow(conn_cnx, timestamp_type):
-#     """Test whether large timestamps are correctly falling back to microsecond precision."""
-
-#     def query(timestamp):
-#         if timestamp_type == "timestamp_tz":
-#             return f"SELECT CONVERT_TIMEZONE ('UTC', '{timestamp}') AS result"
-#         return f"SELECT '{timestamp}'::{timestamp_type} AS result"
-
-#     with conn_cnx() as cnx:
-#         cur = cnx.cursor()
-
-#         # Check that "large" dates are correctly falling back to microsecond precision
-#         cur.execute(query("2999-12-31 00:00:00.001234"))
-#         result = cur.fetchall()
-#         assert str(result[0][0]).startswith("2999-12-31 00:00:00.001234")
-#         result_pandas = cur.fetch_pandas_all()
-#         assert str(result_pandas.iloc[0, 0]).startswith("2999-12-31 00:00:00.001234")
-
-#         # Check that nanosecond precision is used for dates within the nanosecond range
-#         cur.execute(query("2000-12-31 00:00:00.001234567"))
-#         result_pandas = cur.fetch_arrow_all()
-#         result_pandas = cur.fetch_pandas_all()
-#         assert str(result_pandas.iloc[0, 0]).startswith("2999-12-31 00:00:00.001234")
-
-#         # Check that nanosecond precision used outside of nanosecond range throws an error
-#         cur.execute(query("2999-12-31 00:00:00.0012345678"))
-#         with pytest.raises(
-#             OverflowError,
-#             match=(
-#                 "If you use a timestamp with the nanosecond part over 6-digits in the Snowflake database, "
-#                 "the timestamp must be between '1677-09-21 00:12:43.145224192' and "
-#                 "'2262-04-11 23:47:16.854775807' to not overflow."
-#             ),
-#         ):
-#             cur.fetch_pandas_all()
-
-
-# def test_timestamp_ltz_overflow(conn_cnx):
-#     """Test TIMESTAMP_LTZ with microsecond fallback for year 2999.
-
-#     This test verifies that TIMESTAMP_LTZ dates beyond the nanosecond range automatically
-#     fall back to microsecond precision instead of failing.
-#     """
-#     with conn_cnx() as cnx:
-#         cur = cnx.cursor()
-#         cur.execute(SQL_ENABLE_ARROW)
-
-#         # Test with regular fetchone first - this should work fine
-#         result = cur.execute(
-#             "SELECT '2999-12-31 00:00:00.000'::timestamp_ltz AS result1"
-#         ).fetchone()
-#         # TIMESTAMP_LTZ will be converted to session timezone (UTC by default in tests)
-#         assert str(result[0]) == "2999-12-31 00:00:00+00:00"
-
-#         # Test with fetch_pandas_all - this should now work with microsecond fallback
-#         # instead of throwing an error or returning wrong data
-#         pandas_result = cur.execute(
-#             "SELECT '2999-12-31 00:00:00.000'::timestamp_ltz AS result1"
-#         ).fetch_pandas_all()
-
-#         # Check that we got a DataFrame with one row and one column
-#         assert pandas_result.shape == (1, 1)
-#         assert pandas_result.columns[0] == "RESULT1"
-
-#         # Check the actual timestamp value - should be correct year 2999
-#         timestamp_value = pandas_result.iloc[0, 0]
-#         assert str(timestamp_value) == "2999-12-31 00:00:00+00:00"
-
-#         # Test with a date within the nanosecond range (should use nanoseconds)
-#         pandas_result_2200 = cur.execute(
-#             "SELECT '2200-12-31 00:00:00.000'::timestamp_ltz AS result1"
-#         ).fetch_pandas_all()
-
-#         # Check that the date is correct
-#         timestamp_value_2200 = pandas_result_2200.iloc[0, 0]
-#         assert str(timestamp_value_2200) == "2200-12-31 00:00:00+00:00"