chore: cache parsed statements and remove regex loading (#512)

Cache parsed statements and remove loading and checking for regex-based statements,
as the latter is no an empty list.

Author: olavloite

client_side_statement.go

@@ -15,49 +15,13 @@
 package spannerdriver
 
 import (
-	"context"
-	"database/sql/driver"
 	"time"
 
 	"cloud.google.com/go/spanner"
 	"cloud.google.com/go/spanner/apiv1/spannerpb"
 	"google.golang.org/api/iterator"
 )
 
-// statementExecutor is an empty struct that is used to hold the execution methods
-// of the different client side statements. This makes it possible to look up the
-// methods using reflection, which is not possible if the methods do not belong to
-// a struct. The methods all accept the same arguments and return the same types.
-// This is to ensure that they can be assigned to a compiled clientSideStatement.
-//
-// The different methods of statementExecutor are invoked by a connection when one
-// of the valid client side statements is executed on a connection. These methods
-// are responsible for any argument parsing and translating that might be needed
-// before the corresponding method on the connection can be called.
-//
-// The names of the methods are exactly equal to the naming in the
-// client_side_statements.json file. This means that some methods do not adhere
-// to the Go style guide, as these method names are equal for all languages that
-// implement the Connection API.
-type statementExecutor struct {
-}
-
-func (s *statementExecutor) StartBatchDdl(_ context.Context, c *conn, _ string, _ *ExecOptions, _ []driver.NamedValue) (driver.Result, error) {
-	return c.startBatchDDL()
-}
-
-func (s *statementExecutor) StartBatchDml(_ context.Context, c *conn, _ string, _ *ExecOptions, _ []driver.NamedValue) (driver.Result, error) {
-	return c.startBatchDML( /* automatic = */ false)
-}
-
-func (s *statementExecutor) RunBatch(ctx context.Context, c *conn, _ string, _ *ExecOptions, _ []driver.NamedValue) (driver.Result, error) {
-	return c.runBatch(ctx)
-}
-
-func (s *statementExecutor) AbortBatch(_ context.Context, c *conn, _ string, _ *ExecOptions, _ []driver.NamedValue) (driver.Result, error) {
-	return c.abortBatch()
-}
-
 func createEmptyIterator() *clientSideIterator {
 	return &clientSideIterator{
 		metadata: &spannerpb.ResultSetMetadata{

client_side_statement_test.go

@@ -36,23 +36,27 @@ import (
 func TestStatementExecutor_StartBatchDdl(t *testing.T) {
 	t.Parallel()
 
-	c := &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeNonTransactional, map[string]connectionstate.ConnectionPropertyValue{})}
-	s := &statementExecutor{}
+	parser, _ := newStatementParser(databasepb.DatabaseDialect_GOOGLE_STANDARD_SQL, 1000)
+	c := &conn{
+		logger: noopLogger,
+		state:  createInitialConnectionState(connectionstate.TypeNonTransactional, map[string]connectionstate.ConnectionPropertyValue{}),
+		parser: parser,
+	}
 	ctx := context.Background()
 
 	if c.InDDLBatch() {
 		t.Fatal("connection unexpectedly in a DDL batch")
 	}
-	if _, err := s.StartBatchDdl(ctx, c, "", &ExecOptions{}, nil); err != nil {
+	if _, err := c.ExecContext(ctx, "start batch ddl", []driver.NamedValue{}); err != nil {
 		t.Fatalf("could not start a DDL batch: %v", err)
 	}
 	if !c.InDDLBatch() {
 		t.Fatal("connection unexpectedly not in a DDL batch")
 	}
-	if _, err := s.StartBatchDdl(ctx, c, "", &ExecOptions{}, nil); spanner.ErrCode(err) != codes.FailedPrecondition {
+	if _, err := c.ExecContext(ctx, "start batch ddl", []driver.NamedValue{}); spanner.ErrCode(err) != codes.FailedPrecondition {
 		t.Fatalf("error mismatch for starting a DDL batch while already in a batch\nGot: %v\nWant: %v", spanner.ErrCode(err), codes.FailedPrecondition)
 	}
-	if _, err := s.RunBatch(ctx, c, "", &ExecOptions{}, nil); err != nil {
+	if _, err := c.ExecContext(ctx, "run batch", []driver.NamedValue{}); err != nil {
 		t.Fatalf("could not run empty DDL batch: %v", err)
 	}
 	if c.InDDLBatch() {
@@ -61,31 +65,35 @@ func TestStatementExecutor_StartBatchDdl(t *testing.T) {
 
 	// Starting a DDL batch while the connection is in a transaction is not allowed.
 	c.tx = &readWriteTransaction{}
-	if _, err := s.StartBatchDdl(ctx, c, "", &ExecOptions{}, nil); spanner.ErrCode(err) != codes.FailedPrecondition {
+	if _, err := c.ExecContext(ctx, "start batch ddl", []driver.NamedValue{}); spanner.ErrCode(err) != codes.FailedPrecondition {
 		t.Fatalf("error mismatch for starting a DDL batch while in a transaction\nGot: %v\nWant: %v", spanner.ErrCode(err), codes.FailedPrecondition)
 	}
 }
 
 func TestStatementExecutor_StartBatchDml(t *testing.T) {
 	t.Parallel()
 
-	c := &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeNonTransactional, map[string]connectionstate.ConnectionPropertyValue{})}
-	s := &statementExecutor{}
+	parser, _ := newStatementParser(databasepb.DatabaseDialect_GOOGLE_STANDARD_SQL, 1000)
+	c := &conn{
+		logger: noopLogger,
+		state:  createInitialConnectionState(connectionstate.TypeNonTransactional, map[string]connectionstate.ConnectionPropertyValue{}),
+		parser: parser,
+	}
 	ctx := context.Background()
 
 	if c.InDMLBatch() {
 		t.Fatal("connection unexpectedly in a DML batch")
 	}
-	if _, err := s.StartBatchDml(ctx, c, "", &ExecOptions{}, nil); err != nil {
+	if _, err := c.ExecContext(ctx, "start batch dml", []driver.NamedValue{}); err != nil {
 		t.Fatalf("could not start a DML batch: %v", err)
 	}
 	if !c.InDMLBatch() {
 		t.Fatal("connection unexpectedly not in a DML batch")
 	}
-	if _, err := s.StartBatchDml(ctx, c, "", &ExecOptions{}, nil); spanner.ErrCode(err) != codes.FailedPrecondition {
+	if _, err := c.ExecContext(ctx, "start batch dml", []driver.NamedValue{}); spanner.ErrCode(err) != codes.FailedPrecondition {
 		t.Fatalf("error mismatch for starting a DML batch while already in a batch\nGot: %v\nWant: %v", spanner.ErrCode(err), codes.FailedPrecondition)
 	}
-	if _, err := s.RunBatch(ctx, c, "", &ExecOptions{}, nil); err != nil {
+	if _, err := c.ExecContext(ctx, "run batch", []driver.NamedValue{}); err != nil {
 		t.Fatalf("could not run empty DML batch: %v", err)
 	}
 	if c.InDMLBatch() {
@@ -94,13 +102,13 @@ func TestStatementExecutor_StartBatchDml(t *testing.T) {
 
 	// Starting a DML batch while the connection is in a read-only transaction is not allowed.
 	c.tx = &readOnlyTransaction{logger: noopLogger}
-	if _, err := s.StartBatchDml(ctx, c, "", &ExecOptions{}, nil); spanner.ErrCode(err) != codes.FailedPrecondition {
+	if _, err := c.ExecContext(ctx, "start batch dml", []driver.NamedValue{}); spanner.ErrCode(err) != codes.FailedPrecondition {
 		t.Fatalf("error mismatch for starting a DML batch while in a read-only transaction\nGot: %v\nWant: %v", spanner.ErrCode(err), codes.FailedPrecondition)
 	}
 
 	// Starting a DML batch while the connection is in a read/write transaction is allowed.
 	c.tx = &readWriteTransaction{logger: noopLogger}
-	if _, err := s.StartBatchDml(ctx, c, "", &ExecOptions{}, nil); err != nil {
+	if _, err := c.ExecContext(ctx, "start batch dml", []driver.NamedValue{}); err != nil {
 		t.Fatalf("could not start a DML batch while in a read/write transaction: %v", err)
 	}
 }