// Copyright 2021 Google LLC

//

// Licensed 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

//

// https://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 spannerdriver

import (

"context"

"database/sql"

"database/sql/driver"

"encoding/base64"

"encoding/json"

"fmt"

"math/big"

"math/rand"

"os"

"reflect"

"sync"

"testing"

"time"

"cloud.google.com/go/civil"

"cloud.google.com/go/longrunning/autogen/longrunningpb"

"cloud.google.com/go/spanner"

"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"

sppb "cloud.google.com/go/spanner/apiv1/spannerpb"

pb "cloud.google.com/go/spanner/testdata/protos"

"github.com/google/go-cmp/cmp"

"github.com/google/go-cmp/cmp/cmpopts"

"github.com/google/uuid"

"github.com/googleapis/go-sql-spanner/parser"

"github.com/googleapis/go-sql-spanner/testutil"

"google.golang.org/api/option"

"google.golang.org/grpc"

"google.golang.org/grpc/codes"

"google.golang.org/grpc/metadata"

gstatus "google.golang.org/grpc/status"

"google.golang.org/protobuf/proto"

"google.golang.org/protobuf/types/known/anypb"

"google.golang.org/protobuf/types/known/emptypb"

"google.golang.org/protobuf/types/known/structpb"

)

func TestPingContext(t *testing.T) {

t.Parallel()

db, _, teardown := setupTestDBConnection(t)

defer teardown()

if err := db.PingContext(context.Background()); err != nil {

t.Fatalf("unexpected error for ping: %v", err)

}

}

func TestPingContext_Fails(t *testing.T) {

t.Parallel()

db, server, teardown := setupTestDBConnection(t)

defer teardown()

s := gstatus.Newf(codes.PermissionDenied, "Permission denied for database")

_ = server.TestSpanner.PutStatementResult("SELECT 1", &testutil.StatementResult{Err: s.Err()})

if g, w := db.PingContext(context.Background()), driver.ErrBadConn; g != w {

t.Fatalf("ping error mismatch\nGot: %v\nWant: %v", g, w)

}

}

func TestStatementCacheSize(t *testing.T) {

t.Parallel()

db, server, teardown := setupTestDBConnectionWithParams(t, "StatementCacheSize=2")

defer teardown()

c, err := db.Conn(context.Background())

if err != nil {

t.Fatalf("unexpected error for connection: %v", err)

}

var p *parser.StatementParser

if err := c.Raw(func(driverConn any) error {

sc, ok := driverConn.(*conn)

if !ok {

return fmt.Errorf("driverConn is not a Spanner conn")

}

p = sc.parser

return nil

}); err != nil {

t.Fatalf("unexpected error for raw: %v", err)

}

// The cache should initially be empty.

if g, w := p.CacheSize(), 0; g != w {

t.Fatalf("cache size mismatch\n Got: %v\nWant: %v", g, w)

}

for n := 0; n < 3; n++ {

rows, err := db.QueryContext(context.Background(), testutil.SelectFooFromBar)

if err != nil {

t.Fatal(err)

}

for rows.Next() {

}

if err := rows.Close(); err != nil {

t.Fatal(err)

}

}

// Executing the same query multiple times should add the statement once to the cache.

if g, w := p.CacheSize(), 1; g != w {

t.Fatalf("cache size mismatch\n Got: %v\nWant: %v", g, w)

}

// Executing another statement should add yet another statement to the cache.

if _, err := db.ExecContext(context.Background(), testutil.UpdateBarSetFoo); err != nil {

t.Fatal(err)

}

if g, w := p.CacheSize(), 2; g != w {

t.Fatalf("cache size mismatch\n Got: %v\nWant: %v", g, w)

}

// Executing yet another statement should evict the oldest result from the cache and add this.

query := "insert into test (id) values (1)"

_ = server.TestSpanner.PutStatementResult(query, &testutil.StatementResult{

Type: testutil.StatementResultUpdateCount,

UpdateCount: 1,

})

if _, err := db.ExecContext(context.Background(), query); err != nil {

t.Fatal(err)

}

// The cache size should still be 2.

if g, w := p.CacheSize(), 2; g != w {

t.Fatalf("cache size mismatch\n Got: %v\nWant: %v", g, w)

}

}

