chore: use exported BatchType from parser package (#514)

olavloite · web-flow · commit 04d384e9400e · 2025-09-10T01:03:11.000+05:30
Use the exported BatchType from the parser package instead of an unexported type.
This will allow us in the future to export functions to determine the batch type.
diff --git a/batch.go b/batch.go
@@ -14,17 +14,13 @@
 
 package spannerdriver
 
-import "cloud.google.com/go/spanner"
-
-type batchType int
-
-const (
-	ddl batchType = iota
-	dml
+import (
+	"cloud.google.com/go/spanner"
+	"github.com/googleapis/go-sql-spanner/parser"
 )
 
 type batch struct {
-	tp           batchType
+	tp           parser.BatchType
 	statements   []spanner.Statement
 	returnValues []int64
 	options      *ExecOptions
diff --git a/conn.go b/conn.go
@@ -528,11 +528,11 @@ func (c *conn) AbortBatch() error {
 }
 
 func (c *conn) InDDLBatch() bool {
-	return c.batch != nil && c.batch.tp == ddl
+	return c.batch != nil && c.batch.tp == parser.BatchTypeDdl
 }
 
 func (c *conn) InDMLBatch() bool {
-	return (c.batch != nil && c.batch.tp == dml) || (c.inReadWriteTransaction() && c.tx.(*readWriteTransaction).batch != nil)
+	return (c.batch != nil && c.batch.tp == parser.BatchTypeDml) || (c.inReadWriteTransaction() && c.tx.(*readWriteTransaction).batch != nil)
 }
 
 func (c *conn) GetBatchedStatements() []spanner.Statement {
@@ -554,7 +554,7 @@ func (c *conn) startBatchDDL() (driver.Result, error) {
 		return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "This connection has an active transaction. DDL batches in transactions are not supported."))
 	}
 	c.logger.Debug("started ddl batch")
-	c.batch = &batch{tp: ddl}
+	c.batch = &batch{tp: parser.BatchTypeDdl}
 	return driver.ResultNoRows, nil
 }
 
@@ -572,7 +572,7 @@ func (c *conn) startBatchDML(automatic bool) (driver.Result, error) {
 		return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "This connection has an active read-only transaction. Read-only transactions cannot execute DML batches."))
 	}
 	c.logger.Debug("starting dml batch outside transaction")
-	c.batch = &batch{tp: dml, options: execOptions}
+	c.batch = &batch{tp: parser.BatchTypeDml, options: execOptions}
 	return driver.ResultNoRows, nil
 }
 
@@ -585,9 +585,9 @@ func (c *conn) runBatch(ctx context.Context) (driver.Result, error) {
 		return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "This connection does not have an active batch"))
 	}
 	switch c.batch.tp {
-	case ddl:
+	case parser.BatchTypeDdl:
 		return c.runDDLBatch(ctx)
-	case dml:
+	case parser.BatchTypeDml:
 		return c.runDMLBatch(ctx)
 	default:
 		return nil, spanner.ToSpannerError(status.Errorf(codes.InvalidArgument, "Unknown batch type: %d", c.batch.tp))
@@ -622,10 +622,10 @@ func (c *conn) abortBatch() (driver.Result, error) {
 }
 
 func (c *conn) execDDL(ctx context.Context, statements ...spanner.Statement) (driver.Result, error) {
-	if c.batch != nil && c.batch.tp == dml {
+	if c.batch != nil && c.batch.tp == parser.BatchTypeDml {
 		return nil, spanner.ToSpannerError(status.Error(codes.FailedPrecondition, "This connection has an active DML batch"))
 	}
-	if c.batch != nil && c.batch.tp == ddl {
+	if c.batch != nil && c.batch.tp == parser.BatchTypeDdl {
 		c.batch.statements = append(c.batch.statements, statements...)
 		return driver.ResultNoRows, nil
 	}
diff --git a/driver_test.go b/driver_test.go
@@ -491,7 +491,7 @@ func TestConnection_Reset(t *testing.T) {
 		state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{
 			propertyCommitResponse.Key(): propertyCommitResponse.CreateTypedInitialValue(nil),
 		}),
-		batch: &batch{tp: dml},
+		batch: &batch{tp: parser.BatchTypeDml},
 		tx: &readOnlyTransaction{
 			logger: noopLogger,
 			close: func(_ txResult) {
@@ -569,11 +569,11 @@ func TestConn_StartBatchDdl(t *testing.T) {
 		wantErr bool
 	}{
 		{"Default", &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{})}, false},
-		{"In DDL batch", &conn{logger: noopLogger, batch: &batch{tp: ddl}, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{})}, true},
-		{"In DML batch", &conn{logger: noopLogger, batch: &batch{tp: dml}, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{})}, true},
+		{"In DDL batch", &conn{logger: noopLogger, batch: &batch{tp: parser.BatchTypeDdl}, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{})}, true},
+		{"In DML batch", &conn{logger: noopLogger, batch: &batch{tp: parser.BatchTypeDml}, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{})}, true},
 		{"In read/write transaction", &conn{logger: noopLogger, tx: &readWriteTransaction{}, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{})}, true},
 		{"In read-only transaction", &conn{logger: noopLogger, tx: &readOnlyTransaction{}, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{})}, true},
