URL string `docopt:"URL"`

OutFile string `docopt:"--output"`

Command string `docopt:"--cmd"`

List bool `docopt:"--list"`

Bail bool `docopt:"--bail"`

Echo bool `docopt:"--echo"`

Quiet bool `docopt:"--quiet"`

NoHeader bool `docopt:"--noheader"`

NullText string `docopt:"--nullvalue"`

NewLine string `docopt:"--newline"`

Separator string `docopt:"--separator"`

Format string `docopt:"--format"`

OutPutFormat int `docopt:"--outputformat"`

Host string `docopt:"--host"`

Port int `docopt:"--port"`

User string `docopt:"--user"`

Password string `docopt:"--password"`

Database string `docopt:"--dbname"`

Zerotext bool `docopt:"--zerotext"`

Memory bool `docopt:"--memory"`

Create bool `docopt:"--create"`

NonLinearizable bool `docopt:"--nonlinearizable"`

ApiKey string `docopt:"--apikey"`

Token string `docopt:"--token"`

NoBlob bool `docopt:"--noblob"`

MaxData int `docopt:"--maxdata"`

MaxRows int `docopt:"--maxrows"`

MaxRowset int `docopt:"--maxrowset"`

Timeout int `docopt:"--timeout"`

Compress string `docopt:"--compress"`

Tls string `docopt:"--tls"`

UseStdIn bool `docopt:"-"`

Files []string `docopt:"<FILE>"`

for from, to := range map[string]string{"\\0": string(0), "\\a": "\a", "\\b": "\b", "\\t": "\t", "\\n": "\n", "\\v": "\v", "\\f": "\f", "\\r": "\r"} {

in = strings.ReplaceAll(in, from, to)

}

return in

for _, v := range args {

v = strings.TrimSpace(v)

if v != "" {

return v

}

}

return ""

parameter := Parameter{}

var outputformat int

// Parse Command Line Parameter (Attention: "::" -> ":<CTRL+Space>")