func TestDisableStatementCache(t *testing.T) {

t.Parallel()

db, _, teardown := setupTestDBConnectionWithParams(t, "DisableStatementCache=true")

defer teardown()

c, err := db.Conn(context.Background())

if err != nil {

t.Fatalf("unexpected error for connection: %v", err)

}

var p *parser.StatementParser

if err := c.Raw(func(driverConn any) error {

sc, ok := driverConn.(*conn)

if !ok {

return fmt.Errorf("driverConn is not a Spanner conn")

}

p = sc.parser

return nil

}); err != nil {

t.Fatalf("unexpected error for raw: %v", err)

}

// There should be no cache.

if p.UseCache() {

t.Fatalf("statement cache should be disabled")

}

// Executing queries and other statements should work without a cache.

for n := 0; n < 3; n++ {

rows, err := db.QueryContext(context.Background(), testutil.SelectFooFromBar)

if err != nil {

t.Fatal(err)

}

for rows.Next() {

}

if err := rows.Close(); err != nil {

t.Fatal(err)

}

}

if _, err := db.ExecContext(context.Background(), testutil.UpdateBarSetFoo); err != nil {

t.Fatal(err)

}

}

func TestSimpleQuery(t *testing.T) {

t.Parallel()

db, server, teardown := setupTestDBConnection(t)

defer teardown()

rows, err := db.QueryContext(context.Background(), testutil.SelectFooFromBar)

if err != nil {

t.Fatal(err)

}

defer silentClose(rows)

for want := int64(1); rows.Next(); want++ {

cols, err := rows.Columns()

if err != nil {

t.Fatal(err)

}

if !cmp.Equal(cols, []string{"FOO"}) {

t.Fatalf("cols mismatch\nGot: %v\nWant: %v", cols, []string{"FOO"})

}

var got int64

err = rows.Scan(&got)

if err != nil {

t.Fatal(err)

}

if got != want {

t.Fatalf("value mismatch\nGot: %v\nWant: %v", got, want)

}

}

if rows.Err() != nil {

t.Fatal(rows.Err())

}

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)

}

req := sqlRequests[0].(*sppb.ExecuteSqlRequest)

if req.Transaction == nil {

t.Fatalf("missing transaction for ExecuteSqlRequest")

}

if req.Transaction.GetSingleUse() == nil {

t.Fatalf("missing single use selector for ExecuteSqlRequest")

}

if req.Transaction.GetSingleUse().GetReadOnly() == nil {

t.Fatalf("missing read-only option for ExecuteSqlRequest")

}

if !req.Transaction.GetSingleUse().GetReadOnly().GetStrong() {

t.Fatalf("missing strong timestampbound for ExecuteSqlRequest")

}

}

func TestDirectExecuteQuery(t *testing.T) {

t.Parallel()

db, server, teardown := setupTestDBConnection(t)

defer teardown()

// This does not use DirectExecuteQuery. The query is only sent to Spanner when

// rows.Next is called.

rows, err := db.QueryContext(context.Background(), testutil.SelectFooFromBar)

if err != nil {

t.Fatal(err)

}

// There should be no request on the server.

requests := server.TestSpanner.DrainRequestsFromServer()

sqlRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.ExecuteSqlRequest{}))

if g, w := len(sqlRequests), 0; g != w {

t.Fatalf("sql requests count mismatch\n Got: %v\nWant: %v", g, w)

}

if !rows.Next() {

t.Fatal("no rows")

}

// The request should now be present on the server.

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\n Got: %v\nWant: %v", g, w)

}

_ = rows.Close()

// Now repeat the same with the DirectExecuteQuery option.

rows, err = db.QueryContext(context.Background(), testutil.SelectFooFromBar, ExecOptions{DirectExecuteQuery: true})

if err != nil {

t.Fatal(err)

}

// The request should be present on the server.

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\n Got: %v\nWant: %v", g, w)

}

// Verify that we can get the row that we selected.

if !rows.Next() {

t.Fatal("no rows")

}

_ = rows.Close()

}

func TestConcurrentScanAndClose(t *testing.T) {

t.Parallel()

db, _, teardown := setupTestDBConnection(t)

defer teardown()

rows, err := db.QueryContext(context.Background(), testutil.SelectFooFromBar)

if err != nil {

t.Fatal(err)

}

// Only fetch the first row of the query to make sure that the rows are not auto-closed

// when the end of the stream is reached.

rows.Next()

var got int64

err = rows.Scan(&got)

if err != nil {

t.Fatal(err)

}

// Close both the database and the rows (connection) in parallel.

var wg sync.WaitGroup

wg.Add(2)

go func() {

defer wg.Done()

_ = db.Close()

}()

go func() {

defer wg.Done()

_ = rows.Close()

}()

wg.Wait()

}