-		{"In read/write transaction with a DML batch", &conn{logger: noopLogger, tx: &readWriteTransaction{batch: &batch{tp: dml}}, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{})}, true},
+		{"In read/write transaction with a DML batch", &conn{logger: noopLogger, tx: &readWriteTransaction{batch: &batch{tp: parser.BatchTypeDml}}, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{})}, true},
 	} {
 		err := test.c.StartBatchDDL()
 		if test.wantErr {
@@ -598,11 +598,11 @@ func TestConn_StartBatchDml(t *testing.T) {
 		wantErr bool
 	}{
 		{"Default", &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{})}, false},
-		{"In DDL batch", &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{}), batch: &batch{tp: ddl}}, true},
-		{"In DML batch", &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{}), batch: &batch{tp: dml}}, true},
+		{"In DDL batch", &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{}), batch: &batch{tp: parser.BatchTypeDdl}}, true},
+		{"In DML batch", &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{}), batch: &batch{tp: parser.BatchTypeDml}}, true},
 		{"In read/write transaction", &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{}), tx: &readWriteTransaction{logger: noopLogger}}, false},
 		{"In read-only transaction", &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{}), tx: &readOnlyTransaction{logger: noopLogger}}, true},
-		{"In read/write transaction with a DML batch", &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{}), tx: &readWriteTransaction{logger: noopLogger, batch: &batch{tp: dml}}}, true},
+		{"In read/write transaction with a DML batch", &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{}), tx: &readWriteTransaction{logger: noopLogger, batch: &batch{tp: parser.BatchTypeDml}}}, true},
 	} {
 		err := test.c.StartBatchDML()
 		if test.wantErr {
@@ -629,7 +629,7 @@ func TestConn_NonDdlStatementsInDdlBatch(t *testing.T) {
 		parser: p,
 		logger: noopLogger,
 		state:  createInitialConnectionState(connectionstate.TypeNonTransactional, map[string]connectionstate.ConnectionPropertyValue{}),
-		batch:  &batch{tp: ddl},
+		batch:  &batch{tp: parser.BatchTypeDdl},
 		execSingleQuery: func(ctx context.Context, c *spanner.Client, statement spanner.Statement, tb spanner.TimestampBound, options *ExecOptions) *spanner.RowIterator {
 			return &spanner.RowIterator{}
 		},
@@ -669,7 +669,7 @@ func TestConn_NonDmlStatementsInDmlBatch(t *testing.T) {
 		parser: p,
 		logger: noopLogger,
 		state:  createInitialConnectionState(connectionstate.TypeNonTransactional, map[string]connectionstate.ConnectionPropertyValue{}),
-		batch:  &batch{tp: dml},
+		batch:  &batch{tp: parser.BatchTypeDml},
 		execSingleQuery: func(ctx context.Context, c *spanner.Client, statement spanner.Statement, tb spanner.TimestampBound, options *ExecOptions) *spanner.RowIterator {
 			return &spanner.RowIterator{}
 		},
diff --git a/transaction.go b/transaction.go
@@ -536,7 +536,7 @@ func (tx *readWriteTransaction) StartBatchDML(options spanner.QueryOptions, auto
 	}
 	tx.logger.Debug("starting dml batch in transaction", "automatic", automatic)
 	tx.active = true
-	tx.batch = &batch{tp: dml, options: &ExecOptions{QueryOptions: options}, automatic: automatic}
+	tx.batch = &batch{tp: parser.BatchTypeDml, options: &ExecOptions{QueryOptions: options}, automatic: automatic}
 	return driver.ResultNoRows, nil
 }
 
@@ -545,9 +545,9 @@ func (tx *readWriteTransaction) RunBatch(ctx context.Context) (driver.Result, er
 		return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "This transaction does not have an active batch"))
 	}
 	switch tx.batch.tp {
-	case dml:
+	case parser.BatchTypeDml:
 		return tx.runDmlBatch(ctx)
-	case ddl:
+	case parser.BatchTypeDdl:
 		fallthrough
 	default:
 		return nil, spanner.ToSpannerError(status.Errorf(codes.InvalidArgument, "Unknown or unsupported batch type: %d", tx.batch.tp))
@@ -558,7 +558,7 @@ func (tx *readWriteTransaction) RunDmlBatch(ctx context.Context) (SpannerResult,
 	if tx.batch == nil {
 		return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "this transaction does not have an active batch"))
 	}
-	if tx.batch.tp != dml {
+	if tx.batch.tp != parser.BatchTypeDml {
 		return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "batch is not a DML batch"))
 	}
 	return tx.runDmlBatch(ctx)

