BUG: fix regressions on date-typed columns (#616)

Author: theroggy

CHANGES.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 0.12.1 (????-??-??)
+
+### Bug fixes
+
+-   Fix regression in reading date columns (#616)
+
 ## 0.12.0 (2025-11-26)
 
 ### Potentially breaking changes

pyogrio/_io.pyx

@@ -978,7 +978,7 @@ cdef process_fields(
 
         elif field_type == OFTDateTime or field_type == OFTDate:
 
-            if datetime_as_string:
+            if field_type == OFTDateTime and datetime_as_string:
                 # defer datetime parsing to user/ pandas layer
                 IF CTE_GDAL_VERSION >= (3, 7, 0):
                     data[i] = get_string(

pyogrio/geopandas.py

@@ -440,7 +440,12 @@ def read_dataframe(
 
         # convert datetime columns that were read as string to datetime
         for dtype, column in zip(meta["dtypes"], meta["fields"]):
-            if dtype is not None and dtype.startswith("datetime"):
+            # With arrow, date columns are returned as datetime.date objects.
+            if (
+                dtype is not None
+                and dtype.startswith("datetime")
+                and dtype != "datetime64[D]"
+            ):
                 df[column] = _try_parse_datetime(
                     df[column], datetime_as_string, mixed_offsets_as_utc
                 )

pyogrio/tests/conftest.py

@@ -336,6 +336,42 @@ def list_field_values_files(tmp_path, request):
         return list_field_values_parquet_file()
 
 
+@pytest.fixture(scope="function")
+def many_data_types_geojson_file(tmp_path):
+    # create GeoJSON file with properties of many data types
+    many_types_geojson = """{
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": [0, 0]
+                },
+                "properties": {
+                    "int_col": 1,
+                    "float_col": 1.5,
+                    "str_col": "string",
+                    "bool_col": true,
+                    "null_col": null,
+                    "date_col": "2020-01-01",
+                    "time_col": "12:00:00",
+                    "datetime_col": "2020-01-01T12:00:00",
+                    "list_int_col": [1, 2, 3],
+                    "list_str_col": ["a", "b", "c"],
+                    "list_mixed_col": [1, "a", null, true]
+                }
+            }
+        ]
+    }"""
+
+    filename = tmp_path / "test_many_data_types.geojson"
+    with open(filename, "w") as f:
+        _ = f.write(many_types_geojson)
+
+    return filename
+
+
 @pytest.fixture(scope="function")
 def nested_geojson_file(tmp_path):
     # create GeoJSON file with nested properties

pyogrio/tests/test_geopandas_io.py

@@ -51,7 +51,14 @@
     import geopandas as gp
     import pandas as pd
     from geopandas.array import from_wkt
-    from pandas.api.types import is_datetime64_dtype, is_object_dtype, is_string_dtype
+    from pandas.api.types import (
+        is_bool_dtype,
+        is_datetime64_dtype,
+        is_float_dtype,
+        is_integer_dtype,
+        is_object_dtype,
+        is_string_dtype,
+    )
 
     import shapely  # if geopandas is present, shapely is expected to be present
     from shapely.geometry import Point
@@ -515,6 +522,93 @@ def test_read_list_nested_struct_parquet_file(
     assert result["col_struct"][2] == {"a": 1, "b": 2}
 
 
+@pytest.mark.requires_arrow_write_api
+def test_roundtrip_many_data_types_geojson_file(
+    request, tmp_path, many_data_types_geojson_file, use_arrow
+):
+    """Test roundtripping a GeoJSON file containing many data types."""
+
+    def validate_result(df: pd.DataFrame, use_arrow: bool, ignore_mixed_list_col=False):
+        """Function to validate the data of many_data_types_geojson_file.
+
+        Depending on arrow being used or not there are small differences.
+        """
+        assert "int_col" in df.columns
+        assert is_integer_dtype(df["int_col"].dtype)
+        assert df["int_col"].to_list() == [1]
+
+        assert "float_col" in df.columns
+        assert is_float_dtype(df["float_col"].dtype)
+        assert df["float_col"].to_list() == [1.5]
+
+        assert "str_col" in df.columns
+        assert is_string_dtype(df["str_col"].dtype)
+        assert df["str_col"].to_list() == ["string"]
+
+        assert "bool_col" in df.columns
+        assert is_bool_dtype(df["bool_col"].dtype)
+        assert df["bool_col"].to_list() == [True]
+
+        assert "date_col" in df.columns
+        if use_arrow:
+            # Arrow returns dates as datetime.date objects.
+            assert is_object_dtype(df["date_col"].dtype)
+            assert df["date_col"].to_list() == [pd.Timestamp("2020-01-01").date()]
+        else:
+            # Without arrow, date columns are returned as datetime64.
+            assert is_datetime64_dtype(df["date_col"].dtype)
+            assert df["date_col"].to_list() == [pd.Timestamp("2020-01-01")]
+
+        # Ignore time columns till this is solved:
+        # Reported in https://github.com/geopandas/pyogrio/issues/615
+        # assert "time_col" in df.columns
+        # assert is_object_dtype(df["time_col"].dtype)
+        # assert df["time_col"].to_list() == [time(12, 0, 0)]
+
+        assert "datetime_col" in df.columns
+        assert is_datetime64_dtype(df["datetime_col"].dtype)
+        assert df["datetime_col"].to_list() == [pd.Timestamp("2020-01-01T12:00:00")]
+
+        assert "list_int_col" in df.columns
+        assert is_object_dtype(df["list_int_col"].dtype)
+        assert df["list_int_col"][0].tolist() == [1, 2, 3]
+
+        assert "list_str_col" in df.columns
+        assert is_object_dtype(df["list_str_col"].dtype)
+        assert df["list_str_col"][0].tolist() == ["a", "b", "c"]
+
+        if not ignore_mixed_list_col:
+            assert "list_mixed_col" in df.columns
+            assert is_object_dtype(df["list_mixed_col"].dtype)
+            assert df["list_mixed_col"][0] == [1, "a", None, True]
+
+    # Read and validate result of reading
+    read_gdf = read_dataframe(many_data_types_geojson_file, use_arrow=use_arrow)
+    validate_result(read_gdf, use_arrow)
+
+    # Write the data read, read it back, and validate again
+    if use_arrow:
+        # Writing a column with mixed types in a list is not supported with Arrow.
+        ignore_mixed_list_col = True
+        read_gdf = read_gdf.drop(columns=["list_mixed_col"])
+    else:
+        ignore_mixed_list_col = False
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="roundtripping list types fails with use_arrow=False"
+            )
+        )
+
+    tmp_file = tmp_path / "temp.geojson"
+    write_dataframe(read_gdf, tmp_file, use_arrow=use_arrow)
+
+    # Validate data written
+    read_back_gdf = read_dataframe(tmp_file, use_arrow=use_arrow)
+    validate_result(
+        read_back_gdf, use_arrow, ignore_mixed_list_col=ignore_mixed_list_col
+    )
+
+
 @pytest.mark.filterwarnings(
     "ignore: Non-conformant content for record 1 in column dates"
 )