func TestSingleQueryWithTimestampBound(t *testing.T) {

t.Parallel()

db, server, teardown := setupTestDBConnection(t)

defer teardown()

ctx := context.Background()

conn, err := db.Conn(ctx)

if err != nil {

t.Fatal(err)

}

if _, err := conn.ExecContext(ctx, "SET READ_ONLY_STALENESS = 'MAX_STALENESS 10s'"); err != nil {

t.Fatalf("Set read-only staleness: %v", err)

}

rows, err := conn.QueryContext(context.Background(), testutil.SelectFooFromBar)

if err != nil {

t.Fatal(err)

}

for rows.Next() {

}

if rows.Err() != nil {

t.Fatal(rows.Err())

}

_ = rows.Close()

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)

}

req := sqlRequests[0].(*sppb.ExecuteSqlRequest)

if req.Transaction == nil {

t.Fatalf("missing transaction for ExecuteSqlRequest")

}

if req.Transaction.GetSingleUse() == nil {

t.Fatalf("missing single use selector for ExecuteSqlRequest")

}

if req.Transaction.GetSingleUse().GetReadOnly() == nil {

t.Fatalf("missing read-only option for ExecuteSqlRequest")

}

if req.Transaction.GetSingleUse().GetReadOnly().GetMaxStaleness() == nil {

t.Fatalf("missing max_staleness timestampbound for ExecuteSqlRequest")

}

// Close the connection and execute a new query. This should use a strong read.

_ = conn.Close()

rows, err = db.QueryContext(context.Background(), testutil.SelectFooFromBar)

if err != nil {

t.Fatal(err)

}

for rows.Next() {

}

if rows.Err() != nil {

t.Fatal(rows.Err())

}

_ = rows.Close()

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)

}

req = sqlRequests[0].(*sppb.ExecuteSqlRequest)

if req.Transaction == nil {

t.Fatalf("missing transaction for ExecuteSqlRequest")

}

if req.Transaction.GetSingleUse() == nil {

t.Fatalf("missing single use selector for ExecuteSqlRequest")

}

if req.Transaction.GetSingleUse().GetReadOnly() == nil {

t.Fatalf("missing read-only option for ExecuteSqlRequest")

}

if !req.Transaction.GetSingleUse().GetReadOnly().GetStrong() {

t.Fatalf("missing strong timestampbound for ExecuteSqlRequest")

}

}

func TestSimpleReadOnlyTransaction(t *testing.T) {

t.Parallel()

ctx := context.Background()

db, server, teardown := setupTestDBConnection(t)

defer teardown()

tx, err := db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})

if err != nil {

t.Fatal(err)

}

rows, err := tx.Query(testutil.SelectFooFromBar)

if err != nil {

t.Fatal(err)

}

defer silentClose(rows)

for want := int64(1); rows.Next(); want++ {

cols, err := rows.Columns()

if err != nil {

t.Fatal(err)

}

if !cmp.Equal(cols, []string{"FOO"}) {

t.Fatalf("cols mismatch\nGot: %v\nWant: %v", cols, []string{"FOO"})

}

var got int64

err = rows.Scan(&got)

if err != nil {

t.Fatal(err)

}

if got != want {

t.Fatalf("value mismatch\nGot: %v\nWant: %v", got, want)

}

}

if rows.Err() != nil {

t.Fatal(rows.Err())

}

err = tx.Commit()

if err != nil {

t.Fatal(err)

}

requests := server.TestSpanner.DrainRequestsFromServer()

sqlRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.ExecuteSqlRequest{}))

if g, w := len(sqlRequests), 1; g != w {

t.Fatalf("ExecuteSqlRequests count mismatch\nGot: %v\nWant: %v", g, w)

}

req := sqlRequests[0].(*sppb.ExecuteSqlRequest)

if req.Transaction == nil {

t.Fatalf("missing transaction for ExecuteSqlRequest")

}

if req.Transaction.GetBegin() == nil {

t.Fatalf("missing begin selector for ExecuteSqlRequest")

}

// Read-only transactions are not really committed on Cloud Spanner, so

// there should be no commit request on the server.

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)

}

beginReadOnlyRequests := filterBeginReadOnlyRequests(testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{})))

if g, w := len(beginReadOnlyRequests), 0; g != w {

t.Fatalf("begin requests count mismatch\nGot: %v\nWant: %v", g, w)

}

}

func TestReadOnlyTransactionWithStaleness(t *testing.T) {

t.Parallel()

ctx := context.Background()

db, server, teardown := setupTestDBConnection(t)

defer teardown()

conn, err := db.Conn(ctx)

if err != nil {

t.Fatal(err)

}

if _, err := conn.ExecContext(ctx, "SET READ_ONLY_STALENESS = 'EXACT_STALENESS 10s'"); err != nil {

t.Fatalf("Set read-only staleness: %v", err)

}

tx, err := conn.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})