Original file line number	Diff line number	Diff line change
`@@ -528,11 +528,11 @@ func (c *conn) AbortBatch() error {`
`528`	`528`	`}`
`529`	`529`
`530`	`530`	`func (c *conn) InDDLBatch() bool {`
`531`		`- return c.batch != nil && c.batch.tp == ddl`
	`531`	`+ return c.batch != nil && c.batch.tp == parser.BatchTypeDdl`
`532`	`532`	`}`
`533`	`533`
`534`	`534`	`func (c *conn) InDMLBatch() bool {`
`535`		`- return (c.batch != nil && c.batch.tp == dml) \|\| (c.inReadWriteTransaction() && c.tx.(*readWriteTransaction).batch != nil)`
	`535`	`+ return (c.batch != nil && c.batch.tp == parser.BatchTypeDml) \|\| (c.inReadWriteTransaction() && c.tx.(*readWriteTransaction).batch != nil)`
`536`	`536`	`}`
`537`	`537`
`538`	`538`	`func (c *conn) GetBatchedStatements() []spanner.Statement {`
`@@ -554,7 +554,7 @@ func (c *conn) startBatchDDL() (driver.Result, error) {`
`554`	`554`	`return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "This connection has an active transaction. DDL batches in transactions are not supported."))`
`555`	`555`	`}`
`556`	`556`	`c.logger.Debug("started ddl batch")`
`557`		`- c.batch = &batch{tp: ddl}`
	`557`	`+ c.batch = &batch{tp: parser.BatchTypeDdl}`
`558`	`558`	`return driver.ResultNoRows, nil`
`559`	`559`	`}`
`560`	`560`
`@@ -572,7 +572,7 @@ func (c *conn) startBatchDML(automatic bool) (driver.Result, error) {`
`572`	`572`	`return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "This connection has an active read-only transaction. Read-only transactions cannot execute DML batches."))`
`573`	`573`	`}`
`574`	`574`	`c.logger.Debug("starting dml batch outside transaction")`
`575`		`- c.batch = &batch{tp: dml, options: execOptions}`
	`575`	`+ c.batch = &batch{tp: parser.BatchTypeDml, options: execOptions}`
