Implement -R flag for regional settings

- Add RegionalSettings struct with locale-aware formatting for numbers,
  currency, dates, and times
- Detect user locale from Windows LCID or Unix environment variables
- Apply regional formatting to DECIMAL, NUMERIC, MONEY, SMALLMONEY,
  DATE, TIME, DATETIME, DATETIME2, DATETIMEOFFSET types
- Add comprehensive tests for regional formatting
- Update README to document the -R flag behavior

This enables customers migrating from ODBC sqlcmd to see the same
locale-aware output formatting when using the -R flag.

Author: dlevy-msft-sql

README.md

@@ -122,7 +122,7 @@ The `sqlcmd` project aims to be a complete port of the original ODBC sqlcmd to t
 - There are new posix-style versions of each flag, such as `--input-file` for `-i`. `sqlcmd -?` will print those parameter names. Those new names do not preserve backward compatibility with ODBC `sqlcmd`. For example, to specify multiple input file names using `--input-file`, the file names must be comma-delimited, not space-delimited.
 
 The following switches have different behavior in this version of `sqlcmd` compared to the original ODBC based `sqlcmd`.
-- `-R` switch is ignored. The go runtime does not provide access to user locale information, and it's not readily available through syscall on all supported platforms.
+- `-R` switch enables regional formatting for numeric, currency, and date/time values based on the user's locale. Formatting includes locale-specific thousand separators for numbers, and locale-specific date/time formats. On Windows, the user's default locale is detected from system settings. On Linux/macOS, the locale is detected from environment variables (`LC_ALL`, `LC_MESSAGES`, `LANG`).
 - `-I` switch is ignored; quoted identifiers are always set on. To disable quoted identifier behavior, add `SET QUOTED IDENTIFIER OFF` in your scripts.
 - `-N` now takes an optional string value that can be one of `s[trict]`,`t[rue]`,`m[andatory]`, `yes`,`1`, `o[ptional]`,`no`, `0`, `f[alse]`, or `disable` to specify the encryption choice.
   - If `-N` is passed but no value is provided, `true` is used.

cmd/sqlcmd/sqlcmd.go

@@ -84,6 +84,7 @@ type SQLCmdArguments struct {
 	TraceFile                   string
 	CodePage                    string
 	ListCodePages               bool
+	UseRegionalSettings         bool
 	// Keep Help at the end of the list
 	Help bool
 }
