chore: parse SET/SHOW statements with simple parser

Parse SET/SHOW statements using the simple parser. Any connection variable that
is not covered by a regular expression client-side statement, will be picked up
by this simple parser.

In a following step, all regex-based client-side statements will be removed, and
the parsing will happen using the simple parser. This further simplifies and
unifies all client-side statement parsing and handling, and makes all connection
variables transactional.

Author: olavloite

conn.go

@@ -268,6 +268,40 @@ func (c *conn) CommitResponse() (commitResponse *spanner.CommitResponse, err err
 	return c.commitResponse, nil
 }
 
+func (c *conn) showConnectionVariable(identifier identifier) (any, error) {
+	extension, name, err := toExtensionAndName(identifier)
+	if err != nil {
+		return nil, err
+	}
+	return c.state.GetValue(extension, name)
+}
+
+func (c *conn) setConnectionVariable(identifier identifier, value string, local bool) error {
+	extension, name, err := toExtensionAndName(identifier)
+	if err != nil {
+		return err
+	}
+	if local {
+		return c.state.SetLocalValue(extension, name, value)
+	}
+	return c.state.SetValue(extension, name, value, connectionstate.ContextUser)
+}
+
+func toExtensionAndName(identifier identifier) (string, string, error) {
+	var extension string
+	var name string
+	if len(identifier.parts) == 1 {
+		extension = ""
+		name = identifier.parts[0]
+	} else if len(identifier.parts) == 2 {
+		extension = identifier.parts[0]
+		name = identifier.parts[1]
+	} else {
+		return "", "", status.Errorf(codes.InvalidArgument, "invalid variable name: %s", identifier)
+	}
+	return extension, name, nil
+}
+
 func (c *conn) RetryAbortsInternally() bool {
 	return propertyRetryAbortsInternally.GetValueOrDefault(c.state)
 }

conn_with_mockserver_test.go

@@ -634,3 +634,150 @@ func TestConfigureConnectionProperty(t *testing.T) {
 		}
 	}
 }
