feat(connection): implement available parameters

See: sqlitecloud/sqlitecloud-js#68

Author: danielebriggi

.devcontainer/devcontainer.json

@@ -0,0 +1,22 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/go
+{
+	"name": "Go",
+	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+	"image": "mcr.microsoft.com/devcontainers/go:1-1-bullseye"
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "go version",
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

.env.example

@@ -0,0 +1,7 @@
+SQLITE_CONNECTION_STRING=sqlitecloud://myhost.sqlite.cloud
+SQLITE_USER=admin
+SQLITE_PASSWORD=
+SQLITE_API_KEY=
+SQLITE_HOST=myhost.sqlite.cloud
+SQLITE_DB=chinook.sqlite
+SQLITE_PORT=8860

.github/dependabot.yml

@@ -0,0 +1,12 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for more information:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+# https://containers.dev/guide/dependabot
+
+version: 2
+updates:
+ - package-ecosystem: "devcontainers"
+   directory: "/"
+   schedule:
+     interval: weekly

.gitignore

@@ -3,3 +3,6 @@ cli/.DS_Store
 .DS_Store
 cli/.vscode
 .vscode/launch.json
+pkg/
+bin
+.env

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "gopls": {
+        "ui.semanticTokens": true
+    }
+}

cli/sqlc.go

