You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iceberg.apache.org by at...@apache.org on 2026/06/18 16:05:24 UTC
(iceberg-go) branch main updated: feat(table): WKB encoding + GeoArrow conversion for geometry/geography (#1138)
This is an automated email from the ASF dual-hosted git repository.
laskoviymishka pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/iceberg-go.git
The following commit(s) were added to refs/heads/main by this push:
new 38d0d12b feat(table): WKB encoding + GeoArrow conversion for geometry/geography (#1138)
38d0d12b is described below
commit 38d0d12bb30ee7e701c412bbc4f7483e631c6b63
Author: David Zhao <14...@users.noreply.github.com>
AuthorDate: Thu Jun 18 09:05:19 2026 -0700
feat(table): WKB encoding + GeoArrow conversion for geometry/geography (#1138)
Fixes #991.
Added metadata support in arrow_utils.go, created a `WKTToWKB` helper in
`table/internal/geo_codec.go` which uses
[go-geom](https://github.com/twpayne/go-geom) to convert WKT to WKB, and
added a round trip Arrow to Parquet test which tests if geoarrow
extension metadata survives. Also tests Iceberg schema to Arrow schema
round trips.
---------
Signed-off-by: happydave1 <dz...@gmail.com>
---
go.mod | 1 +
go.sum | 10 +
table/arrow_utils.go | 179 +++++++++++++-
table/arrow_utils_test.go | 457 +++++++++++++++++++++++++++++++++++
table/internal/geo_codec_test.go | 101 ++++++++
table/internal/parquet_files_test.go | 96 ++++++++
6 files changed, 838 insertions(+), 6 deletions(-)
diff --git a/go.mod b/go.mod
index 2d0fd976..fcd8d0cd 100644
--- a/go.mod
+++ b/go.mod
@@ -47,6 +47,7 @@ require (
github.com/testcontainers/testcontainers-go/modules/compose v0.42.0
github.com/twmb/avro v1.7.2
github.com/twmb/murmur3 v1.1.8
+ github.com/twpayne/go-geom v1.6.1
github.com/uptrace/bun v1.2.18
github.com/uptrace/bun/dialect/mssqldialect v1.2.18
github.com/uptrace/bun/dialect/mysqldialect v1.2.18
diff --git a/go.sum b/go.sum
index 2570d1dc..f3929406 100644
--- a/go.sum
+++ b/go.sum
@@ -52,6 +52,8 @@ github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1 h1:WJ
github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1/go.mod h1:tCcJZ0uHAmvjsVYzEFivsRTN00oz5BEsRgQHu5JZ9WE=
github.com/AzureAD/microsoft-authentication-library-for-go v1.7.2 h1:RHK7bS+HQMslb1sZpAokUt+zTVmue0hKSs2C791hhzU=
github.com/AzureAD/microsoft-authentication-library-for-go v1.7.2/go.mod h1:HKpQxkWaGLJ+D/5H8QRpyQXA1eKjxkFlOMwck5+33Jk=
+github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
+github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
github.com/DefangLabs/secret-detector v0.0.0-20250403165618-22662109213e h1:rd4bOvKmDIx0WeTv9Qz+hghsgyjikFiPrseXHlKepO0=
github.com/DefangLabs/secret-detector v0.0.0-20250403165618-22662109213e/go.mod h1:blbwPQh4DTlCZEfk1BLU4oMIhLda2U+A840Uag9DsZw=
github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.31.0 h1:DHa2U07rk8syqvCge0QIGMCE1WxGj9njT44GH7zNJLQ=
@@ -81,6 +83,10 @@ github.com/RoaringBitmap/roaring/v2 v2.18.2 h1:oPq3Cgx//iDuJQVp6xSInAKW34J9CEwE5
github.com/RoaringBitmap/roaring/v2 v2.18.2/go.mod h1:eq4wdNXxtJIS/oikeCzdX1rBzek7ANzbth041hrU8Q4=
github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d h1:licZJFw2RwpHMqeKTCYkitsPqHNxTmd4SNR5r94FGM8=
github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d/go.mod h1:asat636LX7Bqt5lYEZ27JNDcqxfjdBQuJ/MM4CN/Lzo=
+github.com/alecthomas/assert/v2 v2.10.0 h1:jjRCHsj6hBJhkmhznrCzoNpbA3zqy0fYiUcYZP/GkPY=
+github.com/alecthomas/assert/v2 v2.10.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
+github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
+github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
github.com/alexflint/go-arg v1.6.1 h1:uZogJ6VDBjcuosydKgvYYRhh9sRCusjOvoOLZopBlnA=
github.com/alexflint/go-arg v1.6.1/go.mod h1:nQ0LFYftLJ6njcaee0sU+G0iS2+2XJQfA8I062D0LGc=
github.com/alexflint/go-scalar v1.2.0 h1:WR7JPKkeNpnYIOfHRa7ivM21aWAdHD0gEWHCx+WQBRw=
@@ -388,6 +394,8 @@ github.com/hashicorp/go-version v1.9.0 h1:CeOIz6k+LoN3qX9Z0tyQrPtiB1DFYRPfCIBtaX
github.com/hashicorp/go-version v1.9.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
github.com/in-toto/attestation v1.1.2 h1:MBFn6lsMq6dptQZJBhalXTcWMb/aJy3V+GX3VYj/V1E=
github.com/in-toto/attestation v1.1.2/go.mod h1:gYFddHMZj3DiQ0b62ltNi1Vj5rC879bTmBbrv9CRHpM=
github.com/in-toto/in-toto-golang v0.11.0 h1:nfidMYBFx+E0lnmX5KUnN2Pdm8zdNKal1ayjJuzzRoA=
@@ -620,6 +628,8 @@ github.com/twmb/avro v1.7.2 h1:cmrEBRSbELRqsg/dRkQvVWuOaR2EfGifHIt/2iJ9lfI=
github.com/twmb/avro v1.7.2/go.mod h1:X0fT1dY2xcbV4YuCE4mYro+qljHl4kUF5uA/2z1rgSk=
github.com/twmb/murmur3 v1.1.8 h1:8Yt9taO/WN3l08xErzjeschgZU2QSrwm1kclYq+0aRg=
github.com/twmb/murmur3 v1.1.8/go.mod h1:Qq/R7NUyOfr65zD+6Q5IHKsJLwP7exErjN6lyyq3OSQ=
+github.com/twpayne/go-geom v1.6.1 h1:iLE+Opv0Ihm/ABIcvQFGIiFBXd76oBIar9drAwHFhR4=
+github.com/twpayne/go-geom v1.6.1/go.mod h1:Kr+Nly6BswFsKM5sd31YaoWS5PeDDH2NftJTK7Gd028=
github.com/uptrace/bun v1.2.18 h1:3HnRcMfS6OBPMG1eSOzlbFJ/X/AyMEJb7rMxE6VQvDU=
github.com/uptrace/bun v1.2.18/go.mod h1:wNltaKJk4JtOt4SG5I5zmA7v0/Mzjh1+/S906Rayd3Y=
github.com/uptrace/bun/dialect/mssqldialect v1.2.18 h1:nYzHoyJKJlIyl5i95Exi8ZTK8ooKWG+o3z3f404d/yQ=
diff --git a/table/arrow_utils.go b/table/arrow_utils.go
index 5d2d197e..b9e60d15 100644
--- a/table/arrow_utils.go
+++ b/table/arrow_utils.go
@@ -18,12 +18,15 @@
package table
import (
+ "bytes"
"context"
"encoding/base64"
"encoding/json"
+ "errors"
"fmt"
"iter"
"log/slog"
+ "regexp"
"slices"
"strconv"
"strings"
@@ -375,6 +378,17 @@ func (c convertToIceberg) Primitive(dt arrow.DataType) (result iceberg.NestedFie
result.Type = iceberg.PrimitiveTypes.UUID
case "parquet.variant":
result.Type = iceberg.VariantType{}
+ case "geoarrow.wkb":
+ wkb, ok := dt.(*geoarrow.WKBType)
+ if !ok {
+ panic(fmt.Errorf("%w: unsupported arrow type for conversion - %s", iceberg.ErrInvalidSchema, dt))
+ }
+
+ iceType, err := geoArrowMetadataToIcebergType(wkb.Metadata())
+ if err != nil {
+ panic(fmt.Errorf("%w: converting geoarrow metadata: %w", iceberg.ErrInvalidSchema, err))
+ }
+ result.Type = iceType
default:
panic(fmt.Errorf("%w: unsupported arrow type for conversion - %s", iceberg.ErrInvalidSchema, dt))
}
@@ -658,20 +672,26 @@ func (c convertToArrow) VisitVariant() arrow.Field {
return arrow.Field{Type: extensions.NewDefaultVariantType()}
}
-func (c convertToArrow) VisitGeometry(iceberg.GeometryType) arrow.Field {
+func (c convertToArrow) VisitGeometry(g iceberg.GeometryType) arrow.Field {
+ meta := icebergCRSToGeoArrowMetadata(g.CRS())
if c.useLargeTypes {
- return arrow.Field{Type: geoarrow.NewWKBType(geoarrow.WKBWithLargeBinaryStorage())}
+ return arrow.Field{Type: geoarrow.NewWKBType(geoarrow.WKBWithLargeBinaryStorage(), geoarrow.WKBWithMetadata(meta))}
}
- return arrow.Field{Type: geoarrow.NewWKBType(geoarrow.WKBWithBinaryStorage())}
+ return arrow.Field{Type: geoarrow.NewWKBType(geoarrow.WKBWithBinaryStorage(), geoarrow.WKBWithMetadata(meta))}
}
-func (c convertToArrow) VisitGeography(iceberg.GeographyType) arrow.Field {
+func (c convertToArrow) VisitGeography(g iceberg.GeographyType) arrow.Field {
+ meta := icebergCRSToGeoArrowMetadata(g.CRS())
+ // Always add an edge to differentiate between Geography and Geometry arrow fields.
+ // Note that the edge convention is a best-effort hint and planar geography from other clients won't round-trip through Arrow alone.
+ meta.Edges = geoarrow.EdgeInterpolation(g.Algorithm())
+
if c.useLargeTypes {
- return arrow.Field{Type: geoarrow.NewWKBType(geoarrow.WKBWithLargeBinaryStorage())}
+ return arrow.Field{Type: geoarrow.NewWKBType(geoarrow.WKBWithLargeBinaryStorage(), geoarrow.WKBWithMetadata(meta))}
}
- return arrow.Field{Type: geoarrow.NewWKBType(geoarrow.WKBWithBinaryStorage())}
+ return arrow.Field{Type: geoarrow.NewWKBType(geoarrow.WKBWithBinaryStorage(), geoarrow.WKBWithMetadata(meta))}
}
var _ iceberg.SchemaVisitorPerPrimitiveType[arrow.Field] = convertToArrow{}
@@ -1826,3 +1846,150 @@ func positionDeleteRecordsToDataFilesDV(ctx context.Context, rootLocation string
}
}
}
+
+func checkCRSString(rawCrs json.RawMessage) bool {
+ b := bytes.TrimSpace(rawCrs)
+
+ return len(b) > 0 && b[0] == '"'
+}
+
+func checkCRSJSON(rawCrs json.RawMessage) bool {
+ b := bytes.TrimSpace(rawCrs)
+
+ return len(b) > 0 && b[0] == '{'
+}
+
+func geoArrowCRSToIcebergCRS(meta geoarrow.Metadata) (string, error) {
+ if len(meta.CRS) == 0 {
+ return "srid:0", nil
+ }
+
+ switch {
+ case checkCRSString(meta.CRS):
+ var crs string
+
+ if err := json.Unmarshal(meta.CRS, &crs); err != nil {
+ return "", fmt.Errorf("invalid geoarrow CRS metadata: %w", err)
+ }
+
+ if strings.EqualFold(crs, "OGC:CRS84") || strings.EqualFold(crs, "EPSG:4326") {
+ return "OGC:CRS84", nil
+ }
+
+ switch meta.CRSType {
+ case geoarrow.CRSTypeSRID:
+ return "srid:" + crs, nil
+ case geoarrow.CRSTypeWKT22019:
+ return "", errors.New("CRS type wkt2:2019 not supported")
+ default:
+ if len(crs) <= 32 {
+ return crs, nil
+ }
+
+ return "", errors.New("crs length too long")
+ }
+ case checkCRSJSON(meta.CRS):
+ var crs map[string]json.RawMessage
+
+ if err := json.Unmarshal(meta.CRS, &crs); err != nil {
+ return "", fmt.Errorf("invalid geoarrow CRS metadata: %w", err)
+ }
+
+ idRaw, ok := crs["id"]
+ if !ok || len(idRaw) == 0 {
+ return "", errors.New("unsupported CRS")
+ }
+
+ var id map[string]json.RawMessage
+ if err := json.Unmarshal(idRaw, &id); err != nil {
+ return "", errors.New("unsupported CRS")
+ }
+
+ var authority string
+ if err := json.Unmarshal(id["authority"], &authority); err != nil || authority == "" {
+ return "", errors.New("unsupported CRS")
+ }
+
+ codeRaw := id["code"]
+ if len(codeRaw) == 0 {
+ return "", errors.New("unsupported CRS")
+ }
+
+ var code string
+ if err := json.Unmarshal(codeRaw, &code); err != nil {
+ var codeNum json.Number
+ if err := json.Unmarshal(codeRaw, &codeNum); err != nil {
+ return "", errors.New("unsupported CRS")
+ }
+ code = codeNum.String()
+ }
+ if code == "" {
+ return "", errors.New("unsupported CRS")
+ }
+
+ authorityCode := authority + ":" + code
+ if strings.EqualFold(authorityCode, "OGC:CRS84") || strings.EqualFold(authorityCode, "EPSG:4326") {
+ return "OGC:CRS84", nil
+ }
+
+ return authorityCode, nil
+ default:
+ return "", errors.New("unsupported CRS: CRS must either be omitted, a string, or a JSON object")
+ }
+}
+
+func geoArrowMetadataToIcebergType(meta geoarrow.Metadata) (iceberg.Type, error) {
+ crs, err := geoArrowCRSToIcebergCRS(meta)
+ if err != nil {
+ return nil, err
+ }
+
+ switch meta.Edges {
+ case geoarrow.EdgePlanar:
+ return iceberg.GeometryTypeOf(crs)
+ case geoarrow.EdgeVincenty, geoarrow.EdgeKarney, geoarrow.EdgeThomas, geoarrow.EdgeAndoyer, geoarrow.EdgeSpherical:
+ return iceberg.GeographyTypeOf(crs, string(meta.Edges))
+ default:
+ return nil, fmt.Errorf("unsupported geoarrow edges %q", meta.Edges)
+ }
+}
+
+var authorityCodeCRS = regexp.MustCompile(`^[A-Za-z][A-Za-z0-9_-]*:[A-Za-z0-9_.-]+$`)
+
+func icebergCRSToGeoArrowMetadata(crs string) geoarrow.Metadata {
+ lowerCRS := strings.ToLower(crs)
+ if strings.HasPrefix(lowerCRS, "srid:") {
+ id := crs[len("srid:"):]
+
+ if id == "0" {
+ return geoarrow.NewMetadata() // srid:0 maps to omitted GeoArrow CRS
+ }
+
+ raw, _ := json.Marshal(id) //nolint:errcheck // Marshalling a string can't fail
+
+ return geoarrow.Metadata{
+ CRS: raw,
+ CRSType: geoarrow.CRSTypeSRID,
+ }
+ }
+
+ if strings.HasPrefix(lowerCRS, "projjson:") {
+ panic(fmt.Errorf("%w: projjson CRS not supported yet", iceberg.ErrInvalidSchema))
+ }
+
+ var raw []byte
+
+ if lowerCRS == "epsg:4326" {
+ // collapse EPSG:4326 to OGC:CRS84
+ raw, _ = json.Marshal("OGC:CRS84") //nolint:errcheck // Marshalling a string can't fail
+ } else {
+ raw, _ = json.Marshal(crs) //nolint:errcheck // Marshalling a string can't fail
+ }
+
+ meta := geoarrow.Metadata{CRS: raw}
+ if authorityCodeCRS.MatchString(crs) {
+ meta.CRSType = geoarrow.CRSTypeAuthorityCode
+ }
+
+ return meta
+}
diff --git a/table/arrow_utils_test.go b/table/arrow_utils_test.go
index 07d17fd7..3e5f9926 100644
--- a/table/arrow_utils_test.go
+++ b/table/arrow_utils_test.go
@@ -35,6 +35,7 @@ import (
"github.com/apache/arrow-go/v18/parquet/variant"
"github.com/apache/iceberg-go"
"github.com/apache/iceberg-go/table"
+ "github.com/geoarrow/geoarrow-go"
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -430,6 +431,462 @@ func TestVariantArrowConversion(t *testing.T) {
})
}
+func assertGeoArrowWKB(t *testing.T, dt arrow.DataType, storage arrow.DataType, want geoarrow.Metadata) {
+ t.Helper()
+
+ wkb, ok := dt.(*geoarrow.WKBType)
+ require.True(t, ok, "expected *geoarrow.WKBType, got %T", dt)
+ assert.Equal(t, "geoarrow.wkb", wkb.ExtensionName())
+ assert.True(t, arrow.TypeEqual(storage, wkb.StorageType()))
+ assert.Equal(t, want.CRS, wkb.Metadata().CRS)
+ assert.Equal(t, want.Edges, wkb.Metadata().Edges)
+}
+
+func assertGeoArrowWKBMetadataJSON(t *testing.T, dt arrow.DataType, storage arrow.DataType, wantJSON string) {
+ t.Helper()
+
+ wkb, ok := dt.(*geoarrow.WKBType)
+ require.True(t, ok, "expected *geoarrow.WKBType, got %T", dt)
+ assert.Equal(t, "geoarrow.wkb", wkb.ExtensionName())
+ assert.True(t, arrow.TypeEqual(storage, wkb.StorageType()))
+
+ var want map[string]json.RawMessage
+ require.NoError(t, json.Unmarshal([]byte(wantJSON), &want))
+
+ meta := wkb.Metadata()
+
+ if wantCRS, ok := want["crs"]; ok {
+ assert.JSONEq(t, string(wantCRS), string(meta.CRS), "crs mismatch")
+ } else {
+ assert.Empty(t, meta.CRS, "expected omitted crs")
+ }
+
+ if wantEdges, ok := want["edges"]; ok {
+ var edges string
+ require.NoError(t, json.Unmarshal(wantEdges, &edges))
+ assert.Equal(t, geoarrow.EdgeInterpolation(edges), meta.Edges, "edges mismatch")
+ } else {
+ assert.Empty(t, meta.Edges, "expected omitted edges")
+ }
+}
+
+func jsonCRS(s string) json.RawMessage {
+ raw, _ := json.Marshal(s)
+
+ return raw
+}
+
+func TestIcebergGeoTypesToArrowSchema(t *testing.T) {
+ geomSRID, err := iceberg.GeometryTypeOf("srid:4326")
+ require.NoError(t, err)
+ geogKarney, err := iceberg.GeographyTypeOf("srid:4269", "karney")
+ require.NoError(t, err)
+ geomSRID0, err := iceberg.GeometryTypeOf("srid:0")
+ require.NoError(t, err)
+ geomEPSG4267, err := iceberg.GeometryTypeOf("EPSG:4267")
+ require.NoError(t, err)
+ geogSpherical, err := iceberg.GeographyTypeOf("OGC:CRS84", "spherical")
+ require.NoError(t, err)
+ geogKarneyDefaultCRS, err := iceberg.GeographyTypeOf("OGC:CRS84", "karney")
+ require.NoError(t, err)
+ geogVincenty, err := iceberg.GeographyTypeOf("OGC:CRS84", "vincenty")
+ require.NoError(t, err)
+ geogAndoyer, err := iceberg.GeographyTypeOf("OGC:CRS84", "andoyer")
+ require.NoError(t, err)
+ geogThomas, err := iceberg.GeographyTypeOf("OGC:CRS84", "thomas")
+ require.NoError(t, err)
+ geogSRID0, err := iceberg.GeographyTypeOf("srid:0", "spherical")
+ require.NoError(t, err)
+ geogEPSG4267, err := iceberg.GeographyTypeOf("EPSG:4267", "spherical")
+ require.NoError(t, err)
+ defaultGeometry, err := iceberg.GeometryTypeOf("OGC:CRS84")
+ require.NoError(t, err)
+ geomEPSG3857, err := iceberg.GeometryTypeOf("EPSG:3857")
+ require.NoError(t, err)
+ geogEPSG4267Karney, err := iceberg.GeographyTypeOf("EPSG:4267", "karney")
+ require.NoError(t, err)
+
+ typeCases := []struct {
+ name string
+ ice iceberg.Type
+ geoarrowMetaJSON string
+ }{
+ // Note that these tests below are based on arrow-rs tests (https://github.com/apache/arrow-rs/pull/10065)
+ // Geometry with default CRS (defaults to OGC:CRS84 per Parquet spec)
+ {
+ name: "geometry_default_crs",
+ ice: iceberg.GeometryType{},
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84"}`,
+ },
+ // Geometry with srid:0 should result in an unset (omitted) CRS
+ {
+ name: "geometry_srid_0",
+ ice: geomSRID0,
+ geoarrowMetaJSON: `{}`,
+ },
+ // Geometry with custom CRSes (authority:code and partial projjson)
+ {
+ name: "geometry_epsg_4267",
+ ice: geomEPSG4267,
+ geoarrowMetaJSON: `{"crs":"EPSG:4267"}`,
+ },
+ // Geography with default CRS (default OGC:CRS84, spherical edges)
+ {
+ name: "geography_default_crs",
+ ice: iceberg.GeographyType{},
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84","edges":"spherical"}`,
+ },
+ // Geography with explicit edges
+ {
+ name: "geography_explicit_spherical",
+ ice: geogSpherical,
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84","edges":"spherical"}`,
+ },
+ {
+ name: "geography_karney",
+ ice: geogKarneyDefaultCRS,
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84","edges":"karney"}`,
+ },
+ {
+ name: "geography_vincenty",
+ ice: geogVincenty,
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84","edges":"vincenty"}`,
+ },
+ {
+ name: "geography_andoyer",
+ ice: geogAndoyer,
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84","edges":"andoyer"}`,
+ },
+ {
+ name: "geography_thomas",
+ ice: geogThomas,
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84","edges":"thomas"}`,
+ },
+ // Geography with srid:0 should result in an unset (omitted) CRS and spherical edges
+ {
+ name: "geography_srid_0",
+ ice: geogSRID0,
+ geoarrowMetaJSON: `{"edges":"spherical"}`,
+ },
+ // Geography with custom CRSes (authority:code and partial projjson)
+ {
+ name: "geography_epsg_4267",
+ ice: geogEPSG4267,
+ geoarrowMetaJSON: `{"crs":"EPSG:4267","edges":"spherical"}`,
+ },
+ // Happy path SRID
+ {
+ name: "geometry_srid_4326",
+ ice: geomSRID,
+ geoarrowMetaJSON: `{"crs":"4326", "crs_type":"srid"}`,
+ },
+ }
+
+ // The following tests focus on edge cases and pinning specific behavior for read case
+ readOnlyCases := []struct {
+ name string
+ ice iceberg.Type
+ geoarrowMetaJSON string
+ }{
+ {
+ name: "geometry_srid_0_with_crs_type",
+ ice: geomSRID0,
+ geoarrowMetaJSON: `{"crs_type":"authority_code"}`,
+ },
+ {
+ name: "case_insensitive_default_geometry",
+ ice: defaultGeometry,
+ geoarrowMetaJSON: `{"crs":"OgC:cRs84"}`,
+ },
+ {
+ name: "case_insensitive_default_geometry_epsg_4326",
+ ice: defaultGeometry,
+ geoarrowMetaJSON: `{"crs":"EpSg:4326"}`,
+ },
+ {
+ name: "geometry_epsg_4326",
+ ice: defaultGeometry,
+ geoarrowMetaJSON: `{"crs":"epsg:4326"}`,
+ },
+ {
+ name: "geometry_epsg_4326_incorrect_type",
+ ice: defaultGeometry,
+ geoarrowMetaJSON: `{"crs":"epsg:4326", "crs_type":"projjson"}`,
+ },
+
+ // Translated from arrow-rs geo logical type read tests (https://github.com/apache/arrow-rs/pull/10065)
+ // Geometry with no CRS should be GEOMETRY(srid:0)
+ {
+ name: "geometry_no_crs",
+ ice: geomSRID0,
+ geoarrowMetaJSON: `{}`,
+ },
+ // Geometry with string CRS
+ {
+ name: "geometry_epsg_4267_from_crs",
+ ice: geomEPSG4267,
+ geoarrowMetaJSON: `{"crs":"EPSG:4267"}`,
+ },
+ // Geometry with PROJJSON CRS
+ {
+ name: "geometry_projjson_epsg_3857",
+ ice: geomEPSG3857,
+ geoarrowMetaJSON: `{"crs":{"id":{"authority":"EPSG","code":3857}}}`,
+ },
+ // Geometry with lon/lat CRSes (canonically removed because lon/lat is the
+ // default Iceberg CRS)
+ {
+ name: "geometry_ogc_crs84_canonical",
+ ice: iceberg.GeometryType{},
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84"}`,
+ },
+ {
+ name: "geometry_epsg_4326_canonical",
+ ice: iceberg.GeometryType{},
+ geoarrowMetaJSON: `{"crs":"EPSG:4326"}`,
+ },
+ {
+ name: "geometry_projjson_epsg_4326_canonical",
+ ice: iceberg.GeometryType{},
+ geoarrowMetaJSON: `{"crs":{"id":{"authority":"EPSG","code":4326}}}`,
+ },
+ {
+ name: "geometry_projjson_epsg_4326_string_code_canonical",
+ ice: iceberg.GeometryType{},
+ geoarrowMetaJSON: `{"crs":{"id":{"authority":"EPSG","code":"4326"}}}`,
+ },
+ {
+ name: "geometry_projjson_ogc_crs84_canonical",
+ ice: iceberg.GeometryType{},
+ geoarrowMetaJSON: `{"crs":{"id":{"authority":"OGC","code":"CRS84"}}}`,
+ },
+ // Geography with no CRS, spherical edges
+ {
+ name: "geography_no_crs_spherical",
+ ice: geogSRID0,
+ geoarrowMetaJSON: `{"edges":"spherical"}`,
+ },
+ // Geography with OGC:CRS84 and spherical edges
+ {
+ name: "geography_ogc_crs84_spherical_canonical",
+ ice: iceberg.GeographyType{},
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84","edges":"spherical"}`,
+ },
+ // Geography with different edge algorithms
+ {
+ name: "geography_ogc_crs84_karney",
+ ice: geogKarneyDefaultCRS,
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84","edges":"karney"}`,
+ },
+ {
+ name: "geography_ogc_crs84_vincenty",
+ ice: geogVincenty,
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84","edges":"vincenty"}`,
+ },
+ {
+ name: "geography_ogc_crs84_andoyer",
+ ice: geogAndoyer,
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84","edges":"andoyer"}`,
+ },
+ {
+ name: "geography_ogc_crs84_thomas",
+ ice: geogThomas,
+ geoarrowMetaJSON: `{"crs":"OGC:CRS84","edges":"thomas"}`,
+ },
+ // Geography with custom CRS and edges
+ {
+ name: "geography_epsg_4267_karney",
+ ice: geogEPSG4267Karney,
+ geoarrowMetaJSON: `{"crs":"EPSG:4267","edges":"karney"}`,
+ },
+ // Geography with PROJJSON CRS
+ {
+ name: "geography_projjson_epsg_4267_spherical",
+ ice: geogEPSG4267,
+ geoarrowMetaJSON: `{"crs":{"id":{"authority":"EPSG","code":4267}},"edges":"spherical"}`,
+ },
+ }
+
+ for _, tt := range typeCases {
+ t.Run("iceberg_to_arrow/"+tt.name, func(t *testing.T) {
+ result, err := table.TypeToArrowType(tt.ice, true, false)
+ require.NoError(t, err)
+ assertGeoArrowWKBMetadataJSON(t, result, arrow.BinaryTypes.Binary, tt.geoarrowMetaJSON)
+ })
+ }
+
+ for _, tt := range typeCases {
+ t.Run("iceberg_to_arrow_round_trip/"+tt.name, func(t *testing.T) {
+ arrowType, err := table.TypeToArrowType(tt.ice, true, false)
+ require.NoError(t, err)
+
+ iceType, err := table.ArrowTypeToIceberg(arrowType, false)
+ require.NoError(t, err)
+ assert.True(t, tt.ice.Equals(iceType), "expected %s, got %s", tt.ice, iceType)
+ })
+ }
+
+ for _, tt := range append(typeCases, readOnlyCases...) {
+ t.Run("arrow_to_iceberg/"+tt.name, func(t *testing.T) {
+ arrowType, err := geoarrow.NewWKBType().Deserialize(arrow.BinaryTypes.Binary, tt.geoarrowMetaJSON)
+ require.NoError(t, err)
+
+ iceType, err := table.ArrowTypeToIceberg(arrowType, false)
+ require.NoError(t, err)
+ assert.True(t, tt.ice.Equals(iceType), "expected %s, got %s", tt.ice, iceType)
+ })
+ }
+
+ t.Run("type/geometry_vs_geography_edge_differentiation", func(t *testing.T) {
+ geomResult, err := table.TypeToArrowType(iceberg.GeometryType{}, true, false)
+ require.NoError(t, err)
+ geogResult, err := table.TypeToArrowType(iceberg.GeographyType{}, true, false)
+ require.NoError(t, err)
+
+ geomWKB, ok := geomResult.(*geoarrow.WKBType)
+ require.True(t, ok)
+ geogWKB, ok := geogResult.(*geoarrow.WKBType)
+ require.True(t, ok)
+
+ assert.Equal(t, geoarrow.EdgePlanar, geomWKB.Metadata().Edges)
+ assert.Equal(t, geoarrow.EdgeSpherical, geogWKB.Metadata().Edges)
+ })
+
+ t.Run("large_binary_storage", func(t *testing.T) {
+ result, err := table.TypeToArrowType(iceberg.GeometryType{}, true, true)
+ require.NoError(t, err)
+ assertGeoArrowWKB(t, result, arrow.BinaryTypes.LargeBinary, geoarrow.Metadata{CRS: jsonCRS("OGC:CRS84")})
+ })
+
+ t.Run("epsg_4326_behavior", func(t *testing.T) {
+ geom, err := iceberg.GeometryTypeOf("EPSG:4326")
+ require.NoError(t, err)
+
+ geomResult, err := table.TypeToArrowType(geom, true, false)
+ require.NoError(t, err)
+
+ geomWKB, ok := geomResult.(*geoarrow.WKBType)
+ assert.True(t, ok)
+
+ meta := geomWKB.Metadata()
+ assert.Equal(t, meta.CRS, jsonCRS("OGC:CRS84"))
+ assert.Equal(t, meta.Edges, geoarrow.EdgePlanar)
+ assert.Equal(t, meta.CRSType, geoarrow.CRSTypeAuthorityCode)
+
+ roundTripGeom, err := table.ArrowTypeToIceberg(geomWKB, false)
+ require.NoError(t, err)
+
+ g, ok := roundTripGeom.(iceberg.GeometryType)
+ require.True(t, ok)
+
+ assert.Equal(t, g.CRS(), "OGC:CRS84")
+ assert.Equal(t, g, defaultGeometry)
+ })
+
+ t.Run("projjson_error_behavior", func(t *testing.T) {
+ geom, err := iceberg.GeometryTypeOf("projjson:my-custom-crs")
+ require.NoError(t, err)
+
+ _, err = table.TypeToArrowType(geom, true, false)
+ require.Error(t, err)
+ require.ErrorContains(t, err, "projjson CRS not supported yet")
+
+ arrowType, err := geoarrow.NewWKBType().Deserialize(arrow.BinaryTypes.Binary,
+ `{"crs_type":"projjson","crs":{"id":{"authority":"OGC", "code":"CRS84"}}}`)
+ require.NoError(t, err)
+
+ g, err := table.ArrowTypeToIceberg(arrowType, false)
+ require.NoError(t, err)
+ assert.Equal(t, g, defaultGeometry)
+ })
+
+ t.Run("wkt2:2019_error_behavior", func(t *testing.T) {
+ arrowType, err := geoarrow.NewWKBType().Deserialize(arrow.BinaryTypes.Binary,
+ `{"crs_type":"wkt2:2019","crs":"GEOGCRS[\"WGS 84\",DATUM[\"World Geodetic System 1984\",ELLIPSOID[\"WGS 84\",6378137,298.257223563]],CS[ellipsoidal,2],AXIS[\"geodetic latitude (Lat)\",north],AXIS[\"geodetic longitude (Lon)\",east],ID[\"EPSG\",4326]]"}`)
+ require.NoError(t, err)
+
+ _, err = table.ArrowTypeToIceberg(arrowType, false)
+ require.Error(t, err)
+ require.ErrorContains(t, err, "CRS type wkt2:2019 not supported")
+
+ arrowTypeWithoutCRSType, err := geoarrow.NewWKBType().Deserialize(arrow.BinaryTypes.Binary,
+ `{"crs":"GEOGCRS[\"WGS 84\",DATUM[\"World Geodetic System 1984\",ELLIPSOID[\"WGS 84\",6378137,298.257223563]],CS[ellipsoidal,2],AXIS[\"geodetic latitude (Lat)\",north],AXIS[\"geodetic longitude (Lon)\",east],ID[\"EPSG\",4326]]"}`)
+ require.NoError(t, err)
+
+ _, err = table.ArrowTypeToIceberg(arrowTypeWithoutCRSType, false)
+ require.Error(t, err)
+ require.ErrorContains(t, err, "crs length too long")
+ })
+
+ t.Run("schema", func(t *testing.T) {
+ geomList, err := iceberg.GeometryTypeOf("srid:4326")
+ require.NoError(t, err)
+
+ iceSchema := iceberg.NewSchema(0,
+ iceberg.NestedField{ID: 1, Name: "point", Type: iceberg.GeometryType{}, Required: false},
+ iceberg.NestedField{ID: 2, Name: "loc", Type: geomSRID, Required: true},
+ iceberg.NestedField{ID: 3, Name: "area", Type: iceberg.GeographyType{}, Required: false},
+ iceberg.NestedField{ID: 4, Name: "region", Type: geogKarney, Required: false},
+ iceberg.NestedField{
+ ID: 5,
+ Name: "locations",
+ Type: &iceberg.ListType{
+ ElementID: 6,
+ Element: geomList,
+ ElementRequired: true,
+ },
+ Required: true,
+ },
+ )
+
+ arrowSc, err := table.SchemaToArrowSchema(iceSchema, nil, true, false)
+ require.NoError(t, err)
+ require.Equal(t, 5, arrowSc.NumFields())
+
+ wantFields := []struct {
+ name string
+ nullable bool
+ fieldID string
+ wantMeta geoarrow.Metadata
+ }{
+ {"point", true, "1", geoarrow.Metadata{CRS: jsonCRS("OGC:CRS84")}},
+ {"loc", false, "2", geoarrow.Metadata{CRS: jsonCRS("4326"), CRSType: geoarrow.CRSTypeSRID}},
+ {"area", true, "3", geoarrow.Metadata{CRS: jsonCRS("OGC:CRS84"), Edges: geoarrow.EdgeSpherical}},
+ {"region", true, "4", geoarrow.Metadata{CRS: jsonCRS("4269"), CRSType: geoarrow.CRSTypeSRID, Edges: geoarrow.EdgeKarney}},
+ }
+
+ for i, want := range wantFields {
+ field := arrowSc.Field(i)
+ assert.Equal(t, want.name, field.Name)
+ assert.Equal(t, want.nullable, field.Nullable)
+ fieldID, ok := field.Metadata.GetValue(table.ArrowParquetFieldIDKey)
+ require.True(t, ok)
+ assert.Equal(t, want.fieldID, fieldID)
+ assertGeoArrowWKB(t, field.Type, arrow.BinaryTypes.Binary, want.wantMeta)
+ }
+
+ listField := arrowSc.Field(4)
+ assert.Equal(t, "locations", listField.Name)
+ assert.False(t, listField.Nullable)
+ listFieldID, ok := listField.Metadata.GetValue(table.ArrowParquetFieldIDKey)
+ require.True(t, ok)
+ assert.Equal(t, "5", listFieldID)
+ listType, ok := listField.Type.(*arrow.ListType)
+ require.True(t, ok, "expected list type, got %T", listField.Type)
+
+ elemField := listType.ElemField()
+ assert.Equal(t, "element", elemField.Name)
+ assert.False(t, elemField.Nullable)
+ elemFieldID, ok := elemField.Metadata.GetValue(table.ArrowParquetFieldIDKey)
+ require.True(t, ok)
+ assert.Equal(t, "6", elemFieldID)
+ assertGeoArrowWKB(t, elemField.Type, arrow.BinaryTypes.Binary, geoarrow.Metadata{
+ CRS: jsonCRS("4326"),
+ CRSType: geoarrow.CRSTypeSRID,
+ })
+ })
+}
+
func TestVariantArrayBuilderLargeValues(t *testing.T) {
mem := memory.NewCheckedAllocator(memory.DefaultAllocator)
defer mem.AssertSize(t, 0)
diff --git a/table/internal/geo_codec_test.go b/table/internal/geo_codec_test.go
new file mode 100644
index 00000000..e8d43067
--- /dev/null
+++ b/table/internal/geo_codec_test.go
@@ -0,0 +1,101 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package internal_test
+
+import (
+ "errors"
+ "fmt"
+ "testing"
+
+ "github.com/geoarrow/geoarrow-go"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "github.com/twpayne/go-geom/encoding/wkb"
+ "github.com/twpayne/go-geom/encoding/wkt"
+)
+
+// wktToWKB is a helper which converts Well Known Text (WKT) to Well Known Bytes (WKB).
+// Note that return bytes are little endian.
+func wktToWKB(s string) (geoarrow.WKBBytes, error) {
+ geometry, err := wkt.Unmarshal(s)
+ if err != nil {
+ return nil, fmt.Errorf("parse WKT: %w", err)
+ }
+
+ wkbBytes, err := wkb.Marshal(geometry, wkb.NDR) // little endian
+ if err != nil {
+ return nil, fmt.Errorf("parse WKT: %w", err)
+ }
+
+ return geoarrow.WKBBytes(wkbBytes), nil
+}
+
+func TestWKTToWKB(t *testing.T) {
+ tests := []struct {
+ name string
+ wkt string
+ wantWKB string
+ wantErr error
+ }{
+ {
+ name: "point",
+ wkt: "POINT (30 10)",
+ wantWKB: "01010000000000000000003e400000000000002440",
+ },
+ {
+ name: "linestring",
+ wkt: "LINESTRING (30 10, 10 30, 40 40)",
+ wantWKB: "0102000000030000000000000000003e40000000000000244000000000000024400000000000003e4000000000000044400000000000004440",
+ },
+ {
+ name: "polygon",
+ wkt: "POLYGON ((30 10, 40 40, 20 40, 10 20, 30 10))",
+ wantWKB: "010300000001000000050000000000000000003e4000000000000024400000000000004440000000000000444000000000000034400000000000004440000000000000244000000000000034400000000000003e400000000000002440",
+ },
+ {
+ name: "multipoint",
+ wkt: "MULTIPOINT ((10 40), (40 30), (20 20), (30 20))",
+ wantWKB: "010400000004000000010100000000000000000024400000000000004440010100000000000000000044400000000000003e4001010000000000000000003440000000000000344001010000000000000000003e400000000000003440",
+ },
+ {
+ name: "geometry_collection",
+ wkt: "GEOMETRYCOLLECTION (POINT (4 6), LINESTRING (4 6, 7 10))",
+ wantWKB: "010700000002000000010100000000000000000010400000000000001840010200000002000000000000000000104000000000000018400000000000001c400000000000002440",
+ },
+ {
+ name: "unknown wkt",
+ wkt: "POINT (30 10",
+ wantErr: errors.New("parse WKT: syntax error: unexpected $end, expecting ')'"),
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, err := wktToWKB(tt.wkt)
+ if tt.wantErr != nil {
+ require.Error(t, err)
+ assert.ErrorContains(t, err, tt.wantErr.Error())
+
+ return
+ }
+
+ require.NoError(t, err)
+ assert.Equal(t, tt.wantWKB, got.String())
+ })
+ }
+}
diff --git a/table/internal/parquet_files_test.go b/table/internal/parquet_files_test.go
index 4e9d381a..d7c0d301 100644
--- a/table/internal/parquet_files_test.go
+++ b/table/internal/parquet_files_test.go
@@ -40,6 +40,7 @@ import (
internal2 "github.com/apache/iceberg-go/internal"
"github.com/apache/iceberg-go/table"
"github.com/apache/iceberg-go/table/internal"
+ "github.com/geoarrow/geoarrow-go"
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -603,6 +604,101 @@ func TestDecimalPhysicalTypes(t *testing.T) {
}
}
+func TestParquetGeoArrowExtensionMetadataRoundTrip(t *testing.T) {
+ geomType, err := iceberg.GeometryTypeOf("srid:4326")
+ require.NoError(t, err)
+
+ geogType, err := iceberg.GeographyTypeOf("srid:4326", "vincenty")
+ require.NoError(t, err)
+
+ iceSchema := iceberg.NewSchema(0,
+ iceberg.NestedField{ID: 1, Name: "id", Type: iceberg.PrimitiveTypes.Int32, Required: false},
+ iceberg.NestedField{ID: 2, Name: "geom", Type: geomType, Required: false},
+ iceberg.NestedField{ID: 3, Name: "geog", Type: geogType, Required: false},
+ )
+
+ arrowSchema, err := table.SchemaToArrowSchema(iceSchema, nil, true, false)
+ require.NoError(t, err)
+
+ geomWKB, err := wktToWKB("POINT (30 10)")
+ require.NoError(t, err)
+ geogWKB, err := wktToWKB("POINT (20 5)")
+ require.NoError(t, err)
+
+ rec, _, err := array.RecordFromJSON(memory.DefaultAllocator, arrowSchema, strings.NewReader(`[
+ {"id": 1, "geom": "`+geomWKB.String()+`", "geog": "`+geogWKB.String()+`"},
+ {"id": null, "geom": null, "geog": "`+geogWKB.String()+`"}
+ ]`))
+ require.NoError(t, err)
+ defer rec.Release()
+
+ arrProps := pqarrow.NewArrowWriterProperties(
+ pqarrow.WithAllocator(memory.DefaultAllocator),
+ pqarrow.WithStoreSchema(),
+ )
+ var buf bytes.Buffer
+ wr, err := pqarrow.NewFileWriter(arrowSchema, &buf,
+ parquet.NewWriterProperties(parquet.WithStats(true)),
+ arrProps)
+ require.NoError(t, err)
+ require.NoError(t, wr.Write(rec))
+ require.NoError(t, wr.Close())
+
+ pqRdr, err := file.NewParquetReader(bytes.NewReader(buf.Bytes()))
+ require.NoError(t, err)
+ defer pqRdr.Close()
+
+ arrRdr, err := pqarrow.NewFileReader(pqRdr, pqarrow.ArrowReadProperties{}, memory.DefaultAllocator)
+ require.NoError(t, err)
+ fr := internal.WrapParquetFileReader(arrRdr)
+
+ tbl, err := fr.ReadTable(context.Background())
+ require.NoError(t, err)
+ defer tbl.Release()
+
+ roundTripSchema := tbl.Schema()
+
+ origGeomType := arrowSchema.Field(1).Type.(*geoarrow.WKBType)
+ origGeogType := arrowSchema.Field(2).Type.(*geoarrow.WKBType)
+ rtGeomField := roundTripSchema.Field(1)
+ rtGeogField := roundTripSchema.Field(2)
+
+ rtGeomExt := rtGeomField.Type.(arrow.ExtensionType)
+ rtGeogExt := rtGeogField.Type.(arrow.ExtensionType)
+ rtGeomType := rtGeomExt.(*geoarrow.WKBType)
+ rtGeogType := rtGeogExt.(*geoarrow.WKBType)
+
+ assert.Equal(t, origGeomType.ExtensionName(), rtGeomExt.ExtensionName())
+ assert.Equal(t, origGeogType.ExtensionName(), rtGeogExt.ExtensionName())
+ assert.True(t, arrow.TypeEqual(origGeomType.StorageType(), rtGeomType.StorageType()))
+ assert.True(t, arrow.TypeEqual(origGeogType.StorageType(), rtGeogType.StorageType()))
+ assert.Equal(t, origGeomType.Metadata(), rtGeomType.Metadata())
+ assert.Equal(t, origGeogType.Metadata(), rtGeogType.Metadata())
+ assert.Equal(t, geoarrow.CRSTypeSRID, rtGeomType.Metadata().CRSType)
+ assert.Equal(t, geoarrow.EdgePlanar, rtGeomType.Metadata().Edges)
+ assert.Equal(t, geoarrow.CRSTypeSRID, rtGeogType.Metadata().CRSType)
+ assert.Equal(t, geoarrow.EdgeVincenty, rtGeogType.Metadata().Edges)
+
+ rr, err := fr.GetRecords(context.Background(), nil, nil)
+ require.NoError(t, err)
+ defer rr.Release()
+ require.True(t, rr.Next())
+
+ batch := rr.RecordBatch()
+ defer batch.Release()
+ require.Equal(t, int64(2), batch.NumRows())
+
+ geomArr, ok := batch.Column(1).(*geoarrow.WKBArray)
+ assert.True(t, ok)
+ assert.Equal(t, geomWKB, geomArr.Value(0))
+ assert.Nil(t, geomArr.Value(1))
+
+ geogArr, ok := batch.Column(2).(*geoarrow.WKBArray)
+ assert.True(t, ok)
+ assert.Equal(t, geogWKB, geogArr.Value(0))
+ assert.Equal(t, geogWKB, geogArr.Value(1))
+}
+
func TestWriteDataFileErrOnClose(t *testing.T) {
ctx := context.Background()
fm := internal.GetFileFormat(iceberg.ParquetFile)