`576`	`576`	`return driver.ResultNoRows, nil`
`577`	`577`	`}`
`578`	`578`
`@@ -585,9 +585,9 @@ func (c *conn) runBatch(ctx context.Context) (driver.Result, error) {`
`585`	`585`	`return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "This connection does not have an active batch"))`
`586`	`586`	`}`
`587`	`587`	`switch c.batch.tp {`
`588`		`- case ddl:`
	`588`	`+ case parser.BatchTypeDdl:`
`589`	`589`	`return c.runDDLBatch(ctx)`
`590`		`- case dml:`
	`590`	`+ case parser.BatchTypeDml:`
`591`	`591`	`return c.runDMLBatch(ctx)`
`592`	`592`	`default:`
`593`	`593`	`return nil, spanner.ToSpannerError(status.Errorf(codes.InvalidArgument, "Unknown batch type: %d", c.batch.tp))`
`@@ -622,10 +622,10 @@ func (c *conn) abortBatch() (driver.Result, error) {`
`622`	`622`	`}`
`623`	`623`
`624`	`624`	`func (c *conn) execDDL(ctx context.Context, statements ...spanner.Statement) (driver.Result, error) {`
`625`		`- if c.batch != nil && c.batch.tp == dml {`
	`625`	`+ if c.batch != nil && c.batch.tp == parser.BatchTypeDml {`
`626`	`626`	`return nil, spanner.ToSpannerError(status.Error(codes.FailedPrecondition, "This connection has an active DML batch"))`
`627`	`627`	`}`
`628`		`- if c.batch != nil && c.batch.tp == ddl {`
	`628`	`+ if c.batch != nil && c.batch.tp == parser.BatchTypeDdl {`
`629`	`629`	`c.batch.statements = append(c.batch.statements, statements...)`
`630`	`630`	`return driver.ResultNoRows, nil`
`631`	`631`	`}`
Original file line number	Diff line number	Diff line change
`@@ -536,7 +536,7 @@ func (tx *readWriteTransaction) StartBatchDML(options spanner.QueryOptions, auto`
`536`	`536`	`}`
`537`	`537`	`tx.logger.Debug("starting dml batch in transaction", "automatic", automatic)`
`538`	`538`	`tx.active = true`
`539`		`- tx.batch = &batch{tp: dml, options: &ExecOptions{QueryOptions: options}, automatic: automatic}`
	`539`	`+ tx.batch = &batch{tp: parser.BatchTypeDml, options: &ExecOptions{QueryOptions: options}, automatic: automatic}`
`540`	`540`	`return driver.ResultNoRows, nil`
`541`	`541`	`}`
`542`	`542`
`@@ -545,9 +545,9 @@ func (tx *readWriteTransaction) RunBatch(ctx context.Context) (driver.Result, er`
`545`	`545`	`return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "This transaction does not have an active batch"))`
`546`	`546`	`}`
`547`	`547`	`switch tx.batch.tp {`
`548`		`- case dml:`
	`548`	`+ case parser.BatchTypeDml:`
`549`	`549`	`return tx.runDmlBatch(ctx)`
`550`		`- case ddl:`
	`550`	`+ case parser.BatchTypeDdl:`
`551`	`551`	`fallthrough`
`552`	`552`	`default:`
`553`	`553`	`return nil, spanner.ToSpannerError(status.Errorf(codes.InvalidArgument, "Unknown or unsupported batch type: %d", tx.batch.tp))`
`@@ -558,7 +558,7 @@ func (tx *readWriteTransaction) RunDmlBatch(ctx context.Context) (SpannerResult,`
`558`	`558`	`if tx.batch == nil {`
`559`	`559`	`return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "this transaction does not have an active batch"))`
`560`	`560`	`}`
`561`		`- if tx.batch.tp != dml {`
	`561`	`+ if tx.batch.tp != parser.BatchTypeDml {`
`562`	`562`	`return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "batch is not a DML batch"))`
`563`	`563`	`}`
`564`	`564`	`return tx.runDmlBatch(ctx)`