@@ -514,7 +514,7 @@ func main() {
 					case ".timeout":
 						parameter.Timeout = getNextTokenValueAsInteger(out, parameter.Timeout, 10, tokens, &parameter)
 					case ".compress":
-						parameter.Compress = getNextTokenValueAsString(out, parameter.Compress, "NO", "|no|lz4|", tokens, &parameter)
+						parameter.Compress = getNextTokenValueAsString(out, parameter.Compress, sqlitecloud.CompressModeNo, "|no|lz4|", tokens, &parameter)
 						db.Compress(parameter.Compress)
 
 					case ".format":

connection.go

@@ -37,11 +37,20 @@ type SQCloudConfig struct {
 	Username              string
 	Password              string
 	Database              string
-	Timeout               time.Duration
-	CompressMode          string
-	Secure                bool
-	TlsInsecureSkipVerify bool
-	Pem                   string
+	PasswordHashed        bool          // Password is hashed
+	Timeout               time.Duration // Optional query timeout passed directly to TLS socket
+	CompressMode          string        // eg: LZ4
+	Compression           bool          // Enable compression
+	Zerotext              bool          // Tell the server to zero-terminate strings
+	Memory                bool          // Database will be created in memory
+	Create                bool          // Create the database if it doesn't exist?
+	Secure                bool          // Connect using plain TCP port, without TLS encryption, NOT RECOMMENDED (insecure)
+	NonLinearizable       bool          // Request for immediate responses from the server node without waiting for linerizability guarantees
+	TlsInsecureSkipVerify bool          // Accept invalid TLS certificates (no_verify_certificate)
+	Pem                   string        // TODO: ?
+	RootCertificate       string
+	ClientCertificate     string
+	ClientCertificateKey  string
 	ApiKey                string
 	NoBlob                bool // flag to tell the server to not send BLOB columns
 	MaxData               int  // value to tell the server to not send columns with more than max_data bytes
@@ -69,6 +78,9 @@ type SQCloud struct {
 	ErrorMessage string
 }
 
+const CompressModeNo = "NO"
+const CompressModeLZ4 = "LZ4"
+
 const SQLiteCloudCA = "SQLiteCloudCA"
 
 func New(config SQCloudConfig) *SQCloud {
@@ -104,15 +116,23 @@ func ParseConnectionString(ConnectionString string) (config *SQCloudConfig, err
 		config.Password, _ = u.User.Password()
 		config.Database = strings.TrimPrefix(u.Path, "/")
 		config.Timeout = 0
-		config.CompressMode = "NO"
+		config.Compression = false
+		config.CompressMode = CompressModeNo
+		config.Zerotext = false
+		config.Memory = false
+		config.Create = false
 		config.Secure = true
+		config.NonLinearizable = false
 		config.TlsInsecureSkipVerify = false
 		config.Pem = ""
-		config.ApiKey = ""
+		config.RootCertificate = ""
+		config.ClientCertificate = ""
+		config.ClientCertificateKey = ""
 		config.NoBlob = false
 		config.MaxData = 0
 		config.MaxRows = 0
 		config.MaxRowset = 0
+		config.ApiKey = ""
 
 		sPort := strings.TrimSpace(u.Port())
 		if len(sPort) > 0 {
@@ -133,8 +153,50 @@ func ParseConnectionString(ConnectionString string) (config *SQCloudConfig, err
 
 			case "compress":
 				config.CompressMode = strings.ToUpper(lastLiteral)
+				if config.CompressMode == CompressModeLZ4 {
+					config.Compression = true
+				}
+			case "compression":
+				if b, err := parseBool(lastLiteral, config.Compression); err == nil && b {
+					config.Compression = true
+					config.CompressMode = CompressModeLZ4
+				}
+			case "zerotext":
+				if b, err := parseBool(lastLiteral, config.Zerotext); err == nil {
+					config.Zerotext = b
+				}
+			case "memory":
+				if b, err := parseBool(lastLiteral, config.Memory); err == nil {
+					config.Memory = b
+				}
+			case "create":
+				if b, err := parseBool(lastLiteral, config.Create); err == nil {
+					config.Create = b
+				}
+			case "secure":
+				if b, err := parseBool(lastLiteral, config.Secure); err == nil {
+					config.Secure = b
+				}
+			case "insecure":
+				if b, err := parseBool(lastLiteral, config.Secure); err == nil {
+					config.Secure = !b
+				}
+			case "non_linearizable", "nonlinearizable":
+				if b, err := parseBool(lastLiteral, config.NonLinearizable); err == nil {
+					config.NonLinearizable = b
+				}
+			case "no_verify_certificate":
+				if b, err := parseBool(lastLiteral, config.TlsInsecureSkipVerify); err == nil {
+					config.TlsInsecureSkipVerify = b
+				}
 			case "tls":
 				config.Secure, config.TlsInsecureSkipVerify, config.Pem = ParseTlsString(lastLiteral)
+			case "root_certificate":
+				config.RootCertificate = lastLiteral
+			case "client_certificate":
+				config.ClientCertificate = lastLiteral
+			case "client_certificate_key":
+				config.ClientCertificateKey = lastLiteral
 			case "apikey":
 				config.ApiKey = lastLiteral
 			case "noblob":
@@ -210,8 +272,8 @@ func (this *SQCloud) CheckConnectionParameter() error {
 		return errors.New(fmt.Sprintf("Invalid Timeout (%s)", this.Timeout.String()))
 	}
 
-	switch strings.ToUpper(this.CompressMode) {
-	case "NO", "LZ4":
+	switch this.CompressMode {
+	case CompressModeNo, CompressModeLZ4:
 	default:
 		return errors.New(fmt.Sprintf("Invalid compression method (%s)", this.CompressMode))
 	}
@@ -340,45 +402,7 @@ func (this *SQCloud) reconnect() error {
 		}
 	}
 
-	commands := ""
-	args := []interface{}{}
-
-	if strings.TrimSpace(this.Username) != "" {
-		c, a := authCommand(this.Username, this.Password)
-		commands += c
-		args = append(args, a...)
-
-	} else if strings.TrimSpace(this.ApiKey) != "" {
-		c, a := authWithKeyCommand(this.ApiKey)
-		commands += c
-		args = append(args, a...)
-	}
-
-	if strings.TrimSpace(this.Database) != "" {
-		c, a := useDatabaseCommand(this.Database)
-		commands += c
-		args = append(args, a...)
-	}
-
-	if this.NoBlob {
-		commands += noblobCommand(this.NoBlob)
-	}
-
-	if this.MaxData > 0 {
-		commands += maxdataCommand(this.MaxData)
-	}
-
-	if this.MaxRows > 0 {
-		commands += maxrowsCommand(this.MaxRows)
-	}
-
-	if this.MaxRowset > 0 {
-		commands += maxrowsetCommand(this.MaxRowset)
-	}
-
-	if this.CompressMode != "NO" {
-		commands += compressCommand(this.CompressMode)
-	}
+	commands, args := connectionCommands(this.SQCloudConfig)
 
 	if commands != "" {
 		if len(args) > 0 {
@@ -421,6 +445,53 @@ func (this *SQCloud) Close() error {
 	return nil
 }
 
+func connectionCommands(config SQCloudConfig) (string, []interface{}) {
+	buffer := ""
+	args := []interface{}{}
+
+	// it must be executed before authentication command
+	if config.NonLinearizable {
+		buffer += nonlinearizableCommand(config.NonLinearizable)
+	}
+
+	if config.ApiKey != "" {
+		c, a := authWithKeyCommand(config.ApiKey)
+		buffer += c
+		args = append(args, a...)
+	}
+
+	if config.Username != "" && config.Password != "" {
+		c, a := authCommand(config.Username, config.Password, config.PasswordHashed)
+		buffer += c
+		args = append(args, a...)
+	}
+
+	if config.Database != "" {
+		create := config.Create && !config.Memory
+		c, a := useDatabaseCommand(config.Database, create)
+		buffer += c
+		args = append(args, a...)
+	}
+
+	buffer += compressCommand(config.CompressMode)
+
+	if config.Zerotext {
+		buffer += zerotextCommand(config.Zerotext)
+	}
+
+	if config.NoBlob {
+		buffer += noblobCommand(config.NoBlob)
+	}
+
+	buffer += maxdataCommand(config.MaxData)
+
+	buffer += maxrowsCommand(config.MaxRows)
+
+	buffer += maxrowsetCommand(config.MaxRowset)
+
+	return buffer, args
+}
+
 func noblobCommand(NoBlob bool) string {
 	if NoBlob {
 		return "SET CLIENT KEY NOBLOB TO 1;"
@@ -443,15 +514,31 @@ func maxrowsetCommand(v int) string {
 
 func compressCommand(CompressMode string) string {
 	switch compression := strings.ToUpper(CompressMode); {
-	case compression == "NO":
+	case compression == CompressModeNo:
 		return "SET CLIENT KEY COMPRESSION TO 0;"
-	case compression == "LZ4":
+	case compression == CompressModeLZ4:
 		return "SET CLIENT KEY COMPRESSION TO 1;"
 	default:
 		return ""
 	}
 }
 
+func nonlinearizableCommand(NonLinearizable bool) string {
+	if NonLinearizable {
+		return "SET CLIENT KEY NONLINEARIZABLE TO 1;"
+	} else {
+		return "SET CLIENT KEY NONLINEARIZABLE TO 0;"
+	}
+}
+
+func zerotextCommand(Zerotext bool) string {
+	if Zerotext {
+		return "SET CLIENT KEY ZEROTEXT TO 1;"
+	} else {
+		return "SET CLIENT KEY ZEROTEXT TO 0;"
+	}
+}
+
 // Compress enabled or disables data compression for this connection.
 // If enabled, the data is compressed with the LZ4 compression algorithm, otherwise no compression is applied the data.
 func (this *SQCloud) Compress(CompressMode string) error {

server.go

@@ -246,13 +246,18 @@ func (this *SQCloud) ListDatabaseConnections(Database string) ([]SQCloudConnecti
 
 // Auth Functions
 
-func authCommand(Username string, Password string) (string, []interface{}) {
-	return "AUTH USER ? PASSWORD ?;", []interface{}{Username, Password}
+func authCommand(Username string, Password string, IsPasswordHashed bool) (string, []interface{}) {
+	command := "PASSWORD"
+	if IsPasswordHashed {
+		command = "HASH"
+	}
+
+	return fmt.Sprintf("AUTH USER ? %s ?;", command), []interface{}{Username, Password}
 }
 
 // Auth - INTERNAL SERVER COMMAND: Authenticates User with the given credentials.
 func (this *SQCloud) Auth(Username string, Password string) error {
-	return this.ExecuteArray(authCommand(Username, Password))
+	return this.ExecuteArray(authCommand(Username, Password, false))
 }
 
 func authWithKeyCommand(Key string) (string, []interface{}) {
@@ -318,16 +323,20 @@ func (this *SQCloud) GetDatabase() (string, error) {
 	return "", err
 }
 
-func useDatabaseCommand(Database string) (string, []interface{}) {
-	return "USE DATABASE ?;", []interface{}{Database}
+func useDatabaseCommand(Database string, create bool) (string, []interface{}) {
+	command := "USE DATABASE ?;"
+	if create {
+		command = "CREATE DATABASE ? IF NOT EXISTS;"
+	}
+	return command, []interface{}{Database}
 }
 
 // UseDatabase - INTERNAL SERVER COMMAND: Selects the specified Database for usage.
 // Only if a database was selected, SQL Commands can be sent to this specific Database.
 // An error is returned if the specified Database was not found or the user has not the necessary access rights to work with this Database.
 func (this *SQCloud) UseDatabase(Database string) error {
 	this.Database = Database
-	return this.ExecuteArray(useDatabaseCommand(Database))
+	return this.ExecuteArray(useDatabaseCommand(Database, false))
 }
 
 // UseDatabase - INTERNAL SERVER COMMAND: Releases the actual Database.