+
+func TestSetAndShowWithExtension(t *testing.T) {
+	t.Parallel()
+
+	db, _, teardown := setupTestDBConnection(t)
+	defer teardown()
+	ctx := context.Background()
+
+	conn, err := db.Conn(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = conn.Close() }()
+
+	// Getting an unknown variable fails, even if it is a variable with an extension.
+	if _, err := conn.QueryContext(ctx, "show my_extension.my_property"); err == nil {
+		t.Fatal("missing expected error")
+	}
+
+	// Setting an unknown variable with an extension is allowed.
+	if _, err := conn.ExecContext(context.Background(), "set my_extension.my_property='my-value'"); err != nil {
+		t.Fatal(err)
+	}
+	it, err := conn.QueryContext(ctx, "show my_extension.my_property")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !it.Next() {
+		t.Fatal("expected it.Next to return true")
+	}
+	var val string
+	if err := it.Scan(&val); err != nil {
+		t.Fatal(err)
+	}
+	if g, w := val, "my-value"; g != w {
+		t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	if it.Next() {
+		t.Fatal("expected it.Next to return false")
+	}
+	if err := it.Close(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestSetAndShowIsolationLevel(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 func() { _ = conn.Close() }()
+
+	// Isolation level should start with 'Default'.
+	row := conn.QueryRowContext(ctx, "show isolation_level")
+	var val string
+	if err := row.Scan(&val); err != nil {
+		t.Fatal(err)
+	}
+	if g, w := val, sql.LevelDefault.String(); g != w {
+		t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+	}
+
+	// We can set the isolation level using a SET statement.
+	if _, err := conn.ExecContext(context.Background(), "set isolation_level = 'repeatable_read'"); err != nil {
+		t.Fatal(err)
+	}
+	// The isolation level should now be 'RepeatableRead'.
+	row = conn.QueryRowContext(ctx, "show isolation_level")
+	if err := row.Scan(&val); err != nil {
+		t.Fatal(err)
+	}
+	if g, w := val, sql.LevelRepeatableRead.String(); g != w {
+		t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	// Verify that this is also the value that the connection uses.
+	tx, err := conn.BeginTx(ctx, &sql.TxOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := tx.ExecContext(ctx, testutil.UpdateBarSetFoo); err != nil {
+		t.Fatal(err)
+	}
+	if err := tx.Commit(); err != nil {
+		t.Fatal(err)
+	}
+	requests := drainRequestsFromServer(server.TestSpanner)
+	executeRequests := requestsOfType(requests, reflect.TypeOf(&spannerpb.ExecuteSqlRequest{}))
+	if g, w := len(executeRequests), 1; g != w {
+		t.Fatalf("execute requests count mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	request := executeRequests[0].(*spannerpb.ExecuteSqlRequest)
+	wantIsolationLevel, _ := toProtoIsolationLevel(sql.LevelRepeatableRead)
+	if g, w := request.Transaction.GetBegin().GetIsolationLevel(), wantIsolationLevel; g != w {
+		t.Fatalf("begin isolation level mismatch\n Got: %v\nWant: %v", g, w)
+	}
+}
+
+func TestSetLocalIsolationLevel(t *testing.T) {
+	t.Skip("temporarily skipped, as transactions get their settings from the connection when the BeginTx call is done, instead of reading them when the transaction is actually started")
+	t.Parallel()
+
+	db, server, teardown := setupTestDBConnection(t)
+	defer teardown()
+	ctx := context.Background()
+
+	// Start a transaction without specifying the isolation level.
+	tx, err := db.BeginTx(ctx, &sql.TxOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// We can set the isolation level only for this transaction using a SET LOCAL statement.
+	if _, err := tx.ExecContext(context.Background(), "set local isolation_level = 'repeatable_read'"); err != nil {
+		t.Fatal(err)
+	}
+	// The isolation level should now be 'RepeatableRead'.
+	var val string
+	row := tx.QueryRowContext(ctx, "show isolation_level")
+	if err := row.Scan(&val); err != nil {
+		t.Fatal(err)
+	}
+	if g, w := val, sql.LevelRepeatableRead.String(); g != w {
+		t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	// Verify that the transaction actually uses the isolation level.
+	if _, err := tx.ExecContext(ctx, testutil.UpdateBarSetFoo); err != nil {
+		t.Fatal(err)
+	}
+	if err := tx.Commit(); err != nil {
+		t.Fatal(err)
+	}
+	requests := drainRequestsFromServer(server.TestSpanner)
+	executeRequests := requestsOfType(requests, reflect.TypeOf(&spannerpb.ExecuteSqlRequest{}))
+	if g, w := len(executeRequests), 1; g != w {
+		t.Fatalf("execute requests count mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	request := executeRequests[0].(*spannerpb.ExecuteSqlRequest)
+	wantIsolationLevel, _ := toProtoIsolationLevel(sql.LevelRepeatableRead)
+	if g, w := request.Transaction.GetBegin().GetIsolationLevel(), wantIsolationLevel; g != w {
+		t.Fatalf("begin isolation level mismatch\n Got: %v\nWant: %v", g, w)
+	}
+}

connectionstate/connection_property.go

@@ -55,6 +55,14 @@ type ConnectionProperty interface {
 	CreateDefaultValue() ConnectionPropertyValue
 	// CreateInitialValue creates an initial value of the property with the given value as the default and reset value.
 	CreateInitialValue(value any) (ConnectionPropertyValue, error)
+	// GetValue returns the current value of the property.
+	GetValue(state *ConnectionState) (any, error)
+	// SetUntypedValue sets a new value for the property without knowing the type in advance.
+	// This is a synonym for SetValue.
+	SetUntypedValue(state *ConnectionState, value any, context Context) error
+	// SetLocalUntypedValue sets a new local value for the property without knowing the type in advance.
+	// This is a synonym for SetLocalValue.
+	SetLocalUntypedValue(state *ConnectionState, value any) error
 	// Convert converts a string to the corresponding value type of the connection property.
 	Convert(value string) (any, error)
 }
@@ -155,6 +163,11 @@ func (p *TypedConnectionProperty[T]) Convert(value string) (any, error) {
 	return p.converter(value)
 }
 
+// GetValue implements ConnectionPropertyValue.GetValue
+func (p *TypedConnectionProperty[T]) GetValue(state *ConnectionState) (any, error) {
+	return p.GetValueOrError(state)
+}
+
 // GetValueOrDefault returns the current value of the property in the given ConnectionState.
 // It returns the default of the property if no value is found.
 func (p *TypedConnectionProperty[T]) GetValueOrDefault(state *ConnectionState) T {
@@ -202,6 +215,15 @@ func (p *TypedConnectionProperty[T]) ResetValue(state *ConnectionState, context
 	return p.setConnectionStateValue(state, typedResetValue /*isReset=*/, true, context)
 }
 
+// SetUntypedValue implements ConnectionProperty.SetUntypedValue.
+func (p *TypedConnectionProperty[T]) SetUntypedValue(state *ConnectionState, value any, context Context) error {
+	valueT, ok := value.(T)
+	if !ok {
+		return status.Errorf(codes.InvalidArgument, "invalid type for value: %T", value)
+	}
+	return p.SetValue(state, valueT, context)
+}
+
 // SetValue sets the value of the property in the given ConnectionState.
 //
 // The given Context should indicate the current context where the application tries to reset the value, e.g. it should
@@ -242,6 +264,15 @@ func (p *TypedConnectionProperty[T]) setConnectionStateValue(state *ConnectionSt
 	return nil
 }
 
+// SetLocalUntypedValue implements ConnectionProperty.SetLocalUntypedValue.
+func (p *TypedConnectionProperty[T]) SetLocalUntypedValue(state *ConnectionState, value any) error {
+	valueT, ok := value.(T)
+	if !ok {
+		return status.Errorf(codes.InvalidArgument, "invalid type for value: %T", value)
+	}
+	return p.SetLocalValue(state, valueT)
+}
+
 // SetLocalValue sets the local value of the property in the given ConnectionState. A local value is only visible
 // for the remainder of the current transaction. The value is reset to the value it had before the transaction when the
 // transaction ends, regardless whether the transaction committed or rolled back.
@@ -311,6 +342,8 @@ type ConnectionPropertyValue interface {
 	ConnectionProperty() ConnectionProperty
 	// Copy creates a shallow copy of the ConnectionPropertyValue.
 	Copy() ConnectionPropertyValue
+	// GetValue gets the current value of the property.
+	GetValue() (any, error)
 	// ClearValue removes the value of the property.
 	ClearValue(context Context) error
 	// SetValue sets the value of the property. The given value must be a valid value for the property.
@@ -350,6 +383,10 @@ func (v *connectionPropertyValue[T]) Copy() ConnectionPropertyValue {
 	}
 }
 
+func (v *connectionPropertyValue[T]) GetValue() (any, error) {
+	return v.value, nil
+}
+
 func (v *connectionPropertyValue[T]) ClearValue(context Context) error {
 	if v.connectionProperty.context < context {
 		return status.Errorf(codes.FailedPrecondition, "property has context %s and cannot be set in context %s", v.connectionProperty.context, context)

connectionstate/connection_state.go

@@ -110,6 +110,67 @@ func NewConnectionState(connectionStateType Type, properties map[string]Connecti
 	return state, nil
 }
 
+func toKey(extension, name string) (key string) {
+	if extension == "" {
+		key = name
+	} else {
+		key = name + "." + extension
+	}
+	return
+}
+
+func (cs *ConnectionState) GetValue(extension, name string) (any, error) {
+	prop, err := cs.findProperty(extension, name)
+	if err != nil {
+		return nil, err
+	}
+	return prop.GetValue(cs)
+}
+
+func (cs *ConnectionState) SetValue(extension, name, value string, context Context) error {
+	return cs.setValue(extension, name, value, context, false)
+}
+
+func (cs *ConnectionState) SetLocalValue(extension, name, value string) error {
+	return cs.setValue(extension, name, value, ContextUser, true)
+}
+
+func (cs *ConnectionState) setValue(extension, name, value string, context Context, local bool) error {
+	prop, err := cs.findProperty(extension, name)
+	if err != nil {
+		return err
+	}
+	convertedValue, err := prop.Convert(value)
+	if err != nil {
+		return err
+	}
+	if local {
+		return prop.SetLocalUntypedValue(cs, convertedValue)
+	}
+	return prop.SetUntypedValue(cs, convertedValue, context)
+}
+
+func (cs *ConnectionState) findProperty(extension, name string) (ConnectionProperty, error) {
+	key := toKey(extension, name)
+	var prop ConnectionProperty
+	existingValue, ok := cs.properties[key]
+	if !ok {
+		prop = &TypedConnectionProperty[string]{
+			key:       key,
+			extension: extension,
+			name:      name,
+			context:   ContextUser,
+			converter: ConvertString,
+		}
+		if extension == "" {
+			return nil, unknownPropertyErr(prop)
+		}
+	} else {
+		prop = existingValue.ConnectionProperty()
+	}
+	return prop, nil
+}
+
 // Begin starts a new transaction for this ConnectionState.
 func (cs *ConnectionState) Begin() error {
 	if cs.inTransaction {