if p, err := docopt.ParseArgs(strings.ReplaceAll(usage, "::", ": "), nil, fmt.Sprintf("%s %s, %s", app_name, version, copyright)); err == nil {

// Preprocessing...

if format, _ := p.String("--format"); format == "" { // If --format was not specified, use default values...

if list, _ := p.Bool("--list"); list {

p["--format"] = "LIST"

} // use --format=LIST when in list mode

if output, _ := p.String("--output"); output != "" {

p["--format"] = "QUOTE"

} // use --format=QUOTE when in batch mode

}

if format, _ := p.String("--format"); format == "" {

p["--format"] = "BOX"

} // use --format=BOX when --format is stil not specified

format, err := p.String("--format")

if err != nil {

return Parameter{}, err

}

outputformat, err = sqlitecloud.GetOutputFormatFromString(format)

if err != nil {

return Parameter{}, err

}

p["--outputformat"] = outputformat

// If the connection string is set, parse and apply the connection string...

if url, isSet := p["URL"]; isSet && url != "<nil>" {

if conf, err := sqlitecloud.ParseConnectionString(reflect.ValueOf(url).String()); err == nil {

p["--host"] = getFirstNoneEmptyString([]string{dropError(p.String("--host")), conf.Host})

p["--user"] = getFirstNoneEmptyString([]string{dropError(p.String("--user")), conf.Username})

p["--password"] = getFirstNoneEmptyString([]string{dropError(p.String("--password")), conf.Password})

p["--dbname"] = getFirstNoneEmptyString([]string{dropError(p.String("--dbname")), conf.Database})

if conf.Port > 0 {

p["--port"] = getFirstNoneEmptyString([]string{dropError(p.String("--port")), fmt.Sprintf("%d", conf.Port)})

}

if conf.Timeout > 0 {

p["--timeout"] = getFirstNoneEmptyString([]string{dropError(p.String("--timeout")), fmt.Sprintf("%d", conf.Timeout)})

}

if conf.Compression {

p["--compress"] = getFirstNoneEmptyString([]string{dropError(p.String("--compress")), conf.CompressMode})

}

if conf.Zerotext {

if b, err := p.Bool("--zerotext"); err == nil {

p["--zerotext"] = b || conf.Zerotext

}

}

if conf.Memory {

if b, err := p.Bool("--memory"); err == nil {

p["--memory"] = b || conf.Memory

}

}

if conf.Create {

if b, err := p.Bool("--create"); err == nil {

p["--create"] = b || conf.Create

}

}

if conf.NonLinearizable {

if b, err := p.Bool("--nonlinearizable"); err == nil {

p["--nonlinearizable"] = b || conf.NonLinearizable

}

}

p["--tls"] = getFirstNoneEmptyString([]string{dropError(p.String("--tls")), conf.Pem})

if !conf.Secure {

p["--tls"] = "NO"

} else if conf.TlsInsecureSkipVerify {

p["--tls"] = "SKIP"

}

p["--apikey"] = getFirstNoneEmptyString([]string{dropError(p.String("--apikey")), conf.ApiKey})

p["--token"] = getFirstNoneEmptyString([]string{dropError(p.String("--token")), conf.Token})

if conf.NoBlob {

if b, err := p.Bool("--noblob"); err == nil {

p["--noblob"] = b || conf.NoBlob

}

}

if conf.MaxData > 0 {

p["--maxdata"] = getFirstNoneEmptyString([]string{dropError(p.String("--maxdata")), fmt.Sprintf("%d", conf.MaxData)})

}

if conf.MaxRows > 0 {

p["--maxrows"] = getFirstNoneEmptyString([]string{dropError(p.String("--maxrows")), fmt.Sprintf("%d", conf.MaxRows)})

}

if conf.MaxRowset > 0 {

p["--maxrowset"] = getFirstNoneEmptyString([]string{dropError(p.String("--maxrowset")), fmt.Sprintf("%d", conf.MaxRowset)})

}

}

} else {

return Parameter{}, err

}

// Set default Values

p["--host"] = getFirstNoneEmptyString([]string{dropError(p.String("--host")), "localhost"})

p["--port"] = getFirstNoneEmptyString([]string{dropError(p.String("--port")), "8860"})

p["--timeout"] = getFirstNoneEmptyString([]string{dropError(p.String("--timeout")), "10"})

p["--compress"] = getFirstNoneEmptyString([]string{dropError(p.String("--compress")), sqlitecloud.CompressModeLZ4})

p["--tls"] = getFirstNoneEmptyString([]string{dropError(p.String("--tls")), "YES"})

p["--separator"] = getFirstNoneEmptyString([]string{dropError(p.String("--separator")), dropError(sqlitecloud.GetDefaultSeparatorForOutputFormat(outputformat)), "|"})

p["--maxdata"] = getFirstNoneEmptyString([]string{dropError(p.String("--maxdata")), "0"})

p["--maxrows"] = getFirstNoneEmptyString([]string{dropError(p.String("--maxrows")), "0"})

p["--maxrowset"] = getFirstNoneEmptyString([]string{dropError(p.String("--maxrowset")), "0"})

// Fix invalid(=unset) parameters, quotation & control-chars

for k, v := range p {

switch reflect.ValueOf(v).Kind() {

case reflect.Invalid:

p[k] = ""

case reflect.String:

p[k] = replaceControlChars(strings.Trim(reflect.ValueOf(v).String(), "'\""))

default:

}

}

// for k, v := range p { fmt.Printf( "%s='%v'\r\n", k, v ) }

// Copy map data into Object

if err := p.Bind(&parameter); err != nil {

return Parameter{}, err

}

if parameter.NewLine == "" {

parameter.NewLine = "\r\n"

}

// Postprocessing...

if parameter.OutFile != "" {

parameter.Echo = false

parameter.Quiet = true

}

if q, _ := p.Bool("--echo"); q {

parameter.Echo = true

}

if parameter.Echo {

parameter.Quiet = false

}

if q, _ := p.Bool("--quiet"); q {

parameter.Quiet = true

parameter.Echo = false

}

} else {

return Parameter{}, err

}

return parameter, nil

start := line[0:pos]

tail = strings.TrimPrefix(line[pos:], " ")

split := strings.LastIndex(start, " ")

head = ""

line = start

