chore: remove unused code (#764)

Author: olavloite

.github/workflows/unit-tests.yml

@@ -66,12 +66,12 @@ jobs:
           fi
 
       - name: staticcheck .
-        run: staticcheck -checks "inherit,-U1000" ./...
+        run: staticcheck ./...
 
       - name: staticcheck ./examples
         working-directory: ./examples
-        run: staticcheck -checks "inherit,-U1000" ./...
+        run: staticcheck ./...
 
       - name: staticcheck ./benchmarks
         working-directory: ./benchmarks
-        run: staticcheck -checks "inherit,-U1000" ./...
+        run: staticcheck ./...

conn.go

@@ -1468,10 +1468,6 @@ func (c *conn) setReadOnlyTransactionOptions(options *ReadOnlyTransactionOptions
 	}
 }
 
-func (c *conn) getReadOnlyTransactionOptions() ReadOnlyTransactionOptions {
-	return ReadOnlyTransactionOptions{TimestampBound: c.ReadOnlyStaleness(), BeginTransactionOption: c.convertDefaultBeginTransactionOption(propertyBeginTransactionOption.GetValueOrDefault(c.state))}
-}
-
 func (c *conn) setBatchReadOnlyTransactionOptions(options *BatchReadOnlyTransactionOptions) {
 	if options == nil {
 		return
@@ -1481,10 +1477,6 @@ func (c *conn) setBatchReadOnlyTransactionOptions(options *BatchReadOnlyTransact
 	}
 }
 
-func (c *conn) getBatchReadOnlyTransactionOptions() BatchReadOnlyTransactionOptions {
-	return BatchReadOnlyTransactionOptions{TimestampBound: c.ReadOnlyStaleness()}
-}
-
 // BeginReadOnlyTransaction is not part of the public API of the database/sql driver.
 // It is exported for internal reasons, and may receive breaking changes without prior notice.
 //

conn_with_mockserver_test.go

@@ -1418,6 +1418,7 @@ func TestGenericConnectionState_GoogleSQL(t *testing.T) {
 	verifyConnectionPropertyValue(t, conn, "max_commit_delay", "100ms")
 	// Verify that other connection variables have a default value.
 	verifyConnectionPropertyValue(t, conn, "auto_batch_dml", false)
+	verifyConnectionPropertyValue(t, conn, propertyTransactionDeferrable.Key(), false)
 
 	// Verify that changing a connection variable value outside a transaction works.
 	setConnectionPropertyValue(t, conn, "max_commit_delay", "50ms")

driver.go

@@ -688,6 +688,7 @@ func createConnector(d *Driver, connectorConfig ConnectorConfig) (*connector, er
 	assignPropertyValueIfExists(state, propertyDisableNativeMetrics, &config.DisableNativeMetrics)
 	assignPropertyValueIfExists(state, propertyDecodeToNativeArrays, &connectorConfig.DecodeToNativeArrays)
 	assignPropertyValueIfExists(state, propertyAutoConfigEmulator, &connectorConfig.AutoConfigEmulator)
+	assignPropertyValueIfExists(state, propertyConnectionStateType, &connectorConfig.ConnectionStateType)
 	assignPropertyValueIfExists(state, propertyIsolationLevel, &connectorConfig.IsolationLevel)
 	assignPropertyValueIfExists(state, propertyBeginTransactionOption, &connectorConfig.BeginTransactionOption)
 	assignPropertyValueIfExists(state, propertyStatementCacheSize, &connectorConfig.StatementCacheSize)

driver_test.go

@@ -278,6 +278,23 @@ func TestExtractDnsParts(t *testing.T) {
 			input:   "project/p/instances/i/databases/d",
 			wantErr: true,
 		},
+		{
+			input: "projects/p/instances/i/databases/d?connection_state_type=TRANSACTIONAL",
+			wantConnectorConfig: ConnectorConfig{
+				Project:  "p",
+				Instance: "i",
+				Database: "d",
+				Params: map[string]string{
+					"connection_state_type": "TRANSACTIONAL",
+				},
+				ConnectionStateType: connectionstate.TypeTransactional,
+			},
+			wantSpannerConfig: spanner.ClientConfig{
+				//lint:ignore SA1019 Needs a change that is backwards compatible
+				SessionPoolConfig: spanner.DefaultSessionPoolConfig,
+				UserAgent:         userAgent,
+			},
+		},
 	}
 	for _, tc := range tests {
 		t.Run(tc.input, func(t *testing.T) {
@@ -1053,3 +1070,20 @@ type ValuerNil struct {
 func (v ValuerNil) Value() (driver.Value, error) {
 	return v.Name, nil
 }
+
+func TestConnectionStateTypeInitialization(t *testing.T) {
+	dsn := "projects/p/instances/i/databases/d?connection_state_type=TRANSACTIONAL"
+	config, err := ExtractConnectorConfig(dsn)
+	if err != nil {
+		t.Fatalf("ExtractConnectorConfig failed: %v", err)
+	}
+
+	c, err := createConnector(&Driver{}, config)
+	if err != nil {
+		t.Fatalf("createConnector failed: %v", err)
+	}
+
+	if c.connectorConfig.ConnectionStateType != connectionstate.TypeTransactional {
+		t.Errorf("ConnectionStateType mismatch. Got: %v, Want: %v", c.connectorConfig.ConnectionStateType, connectionstate.TypeTransactional)
+	}
+}

driver_with_mockserver_test.go

@@ -38,6 +38,7 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/google/uuid"
+	"github.com/googleapis/go-sql-spanner/connectionstate"
 	"github.com/googleapis/go-sql-spanner/parser"
 	"github.com/googleapis/go-sql-spanner/testutil"
 	"google.golang.org/api/option"
@@ -3698,6 +3699,47 @@ func TestMaxSessions(t *testing.T) {
 	}
 }
 
+func TestConnectionStateType(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	db, _, teardown := setupTestDBConnectionWithParams(t, "connection_state_type=TRANSACTIONAL")
+	defer teardown()
+
+	c, err := db.Conn(ctx)
+	if err != nil {
+		t.Fatalf("failed to get a connection: %v", err)
+	}
+
+	verifyConnectionPropertyValue(t, c, "connection_state_type", connectionstate.TypeTransactional)
+	// Check that the behavior is actually transactional.
+	verifyConnectionPropertyValue(t, c, "data_boost_enabled", false)
+	tx, err := c.BeginTx(ctx, nil)
+	if err != nil {
+		t.Fatalf("failed to begin transaction: %v", err)
+	}
+	if _, err := tx.ExecContext(ctx, "set data_boost_enabled = true"); err != nil {
+		t.Fatalf("failed to set data_boost_enabled: %v", err)
+	}
+	if err := tx.Commit(); err != nil {
+		t.Fatalf("failed to commit transaction: %v", err)
+	}
+	verifyConnectionPropertyValue(t, c, "data_boost_enabled", true)
+
+	tx, err = c.BeginTx(ctx, nil)
+	if err != nil {
+		t.Fatalf("failed to begin transaction: %v", err)
+	}
+	if _, err := tx.ExecContext(ctx, "set data_boost_enabled = false"); err != nil {
+		t.Fatalf("failed to set data_boost_enabled: %v", err)
+	}
+	// Rolling back the transaction should also roll back the change to data_boost_enabled.
+	if err := tx.Rollback(); err != nil {
+		t.Fatalf("failed to rollback transaction: %v", err)
+	}
+	verifyConnectionPropertyValue(t, c, "data_boost_enabled", true)
+}
+
 func TestClientReuse(t *testing.T) {
 	// This test is intentionally not parallel, as the internal caching of clients could
 	// be impacted by other parallel tests.
@@ -5821,13 +5863,6 @@ func date(v string) civil.Date {
 	return res
 }
 
-func nullDate(valid bool, v string) spanner.NullDate {
-	if !valid {
-		return spanner.NullDate{}
-	}
-	return spanner.NullDate{Valid: true, Date: date(v)}
-}
-
 func nullJson(valid bool, v string) spanner.NullJSON {
 	if !valid {
 		return spanner.NullJSON{}
@@ -5969,28 +6004,3 @@ func filterBeginReadOnlyRequests(requests []interface{}) []*sppb.BeginTransactio
 	}
 	return res
 }
-
-func waitFor(t *testing.T, assert func() error) {
-	t.Helper()
-	timeout := 5 * time.Second
-	ta := time.After(timeout)
-
-	for {
-		select {
-		case <-ta:
-			if err := assert(); err != nil {
-				t.Fatalf("after %v waiting, got %v", timeout, err)
-			}
-			return
-		default:
-		}
-
-		if err := assert(); err != nil {
-			// Fail. Let's pause and retry.
-			time.Sleep(time.Millisecond)
-			continue
-		}
-
-		return
-	}
-}

integration_test.go

@@ -315,12 +315,6 @@ func skipIfShort(t *testing.T) {
 	}
 }
 
-func skipIfEmulator(t *testing.T, msg string) {
-	if runsOnEmulator() {
-		t.Skip(msg)
-	}
-}
-
 func TestAutoConfigEmulator(t *testing.T) {
 	skipIfShort(t)
 	if !runsOnEmulator() {

merged_row_iterator.go

@@ -168,12 +168,6 @@ func (m *mergedRowIterator) produceRowsFromPartition(ctx context.Context, index
 	}
 }
 
-func (m *mergedRowIterator) isStopped() bool {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	return m.err != nil
-}
-
 func (m *mergedRowIterator) hasErr() bool {
 	m.mu.Lock()
 	defer m.mu.Unlock()

parser/simple_parser.go

@@ -180,10 +180,6 @@ func (p *simpleParser) isValidIdentifierChar() bool {
 	return p.sql[p.pos] == '_' || p.sql[p.pos] == '$' || isLatinLetter(p.sql[p.pos]) || isLatinDigit(p.sql[p.pos])
 }
 
-func (p *simpleParser) isValidDollarTagIdentifierChar() bool {
-	return p.isValidIdentifierChar() && !p.isDollar()
-}
-
 func (p *simpleParser) isDollar() bool {
 	return !p.isMultibyte() && p.sql[p.pos] == '$'
 }

parser/statement_parser.go

@@ -717,26 +717,10 @@ func isDDLKeyword(keyword string) bool {
 	return isStatementKeyword(keyword, ddlStatements)
 }
 
-// isDml returns true if the given sql string is a Dml statement.
-// This function assumes that any comments and hints at the start
-// of the sql string have been removed.
-func (p *StatementParser) isDml(query string) bool {
-	info := p.DetectStatementType(query)
-	return info.StatementType == StatementTypeDml
-}
-
 func isDmlKeyword(keyword string) bool {
 	return isStatementKeyword(keyword, dmlStatements)
 }
 
-// isQuery returns true if the given sql string is a SELECT statement.
-// This function assumes that any comments and hints at the start
-// of the sql string have been removed.
-func (p *StatementParser) isQuery(query string) bool {
-	info := p.DetectStatementType(query)
-	return info.StatementType == StatementTypeQuery
-}
-
 func isQueryKeyword(keyword string) bool {
 	return isStatementKeyword(keyword, selectStatements)
 }