@@ -489,7 +490,7 @@ func setFlags(rootCmd *cobra.Command, args *SQLCmdArguments) {
 	rootCmd.Flags().StringVarP(&args.ListServers, listServers, "L", "", localizer.Sprintf("%s List servers. Pass %s to omit 'Servers:' output.", "-L[c]", "c"))
 	rootCmd.Flags().BoolVarP(&args.DedicatedAdminConnection, "dedicated-admin-connection", "A", false, localizer.Sprintf("Dedicated administrator connection"))
 	_ = rootCmd.Flags().BoolP("enable-quoted-identifiers", "I", true, localizer.Sprintf("Provided for backward compatibility. Quoted identifiers are always enabled"))
-	_ = rootCmd.Flags().BoolP("client-regional-setting", "R", false, localizer.Sprintf("Provided for backward compatibility. Client regional settings are not used"))
+	rootCmd.Flags().BoolVarP(&args.UseRegionalSettings, "client-regional-setting", "R", false, localizer.Sprintf("Use client regional settings for currency, date, and time formatting"))
 	_ = rootCmd.Flags().IntP(removeControlCharacters, "k", 0, localizer.Sprintf("%s Remove control characters from output. Pass 1 to substitute a space per character, 2 for a space per consecutive characters", "-k [1|2]"))
 	rootCmd.Flags().BoolVarP(&args.EchoInput, "echo-input", "e", false, localizer.Sprintf("Echo input"))
 	rootCmd.Flags().IntVarP(&args.QueryTimeout, "query-timeout", "t", 0, "Query timeout")
@@ -856,7 +857,7 @@ func run(vars *sqlcmd.Variables, args *SQLCmdArguments) (int, error) {
 	}
 
 	s.Connect = &connectConfig
-	s.Format = sqlcmd.NewSQLCmdDefaultFormatter(args.TrimSpaces, args.getControlCharacterBehavior())
+	s.Format = sqlcmd.NewSQLCmdDefaultFormatterWithRegional(args.TrimSpaces, args.getControlCharacterBehavior(), args.UseRegionalSettings)
 	if args.OutputFile != "" {
 		err = s.RunCommand(s.Cmd["OUT"], []string{args.OutputFile})
 		if err != nil {

pkg/sqlcmd/format.go

@@ -85,15 +85,23 @@ type sqlCmdFormatterType struct {
 	maxColNameLen        int
 	colorizer            color.Colorizer
 	xml                  bool
+	regional             *RegionalSettings
 }
 
 // NewSQLCmdDefaultFormatter returns a Formatter that mimics the original ODBC-based sqlcmd formatter
 func NewSQLCmdDefaultFormatter(removeTrailingSpaces bool, ccb ControlCharacterBehavior) Formatter {
+	return NewSQLCmdDefaultFormatterWithRegional(removeTrailingSpaces, ccb, false)
+}
+
+// NewSQLCmdDefaultFormatterWithRegional returns a Formatter with optional regional settings support
+// When useRegionalSettings is true, numeric and date/time values are formatted according to the user's locale
+func NewSQLCmdDefaultFormatterWithRegional(removeTrailingSpaces bool, ccb ControlCharacterBehavior, useRegionalSettings bool) Formatter {
 	return &sqlCmdFormatterType{
 		removeTrailingSpaces: removeTrailingSpaces,
 		format:               "horizontal",
 		colorizer:            color.New(false),
 		ccb:                  ccb,
+		regional:             NewRegionalSettings(useRegionalSettings),
 	}
 }
 
@@ -478,11 +486,12 @@ func (f *sqlCmdFormatterType) scanRow(rows *sql.Rows) ([]string, error) {
 		if *j == nil {
 			row[n] = "NULL"
 		} else {
+			typeName := f.columnDetails[n].col.DatabaseTypeName()
 			switch x := (*j).(type) {
 			case []byte:
 				if isBinaryDataType(&f.columnDetails[n].col) {
 					row[n] = decodeBinary(x)
-				} else if f.columnDetails[n].col.DatabaseTypeName() == "UNIQUEIDENTIFIER" {
+				} else if typeName == "UNIQUEIDENTIFIER" {
 					// Unscramble the guid
 					// see https://github.com/denisenkom/go-mssqldb/issues/56
 					x[0], x[1], x[2], x[3] = x[3], x[2], x[1], x[0]
@@ -498,28 +507,55 @@ func (f *sqlCmdFormatterType) scanRow(rows *sql.Rows) ([]string, error) {
 					row[n] = string(x)
 				}
 			case string:
-				row[n] = x
+				// Apply regional formatting for DECIMAL/NUMERIC/MONEY when represented as string
+				if f.regional.IsEnabled() {
+					switch typeName {
+					case "DECIMAL", "NUMERIC":
+						row[n] = f.regional.FormatNumber(x)
+					case "MONEY", "SMALLMONEY":
+						row[n] = f.regional.FormatMoney(x)
+					default:
+						row[n] = x
+					}
+				} else {
+					row[n] = x
+				}
 			case time.Time:
-				// Go lacks any way to get the user's preferred time format or even the system default
-				switch f.columnDetails[n].col.DatabaseTypeName() {
-				case "DATE":
-					row[n] = x.Format("2006-01-02")
-				case "DATETIME":
-					row[n] = x.Format(dateTimeFormatString(3, false))
-				case "DATETIME2":
-					row[n] = x.Format(dateTimeFormatString(f.columnDetails[n].scale, false))
-				case "SMALLDATETIME":
-					row[n] = x.Format(dateTimeFormatString(0, false))
-				case "DATETIMEOFFSET":
-					row[n] = x.Format(dateTimeFormatString(f.columnDetails[n].scale, true))
-				case "TIME":
-					format := "15:04:05"
-					if f.columnDetails[n].scale > 0 {
-						format = fmt.Sprintf("%s.%0*d", format, f.columnDetails[n].scale, 0)
+				// Apply regional formatting when -R is enabled
+				if f.regional.IsEnabled() {
+					switch typeName {
+					case "DATE":
+						row[n] = f.regional.FormatDate(x)
+					case "DATETIME", "DATETIME2", "SMALLDATETIME":
+						row[n] = f.regional.FormatDateTime(x, f.columnDetails[n].scale, false)
+					case "DATETIMEOFFSET":
+						row[n] = f.regional.FormatDateTime(x, f.columnDetails[n].scale, true)
+					case "TIME":
+						row[n] = f.regional.FormatTime(x, f.columnDetails[n].scale)
+					default:
+						row[n] = x.Format(time.RFC3339)
+					}
+				} else {
+					switch typeName {
+					case "DATE":
+						row[n] = x.Format("2006-01-02")
+					case "DATETIME":
+						row[n] = x.Format(dateTimeFormatString(3, false))
+					case "DATETIME2":
+						row[n] = x.Format(dateTimeFormatString(f.columnDetails[n].scale, false))
+					case "SMALLDATETIME":
+						row[n] = x.Format(dateTimeFormatString(0, false))
+					case "DATETIMEOFFSET":
+						row[n] = x.Format(dateTimeFormatString(f.columnDetails[n].scale, true))
+					case "TIME":
+						format := "15:04:05"
+						if f.columnDetails[n].scale > 0 {
+							format = fmt.Sprintf("%s.%0*d", format, f.columnDetails[n].scale, 0)
+						}
+						row[n] = x.Format(format)
+					default:
+						row[n] = x.Format(time.RFC3339)
 					}
-					row[n] = x.Format(format)
-				default:
-					row[n] = x.Format(time.RFC3339)
 				}
 			case fmt.Stringer:
 				row[n] = x.String()
@@ -532,7 +568,21 @@ func (f *sqlCmdFormatterType) scanRow(rows *sql.Rows) ([]string, error) {
 				}
 			default:
 				var err error
-				if row[n], err = fmt.Sprintf("%v", x), nil; err != nil {
+				val := fmt.Sprintf("%v", x)
+				// Apply regional formatting for numeric types
+				if f.regional.IsEnabled() {
+					switch typeName {
+					case "DECIMAL", "NUMERIC":
+						row[n] = f.regional.FormatNumber(val)
+					case "MONEY", "SMALLMONEY":
+						row[n] = f.regional.FormatMoney(val)
+					default:
+						row[n] = val
+					}
+				} else {
+					row[n] = val
+				}
+				if err != nil {
 					return nil, err
 				}
 			}