add more command line switches for connection string management (#22)

* add more command line switches

* better defaults

Author: shueybubbles

README.md

@@ -17,8 +17,14 @@ We will be implementing command line switches and behaviors over time. Several s
     -When prompted, the user can type the password to complete a connection
 
 - `-R` switch will be removed. The go runtime does not provide access to user locale information, and it's not readily available through syscall on all supported platforms.
+- `-I` switch will be removed. To disable quoted identifier behavior, add `SET QUOTED IDENTIFIER OFF` in your scripts.
+- `-N` now takes a string value that can be one of `true`, `false`, or `disable` to specify the encryption choice. (`default` is the same as omitting the parameter)
+  - If `-N` and `-C` are not provided, sqlcmd will negotiate authentication with the server without validating the server certificate.
+  - If `-N` is provided but `-C` is not, sqlcmd will require validation of the server certificate. Note that a `false` value for encryption could still lead to encryption of the login packet.
+  - If both `-N` and `-C` are provided, sqlcmd will use their values for encryption negotiation.
+  - More information about client/server encryption negotiation can be found at <https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/60f56408-0188-4cd5-8b90-25c6f2423868>
 - Some behaviors that were kept to maintain compatibility with `OSQL` may be changed, such as alignment of column headers for some data types.
-- All commands must fit on one line, even `EXIT`. Interactive mode will not check for open parentheses or quotes for commands and prompt for successive lines. The native sqlcmd allows the query run by `EXIT(query)` to span multiple lines.
+- All commands must fit on one line, even `EXIT`. Interactive mode will not check for open parentheses or quotes for commands and prompt for successive lines. The ODBC sqlcmd allows the query run by `EXIT(query)` to span multiple lines.
 
 ### Azure Active Directory Authentication
 

cmd/sqlcmd/main.go

@@ -37,6 +37,20 @@ type SQLCmdArguments struct {
 	UseAad                      bool              `short:"G" xor:"auth" help:"Tells sqlcmd to use Active Directory authentication. If no user name is provided, authentication method ActiveDirectoryDefault is used. If a password is provided, ActiveDirectoryPassword is used. Otherwise ActiveDirectoryInteractive is used."`
 	DisableVariableSubstitution bool              `short:"x" help:"Causes sqlcmd to ignore scripting variables. This parameter is useful when a script contains many INSERT statements that may contain strings that have the same format as regular variables, such as $(variable_name)."`
 	Variables                   map[string]string `short:"v" help:"Creates a sqlcmd scripting variable that can be used in a sqlcmd script. Enclose the value in quotation marks if the value contains spaces. You can specify multiple var=values values. If there are errors in any of the values specified, sqlcmd generates an error message and then exits"`
+	PacketSize                  int               `short:"a" help:"Requests a packet of a different size. This option sets the sqlcmd scripting variable SQLCMDPACKETSIZE. packet_size must be a value between 512 and 32767. The default = 4096. A larger packet size can enhance performance for execution of scripts that have lots of SQL statements between GO commands. You can request a larger packet size. However, if the request is denied, sqlcmd uses the server default for packet size."`
+	LoginTimeout                int               `short:"l" default:"-1" help:"Specifies the number of seconds before a sqlcmd login to the go-mssqldb driver times out when you try to connect to a server. This option sets the sqlcmd scripting variable SQLCMDLOGINTIMEOUT. The default value is 30. 0 means infinite."`
+	WorkstationName             string            `short:"H" help:"This option sets the sqlcmd scripting variable SQLCMDWORKSTATION. The workstation name is listed in the hostname column of the sys.sysprocesses catalog view and can be returned using the stored procedure sp_who. If this option is not specified, the default is the current computer name. This name can be used to identify different sqlcmd sessions."`
+	ApplicationIntent           string            `short:"K" default:"default" enum:"default,ReadOnly" help:"Declares the application workload type when connecting to a server. The only currently supported value is ReadOnly. If -K is not specified, the sqlcmd utility will not support connectivity to a secondary replica in an Always On availability group."`
+	EncryptConnection           string            `short:"N" default:"default" enum:"default,false,true,disable" help:"This switch is used by the client to request an encrypted connection."`
+}
+
+// Validate accounts for settings not described by Kong attributes
+func (a *SQLCmdArguments) Validate() error {
+	if a.PacketSize != 0 && (a.PacketSize < 512 || a.PacketSize > 32767) {
+		return fmt.Errorf(`'-a %d': Packet size has to be a number between 512 and 32767.`, a.PacketSize)
+	}
+
+	return nil
 }
 
 // newArguments constructs a SQLCmdArguments instance with default values
@@ -87,8 +101,13 @@ func main() {
 // setVars initializes scripting variables from command line arguments
 func setVars(vars *sqlcmd.Variables, args *SQLCmdArguments) {
 	varmap := map[string]func(*SQLCmdArguments) string{
-		sqlcmd.SQLCMDDBNAME:       func(a *SQLCmdArguments) string { return a.DatabaseName },
-		sqlcmd.SQLCMDLOGINTIMEOUT: func(a *SQLCmdArguments) string { return "" },
+		sqlcmd.SQLCMDDBNAME: func(a *SQLCmdArguments) string { return a.DatabaseName },
+		sqlcmd.SQLCMDLOGINTIMEOUT: func(a *SQLCmdArguments) string {
+			if a.LoginTimeout > -1 {
+				return fmt.Sprint(a.LoginTimeout)
+			}
+			return ""
+		},
 		sqlcmd.SQLCMDUSEAAD: func(a *SQLCmdArguments) string {
 			if a.UseAad {
 				return "true"
@@ -101,10 +120,15 @@ func setVars(vars *sqlcmd.Variables, args *SQLCmdArguments) {
 			}
 			return ""
 		},
-		sqlcmd.SQLCMDWORKSTATION:       func(a *SQLCmdArguments) string { return "" },
-		sqlcmd.SQLCMDSERVER:            func(a *SQLCmdArguments) string { return a.Server },
-		sqlcmd.SQLCMDERRORLEVEL:        func(a *SQLCmdArguments) string { return "" },
-		sqlcmd.SQLCMDPACKETSIZE:        func(a *SQLCmdArguments) string { return "" },
+		sqlcmd.SQLCMDWORKSTATION: func(a *SQLCmdArguments) string { return args.WorkstationName },
+		sqlcmd.SQLCMDSERVER:      func(a *SQLCmdArguments) string { return a.Server },
+		sqlcmd.SQLCMDERRORLEVEL:  func(a *SQLCmdArguments) string { return "" },
+		sqlcmd.SQLCMDPACKETSIZE: func(a *SQLCmdArguments) string {
+			if args.PacketSize > 0 {
+				return fmt.Sprint(args.PacketSize)
+			}
+			return ""
+		},
 		sqlcmd.SQLCMDUSER:              func(a *SQLCmdArguments) string { return a.UserName },
 		sqlcmd.SQLCMDSTATTIMEOUT:       func(a *SQLCmdArguments) string { return "" },
 		sqlcmd.SQLCMDHEADERS:           func(a *SQLCmdArguments) string { return "" },
@@ -127,6 +151,22 @@ func setVars(vars *sqlcmd.Variables, args *SQLCmdArguments) {
 
 }
 
+func setConnect(s *sqlcmd.Sqlcmd, args *SQLCmdArguments) {
+	if !args.DisableCmdAndWarn {
+		s.Connect.Password = os.Getenv(sqlcmd.SQLCMDPASSWORD)
+	}
+	s.Connect.UseTrustedConnection = args.UseTrustedConnection
+	s.Connect.TrustServerCertificate = args.TrustServerCertificate
+	s.Connect.AuthenticationMethod = args.authenticationMethod(s.Connect.Password != "")
+	s.Connect.DisableEnvironmentVariables = args.DisableCmdAndWarn
+	s.Connect.DisableVariableSubstitution = args.DisableVariableSubstitution
+	s.Connect.ApplicationIntent = args.ApplicationIntent
+	s.Connect.LoginTimeoutSeconds = args.LoginTimeout
+	s.Connect.Encrypt = args.EncryptConnection
+	s.Connect.PacketSize = args.PacketSize
+	s.Connect.WorkstationName = args.WorkstationName
+}
+
 func run(vars *sqlcmd.Variables) (int, error) {
 	wd, err := os.Getwd()
 	if err != nil {
@@ -144,9 +184,7 @@ func run(vars *sqlcmd.Variables) (int, error) {
 	}
 
 	s := sqlcmd.New(line, wd, vars)
-	if !args.DisableCmdAndWarn {
-		s.Connect.Password = os.Getenv(sqlcmd.SQLCMDPASSWORD)
-	}
+
 	if args.BatchTerminator != "GO" {
 		err = s.Cmd.SetBatchTerminator(args.BatchTerminator)
 		if err != nil {
@@ -156,11 +194,8 @@ func run(vars *sqlcmd.Variables) (int, error) {
 	if err != nil {
 		return 1, err
 	}
-	s.Connect.UseTrustedConnection = args.UseTrustedConnection
-	s.Connect.TrustServerCertificate = args.TrustServerCertificate
-	s.Connect.AuthenticationMethod = args.authenticationMethod(s.Connect.Password != "")
-	s.Connect.DisableEnvironmentVariables = args.DisableCmdAndWarn
-	s.Connect.DisableVariableSubstitution = args.DisableVariableSubstitution
+
+	setConnect(s, &args)
 	s.Format = sqlcmd.NewSQLCmdDefaultFormatter(false)
 	if args.OutputFile != "" {
 		err = s.RunCommand(s.Cmd["OUT"], []string{args.OutputFile})

cmd/sqlcmd/main_test.go

@@ -60,7 +60,10 @@ func TestValidCommandLineToArgsConversion(t *testing.T) {
 		}},
 		// Notice no "" around the value with a space in it. It seems quotes get stripped out somewhere before Parse when invoking on a real command line
 		{[]string{"-v", "x=y", "-v", `y=a space`}, func(args SQLCmdArguments) bool {
-			return args.Variables["x"] == "y" && args.Variables["y"] == "a space"
+			return args.LoginTimeout == -1 && args.Variables["x"] == "y" && args.Variables["y"] == "a space"
+		}},
+		{[]string{"-a", "550", "-l", "45", "-H", "mystation", "-K", "ReadOnly", "-N", "true"}, func(args SQLCmdArguments) bool {
+			return args.PacketSize == 550 && args.LoginTimeout == 45 && args.WorkstationName == "mystation" && args.ApplicationIntent == "ReadOnly" && args.EncryptConnection == "true"
 		}},
 	}
 
@@ -86,6 +89,8 @@ func TestInvalidCommandLine(t *testing.T) {
 
 	commands := []cmdLineTest{
 		{[]string{"-E", "-U", "someuser"}, "--use-trusted-connection and --user-name can't be used together"},
+		// the test prefix is a kong artifact https://github.com/alecthomas/kong/issues/221
+		{[]string{"-a", "100"}, "test: '-a 100': Packet size has to be a number between 512 and 32767."},
 	}
 
 	for _, test := range commands {

pkg/sqlcmd/sqlcmd.go

@@ -45,6 +45,16 @@ type ConnectSettings struct {
 	DisableVariableSubstitution bool
 	// Password is the password used with SQL authentication
 	Password string
+	// Encrypt is the choice of encryption
+	Encrypt string
+	// PacketSize is the size of the packet for TDS communication
+	PacketSize int
+	// LoginTimeoutSeconds specifies the timeout for establishing a connection
+	LoginTimeoutSeconds int
+	// WorkstationName is the string to use to identify the host in server DMVs
+	WorkstationName string
+	// ApplicationIntent can only be empty or "ReadOnly"
+	ApplicationIntent string
 }
 
 func (c ConnectSettings) authenticationMethod() string {
@@ -233,6 +243,21 @@ func (s *Sqlcmd) ConnectionString() (connectionString string, err error) {
 	if s.Connect.TrustServerCertificate {
 		query.Add("trustservercertificate", "true")
 	}
+	if s.Connect.ApplicationIntent != "" && s.Connect.ApplicationIntent != "default" {
+		query.Add("applicationintent", s.Connect.ApplicationIntent)
+	}
+	if s.Connect.LoginTimeoutSeconds > 0 {
+		query.Add("connection timeout", fmt.Sprint(s.Connect.LoginTimeoutSeconds))
+	}
+	if s.Connect.PacketSize > 0 {
+		query.Add("packet size", fmt.Sprint(s.Connect.PacketSize))
+	}
+	if s.Connect.WorkstationName != "" {
+		query.Add("workstation id", s.Connect.WorkstationName)
+	}
+	if s.Connect.Encrypt != "" && s.Connect.Encrypt != "default" {
+		query.Add("encrypt", s.Connect.Encrypt)
+	}
 	connectionURL.RawQuery = query.Encode()
 	return connectionURL.String(), nil
 }

pkg/sqlcmd/sqlcmd_test.go

@@ -29,11 +29,18 @@ func TestConnectionStringFromSqlCmd(t *testing.T) {
 
 		{nil, nil, "sqlserver://."},
 		{
-			&ConnectSettings{TrustServerCertificate: true},
+			&ConnectSettings{TrustServerCertificate: true, WorkstationName: "mystation"},
 			func(vars *Variables) {
 				vars.Set(SQLCMDDBNAME, "somedatabase")
 			},
-			"sqlserver://.?database=somedatabase&trustservercertificate=true",
+			"sqlserver://.?database=somedatabase&trustservercertificate=true&workstation+id=mystation",
+		},
+		{
+			&ConnectSettings{WorkstationName: "mystation", Encrypt: "false"},
+			func(vars *Variables) {
+				vars.Set(SQLCMDDBNAME, "somedatabase")
+			},
+			"sqlserver://.?database=somedatabase&encrypt=false&workstation+id=mystation",
 		},
 		{
 			&ConnectSettings{TrustServerCertificate: true, Password: pwd},