You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by ze...@apache.org on 2023/07/05 16:13:04 UTC

[arrow-adbc] branch main updated: fix(go/adbc): fix crash on map type (#854)

This is an automated email from the ASF dual-hosted git repository.

zeroshade pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-adbc.git


The following commit(s) were added to refs/heads/main by this push:
     new 8251403d fix(go/adbc): fix crash on map type (#854)
8251403d is described below

commit 8251403d054eb225d92ae82b687300f34d346061
Author: David Li <li...@gmail.com>
AuthorDate: Wed Jul 5 12:12:59 2023 -0400

    fix(go/adbc): fix crash on map type (#854)
    
    Fixes #853.
---
 .../driver/flightsql/flightsql_adbc_server_test.go | 103 +++++++++++++++++++++
 go/adbc/utils/utils.go                             |  10 +-
 2 files changed, 112 insertions(+), 1 deletion(-)

diff --git a/go/adbc/driver/flightsql/flightsql_adbc_server_test.go b/go/adbc/driver/flightsql/flightsql_adbc_server_test.go
index 11c5c31e..61a46db1 100644
--- a/go/adbc/driver/flightsql/flightsql_adbc_server_test.go
+++ b/go/adbc/driver/flightsql/flightsql_adbc_server_test.go
@@ -103,6 +103,10 @@ func TestCookies(t *testing.T) {
 	suite.Run(t, &CookieTests{})
 }
 
+func TestDataType(t *testing.T) {
+	suite.Run(t, &DataTypeTests{})
+}
+
 // ---- AuthN Tests --------------------
 
 type AuthnTestServer struct {
@@ -524,3 +528,102 @@ func (suite *CookieTests) TestCookieUsage() {
 	suite.Require().NoError(err)
 	defer reader.Release()
 }
+
+// ---- Data Type Tests --------------------
+type DataTypeTestServer struct {
+	flightsql.BaseServer
+}
+
+func (server *DataTypeTestServer) GetFlightInfoStatement(ctx context.Context, cmd flightsql.StatementQuery, desc *flight.FlightDescriptor) (*flight.FlightInfo, error) {
+	tkt, _ := flightsql.CreateStatementQueryTicket([]byte(cmd.GetQuery()))
+	info := &flight.FlightInfo{
+		FlightDescriptor: desc,
+		Endpoint: []*flight.FlightEndpoint{
+			{Ticket: &flight.Ticket{Ticket: tkt}},
+		},
+		TotalRecords: -1,
+		TotalBytes:   -1,
+	}
+
+	return info, nil
+}
+
+var (
+	SchemaListInt3     = arrow.NewSchema([]arrow.Field{{Name: "a", Type: arrow.FixedSizeListOf(3, arrow.PrimitiveTypes.Int32), Nullable: true}}, nil)
+	SchemaListInt      = arrow.NewSchema([]arrow.Field{{Name: "a", Type: arrow.ListOf(arrow.PrimitiveTypes.Int32), Nullable: true}}, nil)
+	SchemaLargeListInt = arrow.NewSchema([]arrow.Field{{Name: "a", Type: arrow.LargeListOf(arrow.PrimitiveTypes.Int32), Nullable: true}}, nil)
+	SchemaMapIntInt    = arrow.NewSchema([]arrow.Field{{Name: "a", Type: arrow.MapOf(arrow.PrimitiveTypes.Int32, arrow.PrimitiveTypes.Int32), Nullable: true}}, nil)
+)
+
+func (server *DataTypeTestServer) DoGetStatement(ctx context.Context, tkt flightsql.StatementQueryTicket) (*arrow.Schema, <-chan flight.StreamChunk, error) {
+	var schema *arrow.Schema
+	var record arrow.Record
+	var err error
+
+	cmd := string(tkt.GetStatementHandle())
+	switch cmd {
+	case "list[int, 3]":
+		schema = SchemaListInt3
+		record, _, err = array.RecordFromJSON(memory.DefaultAllocator, schema, strings.NewReader(`[{"a": [1, 2, 3]}]`))
+	case "list[int]":
+		schema = SchemaListInt
+		record, _, err = array.RecordFromJSON(memory.DefaultAllocator, schema, strings.NewReader(`[{"a": [1]}]`))
+	case "large_list[int]":
+		schema = SchemaLargeListInt
+		record, _, err = array.RecordFromJSON(memory.DefaultAllocator, schema, strings.NewReader(`[{"a": [1]}]`))
+	case "map[int]int":
+		schema = SchemaMapIntInt
+		record, _, err = array.RecordFromJSON(memory.DefaultAllocator, schema, strings.NewReader(`[{"a": null}]`))
+	default:
+		return nil, nil, fmt.Errorf("Unknown command: '%s'", cmd)
+	}
+
+	if err != nil {
+		return nil, nil, err
+	}
+
+	ch := make(chan flight.StreamChunk)
+	go func() {
+		defer close(ch)
+		ch <- flight.StreamChunk{
+			Data: record,
+		}
+	}()
+	return schema, ch, nil
+}
+
+type DataTypeTests struct {
+	ServerBasedTests
+}
+
+func (suite *DataTypeTests) SetupSuite() {
+	suite.DoSetupSuite(&DataTypeTestServer{}, nil, map[string]string{})
+}
+
+func (suite *DataTypeTests) DoTestCase(name string, schema *arrow.Schema) {
+	stmt, err := suite.cnxn.NewStatement()
+	suite.NoError(err)
+	defer stmt.Close()
+
+	suite.NoError(stmt.SetSqlQuery(name))
+	reader, _, err := stmt.ExecuteQuery(context.Background())
+	suite.NoError(err)
+	suite.Equal(reader.Schema(), schema)
+	defer reader.Release()
+}
+
+func (suite *DataTypeTests) TestListInt3() {
+	suite.DoTestCase("list[int, 3]", SchemaListInt3)
+}
+
+func (suite *DataTypeTests) TestLargeListInt() {
+	suite.DoTestCase("large_list[int]", SchemaLargeListInt)
+}
+
+func (suite *DataTypeTests) TestListInt() {
+	suite.DoTestCase("list[int]", SchemaListInt)
+}
+
+func (suite *DataTypeTests) TestMapIntInt() {
+	suite.DoTestCase("map[int]int", SchemaMapIntInt)
+}
diff --git a/go/adbc/utils/utils.go b/go/adbc/utils/utils.go
index 1a34e662..4ddf71bd 100644
--- a/go/adbc/utils/utils.go
+++ b/go/adbc/utils/utils.go
@@ -46,7 +46,15 @@ func removeFieldMetadata(field *arrow.Field) arrow.Field {
 		case *arrow.LargeListType:
 			fieldType = arrow.LargeListOfField(childFields[0])
 		case *arrow.MapType:
-			mapType := arrow.MapOf(childFields[0].Type, childFields[1].Type)
+			// XXX: arrow-go doesn't let us build a map type from fields (so
+			// nonstandard field names or nullability will be lost here)
+
+			// child must be struct
+			structType := ty.Elem().(*arrow.StructType)
+			// struct must have two children
+			keyType := structType.Field(0).Type
+			itemType := structType.Field(1).Type
+			mapType := arrow.MapOf(keyType, itemType)
 			mapType.KeysSorted = ty.KeysSorted
 			fieldType = mapType
 		case *arrow.SparseUnionType: