chore: remove unused code

Author: olavloite

checksum_row_iterator.go

@@ -255,13 +255,5 @@ func (it *checksumRowIterator) Metadata() (*sppb.ResultSetMetadata, error) {
 }
 
 func (it *checksumRowIterator) ResultSetStats() *sppb.ResultSetStats {
-	// TODO: The Spanner client library should offer an option to get the full
-	//       ResultSetStats, instead of only the RowCount and QueryPlan.
-	stats := &sppb.ResultSetStats{
-		QueryPlan: it.RowIterator.QueryPlan,
-	}
-	if it.stmtType == parser.StatementTypeDml {
-		stats.RowCount = &sppb.ResultSetStats_RowCountExact{RowCountExact: it.RowIterator.RowCount}
-	}
-	return stats
+	return createResultSetStats(it.RowIterator, it.stmtType)
 }

rows.go

@@ -55,10 +55,9 @@ type rows struct {
 	it    rowIterator
 	close func() error
 
-	colsOnce     sync.Once
-	dirtyErr     error
-	cols         []string
-	colTypeNames []string
+	colsOnce sync.Once
+	dirtyErr error
+	cols     []string
 
 	decodeOption         DecodeOption
 	decodeToNativeArrays bool
@@ -146,12 +145,8 @@ func (r *rows) getColumns() {
 		}
 		rowType := metadata.RowType
 		r.cols = make([]string, len(rowType.Fields))
-		r.colTypeNames = make([]string, len(rowType.Fields))
 		for i, c := range rowType.Fields {
 			r.cols[i] = c.Name
-			if r.decodeOption != DecodeOptionProto {
-				r.colTypeNames[i] = c.Type.Code.String()
-			}
 		}
 	})
 }

spannerlib/dotnet-spannerlib/Google.Cloud.SpannerLib.MockServer/MockSpannerServer.cs

@@ -57,7 +57,7 @@ public static StatementResult CreateUpdateCount(long count)
             return new StatementResult(count);
         }
 
-        internal static StatementResult CreateException(Exception exception)
+        public static StatementResult CreateException(Exception exception)
         {
             return new StatementResult(exception);
         }

spannerlib/dotnet-spannerlib/Google.Cloud.SpannerLib.Native/MessageHandler.cs

@@ -31,16 +31,6 @@ internal bool HasError()
             return Message.Code != 0;
         }
 
-        internal string? Error()
-        {
-            if (!HasError())
-            {
-                return null;
-            }
-
-            return ValueAsString();
-        }
-
         internal string ValueAsString()
         {
             unsafe

spannerlib/dotnet-spannerlib/Google.Cloud.SpannerLib.Tests/BasicTests.cs

@@ -56,6 +56,19 @@ public void TestExecuteQuery()
         }
     }
 
+    [Test]
+    public void TestExecuteQueryError()
+    {
+        var sql = "select * from non_existing_table";
+        _fixture.SpannerMock.AddOrUpdateStatementResult(sql, StatementResult.CreateException(new RpcException(new Status(StatusCode.NotFound, "Table not found"))));
+        
+        using var pool = Pool.Create(ConnectionString);
+        using var connection = pool.CreateConnection();
+        SpannerException exception = Assert.Throws<SpannerException>(() => connection.Execute(new ExecuteSqlRequest { Sql = sql }));
+        Assert.That(exception.ErrorCode, Is.EqualTo(ErrorCode.NotFound));
+        Assert.That(exception.Message, Is.EqualTo("Table not found"));
+    }
+
     [Test]
     public void TestExecuteParameterizedQuery()
     {

spannerlib/dotnet-spannerlib/Google.Cloud.SpannerLib/SharedLibSpanner.cs

@@ -4,6 +4,7 @@
 using Google.Cloud.SpannerLib.Native;
 using Google.Protobuf;
 using Google.Protobuf.WellKnownTypes;
+using Google.Rpc;
 
 namespace Google.Cloud.SpannerLib;
 
@@ -16,7 +17,7 @@ private MessageHandler ExecuteLibraryFunction(Func<Message> func)
         {
             try
             {
-                throw new SpannerException(handler.Code(), handler.Error()!);
+                throw CreateException(handler);
             }
             finally
             {
@@ -26,12 +27,22 @@ private MessageHandler ExecuteLibraryFunction(Func<Message> func)
         return handler;
     }
 
+    private SpannerException CreateException(MessageHandler handler)
+    {
+        if (handler.Length > 0)
+        {
+            var status = Status.Parser.ParseFrom(handler.Value());
+            return new SpannerException(status.Code, status.Message);
+        }
+        return new SpannerException(handler.Code(), "Unknown error");
+    }
+
     private void ExecuteAndReleaseLibraryFunction(Func<Message> func)
     {
         using var handler = new MessageHandler(func());
         if (handler.HasError())
         {
-            throw new SpannerException(handler.Code(), handler.Error()!);
+            throw CreateException(handler);
         }
     }
 

spannerlib/lib/message.go

@@ -3,8 +3,8 @@ package lib
 import (
 	"unsafe"
 
-	"github.com/google/uuid"
 	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/proto"
 )
 
 type Message struct {
@@ -27,29 +27,14 @@ func (m *Message) ResPointer() unsafe.Pointer {
 	return unsafe.Pointer(&(m.Res[0]))
 }
 
-func generateId() (string, error) {
-	id, err := uuid.NewRandom()
-	if err != nil {
-		return "", err
-	}
-	return id.String(), nil
-}
-
-type BaseMsg struct {
-	Allowed bool
-}
-
-type OtherMsg struct {
-	BaseMsg
-	Foo string
-}
-
 func idMessage(id int64) *Message {
 	return &Message{ObjectId: id}
 }
 
 func errMessage(err error) *Message {
-	errCode := status.Code(err)
-	b := []byte(err.Error())
-	return &Message{Code: int32(errCode), Res: b}
+	s := status.Convert(err)
+	p := s.Proto()
+	// Ignore any marshalling errors and just return an empty status in that case.
+	b, _ := proto.Marshal(p)
+	return &Message{Code: int32(s.Code()), Res: b}
 }

spannerlib/lib/mock_server_test.go

@@ -37,9 +37,22 @@ func TestSimpleQuery(t *testing.T) {
 		t.Fatalf("failed to marshal statement: %v", err)
 	}
 	results := Execute(pool.ObjectId, conn.ObjectId, statementBytes)
-	metadata := Metadata(pool.ObjectId, conn.ObjectId, results.ObjectId)
-	if metadata.Code != 0 {
-		t.Fatalf("metadata.Code: %v", metadata.Code)
+	metadataMsg := Metadata(pool.ObjectId, conn.ObjectId, results.ObjectId)
+	if metadataMsg.Code != 0 {
+		t.Fatalf("metadataMsg.Code: %v", metadataMsg.Code)
+	}
+	metadata := &sppb.ResultSetMetadata{}
+	if err := proto.Unmarshal(metadataMsg.Res, metadata); err != nil {
+		t.Fatalf("failed to unmarshal metadata: %v", err)
+	}
+	if g, w := len(metadata.RowType.Fields), 1; g != w {
+		t.Fatalf("field count mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	if g, w := metadata.RowType.Fields[0].Name, "FOO"; g != w {
+		t.Fatalf("field name mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	if g, w := metadata.RowType.Fields[0].Type.Code, sppb.TypeCode_INT64; g != w {
+		t.Fatalf("field type code mismatch\n Got: %v\nWant: %v", g, w)
 	}
 	for {
 		row := Next(pool.ObjectId, conn.ObjectId, results.ObjectId)
@@ -192,8 +205,8 @@ func TestQueryWithTimestampBound(t *testing.T) {
 	CloseConnection(pool.ObjectId, conn.ObjectId)
 	ClosePool(pool.ObjectId)
 
-	requests := drainRequestsFromServer(server.TestSpanner)
-	sqlRequests := requestsOfType(requests, reflect.TypeOf(&sppb.ExecuteSqlRequest{}))
+	requests := server.TestSpanner.DrainRequestsFromServer()
+	sqlRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.ExecuteSqlRequest{}))
 	if g, w := len(sqlRequests), 1; g != w {
 		t.Fatalf("sql requests count mismatch\nGot: %v\nWant: %v", g, w)
 	}
@@ -305,8 +318,8 @@ func TestApply(t *testing.T) {
 		t.Fatal("commit timestamp missing")
 	}
 
-	requests := drainRequestsFromServer(server.TestSpanner)
-	beginRequests := requestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{}))
+	requests := server.TestSpanner.DrainRequestsFromServer()
+	beginRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{}))
 	if g, w := len(beginRequests), 1; g != w {
 		t.Fatalf("begin requests count mismatch\nGot: %v\nWant: %v", g, w)
 	}
@@ -317,7 +330,7 @@ func TestApply(t *testing.T) {
 	if req.Options.GetReadWrite() == nil {
 		t.Fatalf("missing tx read write")
 	}
-	commitRequests := requestsOfType(requests, reflect.TypeOf(&sppb.CommitRequest{}))
+	commitRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.CommitRequest{}))
 	if g, w := len(commitRequests), 1; g != w {
 		t.Fatalf("commit requests count mismatch\nGot: %v\nWant: %v", g, w)
 	}
@@ -372,14 +385,14 @@ func TestBufferWrite(t *testing.T) {
 		t.Fatal("response length mismatch")
 	}
 
-	requests := drainRequestsFromServer(server.TestSpanner)
+	requests := server.TestSpanner.DrainRequestsFromServer()
 	// There should not be any BeginTransaction requests yet, as we use inlined-begin.
-	beginRequests := requestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{}))
+	beginRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{}))
 	if g, w := len(beginRequests), 0; g != w {
 		t.Fatalf("begin requests count mismatch\nGot: %v\nWant: %v", g, w)
 	}
 	// There should not be any commit requests yet.
-	commitRequests := requestsOfType(requests, reflect.TypeOf(&sppb.CommitRequest{}))
+	commitRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.CommitRequest{}))
 	if g, w := len(commitRequests), 0; g != w {
 		t.Fatalf("commit requests count mismatch\nGot: %v\nWant: %v", g, w)
 	}
@@ -391,8 +404,8 @@ func TestBufferWrite(t *testing.T) {
 	}
 
 	// Verify that we have a commit request on the server.
-	requests = drainRequestsFromServer(server.TestSpanner)
-	beginRequests = requestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{}))
+	requests = server.TestSpanner.DrainRequestsFromServer()
+	beginRequests = testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{}))
 	if g, w := len(beginRequests), 1; g != w {
 		t.Fatalf("begin requests count mismatch\nGot: %v\nWant: %v", g, w)
 	}
@@ -403,7 +416,7 @@ func TestBufferWrite(t *testing.T) {
 	if req.Options.GetReadWrite() == nil {
 		t.Fatalf("missing tx read write")
 	}
-	commitRequests = requestsOfType(requests, reflect.TypeOf(&sppb.CommitRequest{}))
+	commitRequests = testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.CommitRequest{}))
 	if g, w := len(commitRequests), 1; g != w {
 		t.Fatalf("commit requests count mismatch\nGot: %v\nWant: %v", g, w)
 	}
@@ -459,9 +472,9 @@ func TestBufferWrite_RetryAborted(t *testing.T) {
 		t.Fatal("response length mismatch")
 	}
 
-	requests := drainRequestsFromServer(server.TestSpanner)
+	requests := server.TestSpanner.DrainRequestsFromServer()
 	// There should not be any commit requests yet.
-	commitRequests := requestsOfType(requests, reflect.TypeOf(&sppb.CommitRequest{}))
+	commitRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.CommitRequest{}))
 	if g, w := len(commitRequests), 0; g != w {
 		t.Fatalf("commit requests count mismatch\nGot: %v\nWant: %v", g, w)
 	}
@@ -478,8 +491,8 @@ func TestBufferWrite_RetryAborted(t *testing.T) {
 	}
 
 	// Verify that we have both begin and commit requests on the server.
-	requests = drainRequestsFromServer(server.TestSpanner)
-	beginRequests := requestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{}))
+	requests = server.TestSpanner.DrainRequestsFromServer()
+	beginRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{}))
 	if g, w := len(beginRequests), 2; g != w {
 		t.Fatalf("begin requests count mismatch\nGot: %v\nWant: %v", g, w)
 	}
@@ -492,7 +505,7 @@ func TestBufferWrite_RetryAborted(t *testing.T) {
 			t.Fatalf("missing tx read write")
 		}
 	}
-	commitRequests = requestsOfType(requests, reflect.TypeOf(&sppb.CommitRequest{}))
+	commitRequests = testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.CommitRequest{}))
 	if g, w := len(commitRequests), 2; g != w {
 		t.Fatalf("commit requests count mismatch\nGot: %v\nWant: %v", g, w)
 	}
@@ -554,27 +567,3 @@ func setupMockedTestServerWithConfigAndClientOptionsAndDialect(t *testing.T, con
 		serverTeardown()
 	}
 }
-
-func requestsOfType(requests []interface{}, t reflect.Type) []interface{} {
-	res := make([]interface{}, 0)
-	for _, req := range requests {
-		if reflect.TypeOf(req) == t {
-			res = append(res, req)
-		}
-	}
-	return res
-}
-
-func drainRequestsFromServer(server testutil.InMemSpannerServer) []interface{} {
-	var reqs []interface{}
-loop:
-	for {
-		select {
-		case req := <-server.ReceivedRequests():
-			reqs = append(reqs, req)
-		default:
-			break loop
-		}
-	}
-	return reqs
-}

transaction.go

@@ -83,13 +83,17 @@ func (ri *readOnlyRowIterator) Metadata() (*sppb.ResultSetMetadata, error) {
 }
 
 func (ri *readOnlyRowIterator) ResultSetStats() *sppb.ResultSetStats {
+	return createResultSetStats(ri.RowIterator, ri.stmtType)
+}
+
+func createResultSetStats(it *spanner.RowIterator, stmtType parser.StatementType) *sppb.ResultSetStats {
 	// TODO: The Spanner client library should offer an option to get the full
 	//       ResultSetStats, instead of only the RowCount and QueryPlan.
 	stats := &sppb.ResultSetStats{
-		QueryPlan: ri.RowIterator.QueryPlan,
+		QueryPlan: it.QueryPlan,
 	}
-	if ri.stmtType == parser.StatementTypeDml {
-		stats.RowCount = &sppb.ResultSetStats_RowCountExact{RowCountExact: ri.RowIterator.RowCount}
+	if stmtType == parser.StatementTypeDml {
+		stats.RowCount = &sppb.ResultSetStats_RowCountExact{RowCountExact: it.RowCount}
 	}
 	return stats
 }

wrapped_row_iterator.go

@@ -17,6 +17,7 @@ package spannerdriver
 import (
 	"cloud.google.com/go/spanner"
 	"cloud.google.com/go/spanner/apiv1/spannerpb"
+	"github.com/googleapis/go-sql-spanner/parser"
 	"google.golang.org/api/iterator"
 )
 
@@ -50,9 +51,6 @@ func (ri *wrappedRowIterator) Metadata() (*spannerpb.ResultSetMetadata, error) {
 }
 
 func (ri *wrappedRowIterator) ResultSetStats() *spannerpb.ResultSetStats {
-	// Include the row count in the stats, as this is a DML statement.
-	return &spannerpb.ResultSetStats{
-		RowCount:  &spannerpb.ResultSetStats_RowCountExact{RowCountExact: ri.RowIterator.RowCount},
-		QueryPlan: ri.RowIterator.QueryPlan,
-	}
+	// wrappedRowIterator is only used for DML statements.
+	return createResultSetStats(ri.RowIterator, parser.StatementTypeDml)
 }