Merge pull request #3005 from dolthub/angela/system_variables

Added support for `@@port`, `@@hostname`, and other system variables

Author: angelamayxie

enginetest/queries/variable_queries.go

@@ -22,12 +22,6 @@ import (
 )
 
 var VariableQueries = []ScriptTest{
-	{
-		Name:        "use string name for foreign_key checks",
-		SetUpScript: []string{},
-		Query:       "select @@GLOBAL.unknown",
-		ExpectedErr: sql.ErrUnknownSystemVariable,
-	},
 	{
 		Name:        "use string name for foreign_key checks",
 		SetUpScript: []string{},
@@ -649,6 +643,10 @@ var VariableQueries = []ScriptTest{
 }
 
 var VariableErrorTests = []QueryErrorTest{
+	{
+		Query:       "select @@GLOBAL.unknown",
+		ExpectedErr: sql.ErrUnknownSystemVariable,
+	},
 	{
 		Query:       "set @@does_not_exist = 100",
 		ExpectedErr: sql.ErrUnknownSystemVariable,

enginetest/server_engine_test.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"math"
 	"net"
+	"os"
 	"testing"
 
 	"github.com/dolthub/vitess/go/mysql"
@@ -375,3 +376,92 @@ func TestServerPreparedStatements(t *testing.T) {
 		})
 	}
 }
+
+func TestServerVariables(t *testing.T) {
+	hostname, herr := os.Hostname()
+	require.NoError(t, herr)
+
+	port, perr := findEmptyPort()
+	require.NoError(t, perr)
+
+	s, serr := initTestServer(port)
+	require.NoError(t, serr)
+
+	go s.Start()
+	defer s.Close()
+
+	tests := []serverScriptTest{
+		{
+			name:  "test that config system variables are properly set",
+			setup: []string{},
+			assertions: []serverScriptTestAssertion{
+				{
+					query:  "select @@hostname, @@port, @@net_read_timeout, @@net_write_timeout",
+					isExec: false,
+					expectedRows: []any{
+						sql.Row{hostname, port, 1, 1},
+					},
+					checkRows: func(t *testing.T, rows *gosql.Rows, expectedRows []any) (bool, error) {
+						var resHostname string
+						var resPort int
+						var resNetReadTimeout int
+						var resNetWriteTimeout int
+						var rowNum int
+						for rows.Next() {
+							if err := rows.Scan(&resHostname, &resPort, &resNetReadTimeout, &resNetWriteTimeout); err != nil {
+								return false, err
+							}
+							if rowNum >= len(expectedRows) {
+								return false, nil
+							}
+							expectedRow := expectedRows[rowNum].(sql.Row)
+							require.Equal(t, expectedRow[0].(string), resHostname)
+							require.Equal(t, expectedRow[1].(int), resPort)
+						}
+						return true, nil
+					},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			conn, cerr := dbr.Open("mysql", fmt.Sprintf(noUserFmt, address, port), nil)
+			require.NoError(t, cerr)
+			defer conn.Close()
+			commonSetup := []string{
+				"create database test_db;",
+				"use test_db;",
+			}
+			commonTeardown := []string{
+				"drop database test_db",
+			}
+			for _, stmt := range append(commonSetup, test.setup...) {
+				_, err := conn.Exec(stmt)
+				require.NoError(t, err)
+			}
+			for _, assertion := range test.assertions {
+				t.Run(assertion.query, func(t *testing.T) {
+					if assertion.skip {
+						t.Skip()
+					}
+					rows, err := conn.Query(assertion.query, assertion.args...)
+					if assertion.expectErr {
+						require.Error(t, err)
+						return
+					}
+					require.NoError(t, err)
+
+					ok, err := assertion.checkRows(t, rows, assertion.expectedRows)
+					require.NoError(t, err)
+					require.True(t, ok)
+				})
+			}
+			for _, stmt := range append(commonTeardown) {
+				_, err := conn.Exec(stmt)
+				require.NoError(t, err)
+			}
+		})
+	}
+}

server/server.go

@@ -18,6 +18,7 @@ import (
 	"errors"
 	"fmt"
 	"net"
+	"strconv"
 	"time"
 
 	"github.com/dolthub/vitess/go/mysql"
@@ -122,17 +123,42 @@ func portInUse(hostPort string) bool {
 	return false
 }
 
-func newServerFromHandler(cfg Config, e *sqle.Engine, sm *SessionManager, handler mysql.Handler, sel ServerEventListener) (*Server, error) {
-	if cfg.ConnReadTimeout < 0 {
-		cfg.ConnReadTimeout = 0
+func getPort(cfg mysql.ListenerConfig) (int64, error) {
+	_, port, err := net.SplitHostPort(cfg.Listener.Addr().String())
+	if err != nil {
+		return 0, err
+	}
+	portInt, err := strconv.ParseInt(port, 10, 64)
+	if err != nil {
+		return 0, err
+	}
+	return portInt, nil
+}
+
+func updateSystemVariables(cfg mysql.ListenerConfig) error {
+	sysVars := make(map[string]interface{})
+
+	if port, err := getPort(cfg); err == nil {
+		sysVars["port"] = port
 	}
-	if cfg.ConnWriteTimeout < 0 {
-		cfg.ConnWriteTimeout = 0
+
+	oneSecond := time.Duration(1) * time.Second
+	if cfg.ConnReadTimeout >= oneSecond {
+		sysVars["net_read_timeout"] = cfg.ConnReadTimeout.Seconds()
 	}
-	if cfg.MaxConnections < 0 {
-		cfg.MaxConnections = 0
+	if cfg.ConnWriteTimeout >= oneSecond {
+		sysVars["net_write_timeout"] = cfg.ConnWriteTimeout.Seconds()
 	}
 
+	// TODO: add the rest of the config variables
+	err := sql.SystemVariables.AssignValues(sysVars)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func newServerFromHandler(cfg Config, e *sqle.Engine, sm *SessionManager, handler mysql.Handler, sel ServerEventListener) (*Server, error) {
 	for _, opt := range cfg.Options {
 		e, sm, handler = opt(e, sm, handler)
 	}
@@ -176,6 +202,11 @@ func newServerFromHandler(cfg Config, e *sqle.Engine, sm *SessionManager, handle
 		return nil, err
 	}
 
+	err = updateSystemVariables(listenerCfg)
+	if err != nil {
+		return nil, err
+	}
+
 	return &Server{
 		Listener:   protocolListener,
 		handler:    handler,

server/server_config.go

@@ -116,14 +116,14 @@ func (c Config) NewConfig() (Config, error) {
 		if !ok {
 			return Config{}, sql.ErrUnknownSystemVariable.New("net_write_timeout")
 		}
-		c.ConnWriteTimeout = time.Duration(timeout) * time.Millisecond
+		c.ConnWriteTimeout = time.Duration(timeout) * time.Second
 	}
 	if _, val, ok := sql.SystemVariables.GetGlobal("net_read_timeout"); ok {
 		timeout, ok := val.(int64)
 		if !ok {
 			return Config{}, sql.ErrUnknownSystemVariable.New("net_read_timeout")
 		}
-		c.ConnReadTimeout = time.Duration(timeout) * time.Millisecond
+		c.ConnReadTimeout = time.Duration(timeout) * time.Second
 	}
 	return c, nil
 }

server/server_config_test.go

@@ -49,14 +49,14 @@ func TestConfigWithDefaults(t *testing.T) {
 			Type:        types.NewSystemIntType("net_write_timeout", 1, 9223372036854775807, false),
 			ConfigField: "ConnWriteTimeout",
 			Default:     int64(76),
-			ExpectedCmp: int64(76000000),
+			ExpectedCmp: int64(76000000000),
 		}, {
 			Name:        "net_read_timeout",
 			Scope:       sql.SystemVariableScope_Both,
 			Type:        types.NewSystemIntType("net_read_timeout", 1, 9223372036854775807, false),
 			ConfigField: "ConnReadTimeout",
 			Default:     int64(67),
-			ExpectedCmp: int64(67000000),
+			ExpectedCmp: int64(67000000000),
 		},
 	}
 

server/server_test.go

@@ -18,8 +18,8 @@ import (
 	gsql "github.com/dolthub/go-mysql-server/sql"
 )
 
-// TestSeverCustomListener verifies a caller can provide their own net.Conn implementation for the server to use
-func TestSeverCustomListener(t *testing.T) {
+// TestServerCustomListener verifies a caller can provide their own net.Conn implementation for the server to use
+func TestServerCustomListener(t *testing.T) {
 	dbName := "mydb"
 	// create a net.Conn thats based on a golang buffer
 	buffer := 1024

sql/variables/system_variables.go

@@ -17,6 +17,7 @@ package variables
 import (
 	"fmt"
 	"math"
+	"os"
 	"strings"
 	"sync"
 	"time"
@@ -186,6 +187,11 @@ func init() {
 	InitSystemVariables()
 }
 
+func getHostname() string {
+	hostname, _ := os.Hostname()
+	return hostname
+}
+
 // systemVars is the internal collection of all MySQL system variables according to the following pages:
 // https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html
 // https://dev.mysql.com/doc/refman/8.0/en/replication-options-gtids.html
@@ -1008,7 +1014,7 @@ var systemVars = map[string]sql.SystemVariable{
 		Dynamic:           false,
 		SetVarHintApplies: false,
 		Type:              types.NewSystemStringType("hostname"),
-		Default:           "",
+		Default:           getHostname(),
 	},
 	"immediate_server_version": &sql.MysqlSystemVariable{
 		Name:              "immediate_server_version",