Implement multi-line EXIT(query) support

In interactive mode, EXIT(query) can now span multiple lines when
parentheses are unbalanced. The shell prompts for continuation lines
until parentheses balance, matching ODBC sqlcmd behavior.

Changes:
- Add isExitParenBalanced() to check paren balance respecting quotes
- Add readExitContinuation() to prompt for additional lines
- Update exitCommand() to call continuation when needed
- Add TestIsExitParenBalanced tests
- Remove limitation note from README

Author: dlevy-msft-sql

README.md

@@ -134,7 +134,6 @@ The following switches have different behavior in this version of `sqlcmd` compa
   - More information about client/server encryption negotiation can be found at <https://docs.microsoft.com/openspecs/windows_protocols/ms-tds/60f56408-0188-4cd5-8b90-25c6f2423868>
 - `-u` The generated Unicode output file will have the UTF16 Little-Endian Byte-order mark (BOM) written to it.
 - 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 ODBC sqlcmd allows the query run by `EXIT(query)` to span multiple lines.
 - `-i` doesn't handle a comma `,` in a file name correctly unless the file name argument is triple quoted. For example:
   `sqlcmd -i """select,100.sql"""` will try to open a file named `sql,100.sql` while `sqlcmd -i "select,100.sql"` will try to open two files `select` and `100.sql`
 - If using a single `-i` flag  to pass multiple file names, there must be a space after the `-i`. Example: `-i file1.sql file2.sql`

pkg/sqlcmd/commands.go

@@ -208,10 +208,55 @@ func (c Commands) SetBatchTerminator(terminator string) error {
 	return nil
 }
 
+// isExitParenBalanced checks if the parentheses in an EXIT command argument are balanced.
+// It tracks quotes to avoid counting parens inside string literals.
+func isExitParenBalanced(s string) bool {
+	depth := 0
+	var quote rune
+	for _, c := range s {
+		switch {
+		case quote != 0:
+			// Inside a quoted string
+			if c == quote {
+				quote = 0
+			}
+		case c == '\'' || c == '"':
+			quote = c
+		case c == '[':
+			quote = ']' // SQL Server bracket quoting
+		case c == '(':
+			depth++
+		case c == ')':
+			depth--
+		}
+	}
+	return depth == 0
+}
+
+// readExitContinuation reads additional lines from the console until the EXIT
+// parentheses are balanced. This enables multi-line EXIT(query) in interactive mode.
+func readExitContinuation(s *Sqlcmd, params string) (string, error) {
+	var builder strings.Builder
+	builder.WriteString(params)
+
+	for !isExitParenBalanced(builder.String()) {
+		// Show continuation prompt
+		s.lineIo.SetPrompt("      -> ")
+		line, err := s.lineIo.Readline()
+		if err != nil {
+			return "", err
+		}
+		builder.WriteString(SqlcmdEol)
+		builder.WriteString(line)
+	}
+	return builder.String(), nil
+}
+
 // exitCommand has 3 modes.
 // With no (), it just exits without running any query
 // With () it runs whatever batch is in the buffer then exits
 // With any text between () it runs the text as a query then exits
+// In interactive mode, if parentheses are unbalanced, it prompts for continuation lines.
 func exitCommand(s *Sqlcmd, args []string, line uint) error {
 	if len(args) == 0 {
 		return ErrExitRequested
@@ -220,9 +265,29 @@ func exitCommand(s *Sqlcmd, args []string, line uint) error {
 	if params == "" {
 		return ErrExitRequested
 	}
-	if !strings.HasPrefix(params, "(") || !strings.HasSuffix(params, ")") {
+
+	// Check if we have an opening paren
+	if !strings.HasPrefix(params, "(") {
 		return InvalidCommandError("EXIT", line)
 	}
+
+	// If parentheses are unbalanced, try to read continuation lines (interactive mode only)
+	if !isExitParenBalanced(params) {
+		if s.lineIo == nil {
+			// Not in interactive mode, can't read more lines
+			return InvalidCommandError("EXIT", line)
+		}
+		var err error
+		params, err = readExitContinuation(s, params)
+		if err != nil {
+			return err
+		}
+	}
+
+	if !strings.HasSuffix(params, ")") {
+		return InvalidCommandError("EXIT", line)
+	}
+
 	// First we save the current batch
 	query1 := s.batch.String()
 	if len(query1) > 0 {

pkg/sqlcmd/commands_test.go

@@ -458,3 +458,31 @@ func TestExitCommandAppendsParameterToCurrentBatch(t *testing.T) {
 	}
 
 }
+func TestIsExitParenBalanced(t *testing.T) {
+	tests := []struct {
+		input    string
+		balanced bool
+	}{
+		{"()", true},
+		{"(select 1)", true},
+		{"(select 1", false},
+		{"(select (1 + 2))", true},
+		{"(select ')')", true},     // paren inside string
+		{"(select \"(\")", true},   // paren inside double-quoted string
+		{"(select [col)])", true},  // paren inside bracket-quoted identifier
+		{"(select 1) extra", true}, // balanced even with trailing text
+		{"((nested))", true},
+		{"((nested)", false},
+		{"", true},          // empty string is balanced
+		{"no parens", true}, // no parens is balanced
+		{"(", false},
+		{")", false},       // depth goes -1, not balanced
+		{"(test))", false}, // depth goes -1 at end
+	}
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			result := isExitParenBalanced(test.input)
+			assert.Equal(t, test.balanced, result, "isExitParenBalanced(%q)", test.input)
+		})
+	}
+}