if split > 0 {

head = start[0 : split+1]

line = start[split+1:]

}

// fmt.Printf( "start=>%s<, tail=>%s<, head=>%s<, line=>%s<\r\n", start, tail, head, line )

for _, token := range dynamic_tokens {

if strings.HasPrefix(strings.ToLower(token), strings.ToLower(line)) {

suggestions = append(suggestions, token)

}

}

for _, token := range tokens {

if strings.HasPrefix(strings.ToLower(token), strings.ToLower(line)) {

suggestions = append(suggestions, token)

}

}

return

width := -1

out := bufio.NewWriter(os.Stdout)

if parameter, err := parseParameters(); err != nil {

fatal(out, fmt.Sprintf("ERROR: Could not parse arguments (%s).", err.Error()), &parameter)

} else {

if parameter.OutFile != "" {

_ = os.Remove(parameter.OutFile)

if file, err := os.OpenFile(parameter.OutFile, os.O_CREATE|os.O_RDWR, 0664); err != nil {

fatal(out, fmt.Sprintf("ERROR: Could not create '%s' for writing", parameter.OutFile), &parameter)

} else {

out = bufio.NewWriter(file)

width = 0

defer func() {

if err := file.Close(); err != nil {

fatal(out, fmt.Sprintf("ERROR: Could not close file '%s': %s", parameter.OutFile, err), &parameter)

}

}()

}

}

// print( out, fmt.Sprintf( "%s %s, %s", long_name, version, copyright ), &parameter )

config := sqlitecloud.SQCloudConfig{

Host: parameter.Host,

Port: parameter.Port,

Username: parameter.User,

Password: parameter.Password,

Token: parameter.Token,

Database: parameter.Database,

Timeout: time.Duration(parameter.Timeout) * time.Second,

Compression: parameter.Compress == sqlitecloud.CompressModeLZ4,

CompressMode: parameter.Compress,

Zerotext: parameter.Zerotext,

Memory: parameter.Memory,

Create: parameter.Create,

NonLinearizable: parameter.NonLinearizable,

ApiKey: parameter.ApiKey,

NoBlob: parameter.NoBlob,

MaxData: parameter.MaxData,

MaxRows: parameter.MaxRows,

MaxRowset: parameter.MaxRowset,

}

config.Secure, config.TlsInsecureSkipVerify, config.Pem = sqlitecloud.ParseTlsString(parameter.Tls)

var db *sqlitecloud.SQCloud = sqlitecloud.New(config)

if err := db.Connect(); err != nil {

fatal(out, fmt.Sprintf("ERROR: %s.", err.Error()), &parameter)

} else {

defer db.Close()

db.Callback = func(conn *sqlitecloud.SQCloud, json string) {

print(out, json, &parameter)

out.Flush()

}

//print( out, fmt.Sprintf( "Connected to %s.", parameter.Host ), &parameter )

//print( out, strings.Split( help, "\n" )[ 0 ], &parameter )

print(out, strings.ReplaceAll(banner, "<HOST>", parameter.Host), &parameter)

print(out, "", &parameter)

if parameter.List {

Execute(db, out, "LIST DATABASES", width, &parameter)

os.Exit(0)

}

// Execute single Command

if parameter.Command != "" {

Execute(db, out, parameter.Command, width, &parameter)

}

// Batch Mode starts here ///////////////////////////////////////////////////////////////

// Execute Files

if len(parameter.Files) > 0 {

ExecuteFiles(db, out, parameter.Files, width, &parameter)

}

// Execute Stdin

if parameter.UseStdIn {

if err := ExecuteBuffer(db, out, os.Stdin, width, &parameter); err != nil {

bail(out, fmt.Sprintf("Could not execute (%s)", err.Error()), &parameter)

}

}

// End Batch Mode

if parameter.OutFile != "" {

os.Exit(0)

}

// Interactive Mode starts here /////////////////////////////////////////////////////////

editor := liner.NewLiner()

defer editor.Close()

editor.SetCtrlCAborts(true)

editor.SetMultiLineMode(true)

editor.SetWordCompleter(autocomplete)

if strings.HasPrefix(history_file, "~/") { // fix Home directory for POSIX and Windows

if dir, err := os.UserHomeDir(); err == nil {

history_file = fmt.Sprintf("%s/%s", dir, strings.TrimPrefix(history_file, "~/"))

}

}

if f, err := os.Open(history_file); err == nil {

editor.ReadHistory(f)

f.Close()

}

prompt := "sqlc > "

prompt = "\\u@\\H:\\p/\\d > "

refreshDB := false

Loop:

for {

out.Flush()

if refreshDB {

db.Database, _ = db.GetDatabase()

}

renderdPrompt := prompt

renderdPrompt = strings.ReplaceAll(renderdPrompt, "\\H", parameter.Host)

renderdPrompt = strings.ReplaceAll(renderdPrompt, "\\p", fmt.Sprintf("%d", parameter.Port))

renderdPrompt = strings.ReplaceAll(renderdPrompt, "\\u", parameter.User)

renderdPrompt = strings.ReplaceAll(renderdPrompt, "\\d", db.Database)

renderdPrompt = strings.ReplaceAll(renderdPrompt, "\\T", time.Now().Format("2006-01-02"))

renderdPrompt = strings.ReplaceAll(renderdPrompt, "\\t", time.Now().Format("15:04:05"))

renderdPrompt = strings.ReplaceAll(renderdPrompt, "\\w", fmt.Sprintf("/%s", dropError(os.Getwd())))

command, err := editor.Prompt(renderdPrompt)

switch err {

case io.EOF:

break

case nil:

switch tokens := strings.Split(strings.ToLower(strings.TrimSpace(command)), " "); tokens[0] {

case "":

continue Loop

case ".exit", "exit":

break Loop

case ".help":

print(out, help, &parameter)

case ".bail":

parameter.Bail = getNextTokenValueAsBool(out, parameter.Bail, tokens, &parameter)

case ".echo":

parameter.Echo = getNextTokenValueAsBool(out, parameter.Echo, tokens, &parameter)

case ".quiet":

parameter.Quiet = getNextTokenValueAsBool(out, parameter.Quiet, tokens, &parameter)

case ".noheader":

parameter.NoHeader = getNextTokenValueAsBool(out, parameter.NoHeader, tokens, &parameter)

case ".width":

width = getNextTokenValueAsInteger(out, width, -1, tokens, &parameter)

case ".nullvalue":

parameter.NullText = getNextTokenValueAsString(out, parameter.NullText, "NULL", "", tokens, &parameter)

case ".newline":

parameter.NewLine = getNextTokenValueAsString(out, parameter.NewLine, "\r\n", "", tokens, &parameter)

case ".prompt":

prompt = getNextTokenValueAsString(out, prompt, "sqlc >", "", tokens, &parameter)

case ".separator":

parameter.Separator = getNextTokenValueAsString(out, parameter.Separator, "<auto>", "", tokens, &parameter)

case ".timeout":

parameter.Timeout = getNextTokenValueAsInteger(out, parameter.Timeout, 10, tokens, &parameter)

case ".compress":

parameter.Compress = getNextTokenValueAsString(out, parameter.Compress, sqlitecloud.CompressModeNo, "|no|lz4|", tokens, &parameter)

db.Compress(parameter.Compress)

case ".format":

newFormat := getNextTokenValueAsString(out, parameter.Format, "BOX", "|list|csv|quote|tabs|line|json|html|xml|markdown|table|box|", tokens, &parameter)

if newFormat != parameter.Format {

parameter.Format = newFormat

parameter.Separator = "<auto>"

parameter.OutPutFormat, _ = sqlitecloud.GetOutputFormatFromString(newFormat)

}

default:

Execute(db, out, command, width, &parameter)

switch tokens[0] {

case ".quit", "quit":

break Loop

default:

editor.AppendHistory(command)

}

commandLower := strings.ToLower(command)

refreshDB = strings.Contains(commandLower, "use database") || strings.Contains(commandLower, "unuse database") || strings.Contains(commandLower, "create table")

}

default:

bail(out, err.Error(), &parameter)

}

}

if f, err := os.Create(history_file); err == nil {

_, _ = editor.WriteHistory(f)

_ = f.Close()

}

}

}

Seperator := Settings.Separator

if cmd == "" {

return

}

if Settings.OutPutFormat == sqlitecloud.OUTFORMAT_XML {

Seperator = cmd

}

if width < 0 {

if w, _, err := term.GetSize(0); err == nil {

width = w

}

}

if Settings.Echo {

print(out, cmd, Settings)

}

start := time.Now()

if res, err := db.Select(cmd); res != nil {

defer res.Free()

if err == nil {

if !res.IsRowSet() || (res.GetNumberOfRows() > 0 && res.GetNumberOfColumns() > 0) {

res.DumpToWriter(out, Settings.OutPutFormat, Settings.NoHeader, Seperator, Settings.NullText, Settings.NewLine, uint(width), Settings.Quiet)

}

if res.IsRowSet() {

print(out, fmt.Sprintf("Rows: %d - Cols: %d: %s Time: %s", res.GetNumberOfRows(), res.GetNumberOfColumns(), renderByteCount(int64(res.GetUncompressedChuckSizeSum())), time.Since(start)), Settings)

}

}

} else {

bail(out, err.Error(), Settings)

// bail(out, err.Error()+fmt.Sprintf(" (%d:%d:%d)", db.GetErrorCode(), db.GetExtErrorCode(), db.GetErrorOffset()), Settings)

}

print(out, "", Settings) // Empty line

if scanner := bufio.NewScanner(in); scanner != nil {

for scanner.Scan() {

line := scanner.Text()

if strings.ToUpper(line) == ".GOTO_PROMPT" {

return nil // break out of sql script

}

if strings.TrimSpace(line) != "" {

Execute(db, out, line, width, Settings)

}

}

return scanner.Err() // nil or some error

}

return errors.New("Could not instanciate the line scanner")

file, err := os.Open(FilePath)

if err == nil {

defer func() {

_ = file.Close()

}()

if err := ExecuteBuffer(db, out, file, width, Settings); err != nil {

return err

}

}

return err

for _, file := range FilePathes {

err := ExecuteFile(db, out, file, width, Settings)

if err != nil {

return err

}

}

return nil

if !Settings.Quiet {

_, _ = io.WriteString(out, Message)

_, _ = io.WriteString(out, Settings.NewLine)

}

print(out, Message, Settings)

if Settings.Bail {

os.Exit(1)

}

_, _ = io.WriteString(out, Message)

_, _ = io.WriteString(out, Settings.NewLine)

_ = out.Flush()

os.Exit(1)

const unit = 1000

if count < unit {

return fmt.Sprintf("%d Bytes", count)

}

div, exp := int64(unit), 0

for n := count / unit; n >= unit; n /= unit {

div *= unit

exp++

}

return fmt.Sprintf("%.1f %cBytes", float64(count)/float64(div), "kMGTPE"[exp])

switch len(tokens) {

case 1:

return !oldValue

case 2:

switch tokens[1] {

case "on", "true", "1", "enable":

return true

case "off", "false", "0", "disable":

return false

default:

bail(out, fmt.Sprintf("SYNTHAX ERROR: Invalid parameter \"%s\".", tokens[1]), Settings)

}

default:

bail(out, "SYNTHAX ERROR: Wrong number of parameters.", Settings)

}

return oldValue

switch len(tokens) {

case 1:

return defaultValue

case 2:

if i, err := strconv.Atoi(tokens[1]); err == nil {

return i

}

bail(out, fmt.Sprintf("SYNTHAX ERROR: \"%s\" is not a valid number.", tokens[1]), Settings)

default:

bail(out, "SYNTHAX ERROR: Wrong number of parameters.", Settings)

}

return oldValue

switch len(tokens) {

case 1:

return defaultValue

case 2:

if allowedValues == "" {

return replaceControlChars(tokens[1])

}

if strings.Contains(allowedValues, fmt.Sprintf("|%s|", tokens[1])) {

return tokens[1]

}

bail(out, fmt.Sprintf("SYNTHAX ERROR: Invalid parameter \"%s\".", tokens[1]), Settings)

default:

bail(out, "SYNTHAX ERROR: Wrong number of parameters.", Settings)

}

return oldValue