if err != nil {

t.Fatal(err)

}

rows, err := tx.Query(testutil.SelectFooFromBar)

if err != nil {

t.Fatal(err)

}

for rows.Next() {

}

if rows.Err() != nil {

t.Fatal(rows.Err())

}

_ = rows.Close()

if err := tx.Commit(); err != nil {

t.Fatal(err)

}

requests := server.TestSpanner.DrainRequestsFromServer()

beginReadOnlyRequests := filterBeginReadOnlyRequests(testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{})))

if g, w := len(beginReadOnlyRequests), 0; g != w {

t.Fatalf("begin requests count mismatch\n Got: %v\nWant: %v", g, w)

}

executeRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.ExecuteSqlRequest{}))

if g, w := len(executeRequests), 1; g != w {

t.Fatalf("execute requests count mismatch\n Got: %v\nWant: %v", g, w)

}

executeReq := executeRequests[0].(*sppb.ExecuteSqlRequest)

if executeReq.GetTransaction() == nil || executeReq.GetTransaction().GetBegin() == nil {

t.Fatalf("missing begin selector for ExecuteSqlRequest")

}

if executeReq.GetTransaction().GetBegin().GetReadOnly().GetExactStaleness() == nil {

t.Fatalf("missing exact_staleness option on BeginTransaction option")

}

}

func TestReadOnlyTransactionWithOptions(t *testing.T) {

t.Parallel()

ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)

defer cancel()

db, server, teardown := setupTestDBConnection(t)

defer teardown()

// Set max open connections to 1 to force a failure if there is a connection leak.

db.SetMaxOpenConns(1)

tx, err := BeginReadOnlyTransaction(ctx, db, ReadOnlyTransactionOptions{

TimestampBound: spanner.ExactStaleness(10 * time.Second),

BeginTransactionOption: spanner.InlinedBeginTransaction,

})

if err != nil {

t.Fatal(err)

}

useTx := func(tx *sql.Tx) {

rows, err := tx.Query(testutil.SelectFooFromBar)

if err != nil {

t.Fatal(err)

}

for rows.Next() {

}

if rows.Err() != nil {

t.Fatal(rows.Err())

}

_ = rows.Close()

if err := tx.Commit(); err != nil {

t.Fatal(err)

}

}

useTx(tx)

requests := server.TestSpanner.DrainRequestsFromServer()

beginReadOnlyRequests := filterBeginReadOnlyRequests(testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{})))

if g, w := len(beginReadOnlyRequests), 0; g != w {

t.Fatalf("begin requests count mismatch\nGot: %v\nWant: %v", g, w)

}

executeRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.ExecuteSqlRequest{}))

if g, w := len(executeRequests), 1; g != w {

t.Fatalf("execute requests count mismatch\n Got: %v\nWant: %v", g, w)

}

executeReq := executeRequests[0].(*sppb.ExecuteSqlRequest)

if executeReq.GetTransaction() == nil || executeReq.GetTransaction().GetBegin() == nil {

t.Fatalf("missing begin selector for ExecuteSqlRequest")

}

if executeReq.GetTransaction().GetBegin().GetReadOnly().GetExactStaleness() == nil {

t.Fatalf("missing exact_staleness option on BeginTransaction option")

}

// Verify that the staleness option is not 'sticky' on the database.

// Running a second transaction also verifies that there is no connection

// leak, as the database has max one connection in the pool.

tx, err = db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})

if err != nil {

t.Fatal(err)

}

useTx(tx)

requests = server.TestSpanner.DrainRequestsFromServer()

beginReadOnlyRequests = filterBeginReadOnlyRequests(testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{})))

if g, w := len(beginReadOnlyRequests), 0; g != w {

t.Fatalf("begin requests count mismatch\n Got: %v\nWant: %v", g, w)

}

executeRequests = testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.ExecuteSqlRequest{}))

if g, w := len(executeRequests), 1; g != w {

t.Fatalf("execute requests count mismatch\n Got: %v\nWant: %v", g, w)

}

executeReq = executeRequests[0].(*sppb.ExecuteSqlRequest)

if executeReq.GetTransaction() == nil || executeReq.GetTransaction().GetBegin() == nil {

t.Fatalf("missing begin selector for ExecuteSqlRequest")

}

if executeReq.GetTransaction().GetBegin().GetReadOnly().GetExactStaleness() != nil {

t.Fatalf("got unexpected exact_staleness option on BeginTransaction request")

}

}

func TestSimpleReadWriteTransaction(t *testing.T) {

t.Parallel()

db, server, teardown := setupTestDBConnection(t)

defer teardown()

ctx := context.Background()

conn, err := db.Conn(ctx)

if err != nil {

t.Fatal(err)

}

defer silentClose(conn)

if _, err := conn.ExecContext(ctx, "set max_commit_delay='10ms'"); err != nil {

t.Fatal(err)

}

tx, err := conn.BeginTx(ctx, &sql.TxOptions{})

if err != nil {

t.Fatal(err)

}

rows, err := tx.Query(testutil.SelectFooFromBar)

if err != nil {

t.Fatal(err)

}

defer silentClose(rows)

for want := int64(1); rows.Next(); want++ {

cols, err := rows.Columns()

if err != nil {

t.Fatal(err)

}

if !cmp.Equal(cols, []string{"FOO"}) {

t.Fatalf("cols mismatch\nGot: %v\nWant: %v", cols, []string{"FOO"})

}

var got int64

err = rows.Scan(&got)

if err != nil {

t.Fatal(err)

}

if got != want {

t.Fatalf("value mismatch\nGot: %v\nWant: %v", got, want)

}

}

if rows.Err() != nil {

t.Fatal(rows.Err())

}

err = tx.Commit()

if err != nil {

t.Fatal(err)

}

requests := server.TestSpanner.DrainRequestsFromServer()

beginRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.BeginTransactionRequest{}))

if g, w := len(beginRequests), 0; g != w {

t.Fatalf("begin requests count mismatch\n Got: %v\nWant: %v", g, w)

}

sqlRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.ExecuteSqlRequest{}))

if g, w := len(sqlRequests), 1; g != w {

t.Fatalf("ExecuteSqlRequests count mismatch\n Got: %v\nWant: %v", g, w)

}

req := sqlRequests[0].(*sppb.ExecuteSqlRequest)

if req.Transaction == nil {

t.Fatalf("missing transaction for ExecuteSqlRequest")

}

if req.Transaction.GetBegin() == nil {

t.Fatalf("missing begin selector for ExecuteSqlRequest")

}

if req.LastStatement {

t.Fatalf("last statement set for ExecuteSqlRequest")

}

commitRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&sppb.CommitRequest{}))

if g, w := len(commitRequests), 1; g != w {

t.Fatalf("commit requests count mismatch\n Got: %v\nWant: %v", g, w)

}

commitReq := commitRequests[0].(*sppb.CommitRequest)

if commitReq.MaxCommitDelay == nil {

t.Fatal("missing max commit delay for CommitRequest")

}

if g, w := commitReq.MaxCommitDelay.Nanos, int32(time.Millisecond*10); g != w {

t.Fatalf("max_commit_delay mismatch\n Got: %v\nWant: %v", g, w)

}

}

func TestPreparedQuery(t *testing.T) {

t.Parallel()

db, server, teardown := setupTestDBConnection(t)

defer teardown()

_ = server.TestSpanner.PutStatementResult(

"SELECT * FROM Test WHERE Id=@id",

&testutil.StatementResult{

Type: testutil.StatementResultResultSet,

ResultSet: testutil.CreateSelect1ResultSet(),

},

)

stmt, err := db.Prepare("SELECT * FROM Test WHERE Id=@id")

if err != nil {

t.Fatal(err)

}

defer silentClose(stmt)

rows, err := stmt.Query(1)

if err != nil {

t.Fatal(err)

}

defer silentClose(rows)

for want := int64(1); rows.Next(); want++ {

var got int64

err = rows.Scan(&got)

if err != nil {

t.Fatal(err)

}

if got != want {

t.Fatalf("value mismatch\nGot: %v\nWant: %v", got, want)

}

}

if rows.Err() != nil {

t.Fatal(rows.Err())

}

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)

}

req := sqlRequests[0].(*sppb.ExecuteSqlRequest)

if g, w := len(req.ParamTypes), 1; g != w {

t.Fatalf("param types length mismatch\nGot: %v\nWant: %v", g, w)

}

if pt, ok := req.ParamTypes["id"]; ok {

if g, w := pt.Code, sppb.TypeCode_INT64; g != w {

t.Fatalf("param type mismatch\nGot: %v\nWant: %v", g, w)

}

} else {

t.Fatalf("no param type found for @id")

}

if g, w := len(req.Params.Fields), 1; g != w {

t.Fatalf("params length mismatch\nGot: %v\nWant: %v", g, w)

}

if val, ok := req.Params.Fields["id"]; ok {

if g, w := val.GetStringValue(), "1"; g != w {

t.Fatalf("param value mismatch\nGot: %v\nWant: %v", g, w)

}

} else {

t.Fatalf("no value found for param @id")

}

}

func TestQueryWithAllTypes(t *testing.T) {

t.Parallel()

db, server, teardown := setupTestDBConnection(t)

defer teardown()

query := `SELECT *

FROM Test

WHERE ColBool=@bool

AND ColString=@string

AND ColBytes=@bytes

AND ColInt=@int64

AND ColFloat32=@float32

AND ColFloat64=@float64

AND ColNumeric=@numeric

AND ColDate=@date

AND ColTimestamp=@timestamp

AND ColJson=@json

AND ColUuid=@uuid

AND ColBoolArray=@boolArray

AND ColStringArray=@stringArray

AND ColBytesArray=@bytesArray

AND ColIntArray=@int64Array

AND ColFloat32Array=@float32Array

AND ColFloat64Array=@float64Array

AND ColNumericArray=@numericArray

AND ColDateArray=@dateArray

AND ColTimestampArray=@timestampArray

AND ColJsonArray=@jsonArray

AND ColUuidArray=@uuidArray`

_ = server.TestSpanner.PutStatementResult(

query,

&testutil.StatementResult{

Type: testutil.StatementResultResultSet,

ResultSet: testutil.CreateResultSetWithAllTypes(false, true),

},

)

stmt, err := db.Prepare(query)

if err != nil {

t.Fatal(err)

}

defer silentClose(stmt)

ts, _ := time.Parse(time.RFC3339Nano, "2021-07-22T10:26:17.123Z")

ts1, _ := time.Parse(time.RFC3339Nano, "2021-07-21T21:07:59.339911800Z")

ts2, _ := time.Parse(time.RFC3339Nano, "2021-07-27T21:07:59.339911800Z")

rows, err := stmt.QueryContext(

context.Background(),

true,

"test",

[]byte("testbytes"),

uint(5),

float32(3.14),

3.14,

numeric("6.626"),

civil.Date{Year: 2021, Month: 7, Day: 21},

ts,

nullJson(true, `{"key":"value","other-key":["value1","value2"]}`),

uuid.MustParse("a4e71944-fe14-4047-9d0a-e68c281602e1"),

[]spanner.NullBool{{Valid: true, Bool: true}, {}, {Valid: true, Bool: false}},

[]spanner.NullString{{Valid: true, StringVal: "test1"}, {}, {Valid: true, StringVal: "test2"}},

[][]byte{[]byte("testbytes1"), nil, []byte("testbytes2")},

[]spanner.NullInt64{{Valid: true, Int64: 1}, {}, {Valid: true, Int64: 2}},

[]spanner.NullFloat32{{Valid: true, Float32: 3.14}, {}, {Valid: true, Float32: -99.99}},

[]spanner.NullFloat64{{Valid: true, Float64: 6.626}, {}, {Valid: true, Float64: 10.01}},

[]spanner.NullNumeric{nullNumeric(true, "3.14"), {}, nullNumeric(true, "10.01")},

[]spanner.NullDate{{Valid: true, Date: civil.Date{Year: 2000, Month: 2, Day: 29}}, {}, {Valid: true, Date: civil.Date{Year: 2021, Month: 7, Day: 27}}},

[]spanner.NullTime{{Valid: true, Time: ts1}, {}, {Valid: true, Time: ts2}},

[]spanner.NullJSON{

nullJson(true, `{"key1": "value1", "other-key1": ["value1", "value2"]}`),

nullJson(false, ""),

nullJson(true, `{"key2": "value2", "other-key2": ["value1", "value2"]}`),

},

[]spanner.NullUUID{

nullUuid(true, `d0546638-6d51-4d7c-a4a9-9062204ee5bb`),

nullUuid(false, ""),

nullUuid(true, `0dd0f9b7-05af-48e0-a5b1-35432a01c6bf`),

},

)

if err != nil {

t.Fatal(err)

}

defer silentClose(rows)

for rows.Next() {

var b bool

var s string

var bt []byte

var i int64

var f32 float32

var f float64

var r big.Rat

var d civil.Date

var ts time.Time

var j spanner.NullJSON

var u uuid.UUID

var p []byte

var e int64

var bArray []spanner.NullBool

var sArray []spanner.NullString

var btArray [][]byte

var iArray []spanner.NullInt64

var f32Array []spanner.NullFloat32

var fArray []spanner.NullFloat64

var rArray []spanner.NullNumeric

var dArray []spanner.NullDate

var tsArray []spanner.NullTime

var jArray []spanner.NullJSON

var uArray []spanner.NullUUID

var pArray [][]byte

var eArray []spanner.NullInt64

err = rows.Scan(&b, &s, &bt, &i, &f32, &f, &r, &d, &ts, &j, &u, &p, &e, &bArray, &sArray, &btArray, &iArray, &f32Array, &fArray, &rArray, &dArray, &tsArray, &jArray, &uArray, &pArray, &eArray)

if err != nil {

t.Fatal(err)

}

if g, w := b, true; g != w {

t.Errorf("row value mismatch for bool\nGot: %v\nWant: %v", g, w)

}

if g, w := s, "test"; g != w {

t.Errorf("row value mismatch for string\nGot: %v\nWant: %v", g, w)

}

if g, w := bt, []byte("testbytes"); !cmp.Equal(g, w) {

t.Errorf("row value mismatch for bytes\nGot: %v\nWant: %v", g, w)

}

if g, w := i, int64(5); g != w {

t.Errorf("row value mismatch for int64\nGot: %v\nWant: %v", g, w)

}

if g, w := f32, float32(3.14); g != w {

t.Errorf("row value mismatch for float32\nGot: %v\nWant: %v", g, w)

}

if g, w := f, 3.14; g != w {

t.Errorf("row value mismatch for float64\nGot: %v\nWant: %v", g, w)

}

if g, w := r, numeric("6.626"); g.Cmp(&w) != 0 {

t.Errorf("row value mismatch for numeric\nGot: %v\nWant: %v", g, w)

}

if g, w := d, date("2021-07-21"); !cmp.Equal(g, w) {

t.Errorf("row value mismatch for date\nGot: %v\nWant: %v", g, w)

}

if g, w := ts, time.Date(2021, 7, 21, 21, 7, 59, 339911800, time.UTC); g != w {

t.Errorf("row value mismatch for timestamp\nGot: %v\nWant: %v", g, w)

}

if g, w := j, nullJson(true, `{"key":"value","other-key":["value1","value2"]}`); !cmp.Equal(g, w) {

t.Errorf("row value mismatch for json\nGot: %v\nWant: %v", g, w)

}

if g, w := u, uuid.MustParse(`a4e71944-fe14-4047-9d0a-e68c281602e1`); !cmp.Equal(g, w) {

t.Errorf("row value mismatch for uuid\nGot: %v\nWant: %v", g, w)

}

wantSingerEnumValue := pb.Genre_ROCK

wantSingerProtoMsg := pb.SingerInfo{

SingerId: proto.Int64(1),

BirthDate: proto.String("January"),

Nationality: proto.String("Country1"),

Genre: &wantSingerEnumValue,

}

gotSingerProto := pb.SingerInfo{}

if err := proto.Unmarshal(p, &gotSingerProto); err != nil {

t.Fatalf("failed to unmarshal proto: %v", err)

}

if g, w := &gotSingerProto, &wantSingerProtoMsg; !cmp.Equal(g, w, cmpopts.IgnoreUnexported(pb.SingerInfo{})) {

t.Errorf("row value mismatch for proto\nGot: %v\nWant: %v", g, w)

}

if g, w := pb.Genre(e), wantSingerEnumValue; g != w {

t.Errorf("row value mismatch for enum\nGot: %v\nWant: %v", g, w)

}

if g, w := bArray, []spanner.NullBool{{Valid: true, Bool: true}, {}, {Valid: true, Bool: false}}; !cmp.Equal(g, w) {

t.Errorf("row value mismatch for bool array\nGot: %v\nWant: %v", g, w)

}

if g, w := sArray, []spanner.NullString{{Valid: true, StringVal: "test1"}, {}, {Valid: true, StringVal: "test2"}}; !cmp.Equal(g, w) {

t.Errorf("row value mismatch for string array\nGot: %v\nWant: %v", g, w)

}

if g, w := btArray, [][]byte{[]byte("testbytes1"), nil, []byte("testbytes2")}; !cmp.Equal(g, w) {

t.Errorf("row value mismatch for bytes array\nGot: %v\nWant: %v", g, w)

}

if g, w := iArray, []spanner.NullInt64{{Valid: true, Int64: 1}, {}, {Valid: true, Int64: 2}}; !cmp.Equal(g, w) {

t.Errorf("row value mismatch for int array\nGot: %v\nWant: %v", g, w)

}

if g, w := f32Array, []spanner.NullFloat32{{Valid: true, Float32: 3.14}, {}, {Valid: true, Float32: -99.99}}; !cmp.Equal(g, w) {

t.Errorf("row value mismatch for float32 array\nGot: %v\nWant: %v", g, w)

}

if g, w := fArray, []spanner.NullFloat64{{Valid: true, Float64: 6.626}, {}, {Valid: true, Float64: 10.01}}; !cmp.Equal(g, w) {

t.Errorf("row value mismatch for float64 array\nGot: %v\nWant: %v", g, w)

}

if g, w := rArray, []spanner.NullNumeric{nullNumeric(true, "3.14"), {}, nullNumeric(true, "10.01")}; !cmp.Equal(g, w, cmp.AllowUnexported(big.Rat{}, big.Int{})) {

t.Errorf("row value mismatch for numeric array\nGot: %v\nWant: %v", g, w)

}

if g, w := dArray, []spanner.NullDate{{Valid: true, Date: civil.Date{Year: 2000, Month: 2, Day: 29}}, {}, {Valid: true, Date: civil.Date{Year: 2021, Month: 7, Day: 27}}}; !cmp.Equal(g, w) {

t.Errorf("row value mismatch for date array\nGot: %v\nWant: %v", g, w)

}

if g, w := tsArray, []spanner.NullTime{{Valid: true, Time: ts1}, {}, {Valid: true, Time: ts2}}; !cmp.Equal(g, w) {

t.Errorf("row value mismatch for timestamp array\nGot: %v\nWant: %v", g, w)

}

if g, w := jArray, []spanner.NullJSON{

nullJson(true, `{"key1": "value1", "other-key1": ["value1", "value2"]}`),

nullJson(false, ""),

nullJson(true, `{"key2": "value2", "other-key2": ["value1", "value2"]}`),

}; !cmp.Equal(g, w) {

t.Errorf("row value mismatch for json array\nGot: %v\nWant: %v", g, w)

}

if g, w := uArray, []spanner.NullUUID{

nullUuid(true, `d0546638-6d51-4d7c-a4a9-9062204ee5bb`),

nullUuid(false, ""),

nullUuid(true, `0dd0f9b7-05af-48e0-a5b1-35432a01c6bf`),

}; !cmp.Equal(g, w) {

t.Errorf("row value mismatch for json array\nGot: %v\nWant: %v", g, w)

}

if g, w := len(pArray), 3; g != w {

t.Errorf("row value length mismatch for proto array\nGot: %v\nWant: %v", g, w)

}

wantSinger2ProtoEnum := pb.Genre_FOLK

wantSinger2ProtoMsg := pb.SingerInfo{

SingerId: proto.Int64(2),

BirthDate: proto.String("February"),

Nationality: proto.String("Country2"),

Genre: &wantSinger2ProtoEnum,

}

gotSingerProto1 := pb.SingerInfo{}

if err := proto.Unmarshal(pArray[0], &gotSingerProto1); err != nil {

t.Fatalf("failed to unmarshal proto: %v", err)

}

gotSingerProto2 := pb.SingerInfo{}

if err := proto.Unmarshal(pArray[2], &gotSingerProto2); err != nil {

t.Fatalf("failed to unmarshal proto: %v", err)

}

if g, w := &gotSingerProto1, &wantSingerProtoMsg; !cmp.Equal(g, w, cmpopts.IgnoreUnexported(pb.SingerInfo{})) {

t.Errorf("row value mismatch for proto\nGot: %v\nWant: %v", g, w)

}

if g, w := pArray[1], []byte(nil); !cmp.Equal(g, w) {

t.Errorf("row value mismatch for proto\nGot: %v\nWant: %v", g, w)

}

if g, w := &gotSingerProto2, &wantSinger2ProtoMsg; !cmp.Equal(g, w, cmpopts.IgnoreUnexported(pb.SingerInfo{})) {

t.Errorf("row value mismatch for proto\nGot: %v\nWant: %v", g, w)

}

}

if rows.Err() != nil {

t.Fatal(rows.Err())

}

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)

}

req := sqlRequests[0].(*sppb.ExecuteSqlRequest)

if g, w := len(req.ParamTypes), 22; g != w {

t.Fatalf("param types length mismatch\nGot: %v\nWant: %v", g, w)

}

if g, w := len(req.Params.Fields), 22; g != w {

t.Fatalf("params length mismatch\nGot: %v\nWant: %v", g, w)

}

wantParams := []struct {

name string

code sppb.TypeCode

array bool

value interface{}

}{

{

name: "bool",

code: sppb.TypeCode_BOOL,

value: true,

},

{

name: "string",

code: sppb.TypeCode_STRING,

value: "test",

},