Add shared-libraries to release

.github/workflows/compile-shared-libraries.yml

@@ -22,9 +22,10 @@ jobs:
           targets: linux/amd64,linux/arm64,windows/amd64,windows/arm64,darwin/amd64,darwin/arm64
           v: true
           buildmode: c-shared
+          buildvcs: true
 
       - name: Upload artifact
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: shared-libraries
           path: dist/*

.github/workflows/release.yml

@@ -17,16 +17,32 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
           go-version: 1.22.0
+
+      - name: Cross-Compile with xgo
+        uses: crazy-max/ghaction-xgo@v3.1.0
+        with:
+          xgo_version: latest
+          go_version: 1.22.0
+          dest: sharedlibrary_dist
+          pkg: sharedlibrary
+          prefix: cosmium
+          targets: linux/amd64,linux/arm64,windows/amd64,windows/arm64,darwin/amd64,darwin/arm64
+          v: true
+          buildmode: c-shared
+          buildvcs: true
+
       - name: Docker Login
         uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
+
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v5
         with:

.gitignore

@@ -1,4 +1,5 @@
 dist/
+sharedlibrary_dist/
 ignored/
 explorer_www/
 main

.goreleaser.yaml

@@ -26,6 +26,23 @@ brews:
     commit_author:
       name: pikami
       email: git@pikami.org
+    skip_upload: auto
+
+archives:
+  - id: bundle
+    format: tar.gz
+    format_overrides:
+      - goos: windows
+        format: zip
+  - id: shared-libraries
+    meta: true
+    format: "tar.gz"
+    wrap_in_directory: true
+    name_template: "{{ .ProjectName }}_{{ .Version }}_shared-libraries"
+    files:
+    - LICENSE
+    - README.md
+    - sharedlibrary_dist/**
 
 dockers:
   - id: docker-linux-amd64
@@ -33,7 +50,6 @@ dockers:
     goarch: amd64
     image_templates:
     - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-amd64"
-    - "ghcr.io/pikami/{{ .ProjectName }}:latest-amd64"
     dockerfile: Dockerfile
     use: buildx
     build_flag_templates:
@@ -51,9 +67,7 @@ dockers:
     goarch: arm64
     image_templates:
     - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64"
-    - "ghcr.io/pikami/{{ .ProjectName }}:latest-arm64"
     - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64v8"
-    - "ghcr.io/pikami/{{ .ProjectName }}:latest-arm64v8"
     dockerfile: Dockerfile
     use: buildx
     build_flag_templates:
@@ -66,18 +80,61 @@ dockers:
     - "--label=org.opencontainers.image.created={{.Date}}"
     - "--label=org.opencontainers.image.revision={{.FullCommit}}"
     - "--label=org.opencontainers.image.version={{.Version}}"
+  - id: docker-explorer-linux-amd64
+    goos: linux
+    goarch: amd64
+    image_templates:
+    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-amd64"
+    dockerfile: Explorer.Dockerfile
+    use: buildx
+    build_flag_templates:
+    - "--platform=linux/amd64"
+    - "--pull"
+    - "--label=org.opencontainers.image.title={{.ProjectName}}"
+    - "--label=org.opencontainers.image.description=Lightweight Cosmos DB emulator"
+    - "--label=org.opencontainers.image.url=https://github.com/pikami/cosmium"
+    - "--label=org.opencontainers.image.source=https://github.com/pikami/cosmium"
+    - "--label=org.opencontainers.image.created={{.Date}}"
+    - "--label=org.opencontainers.image.revision={{.FullCommit}}"
+    - "--label=org.opencontainers.image.version={{.Version}}"
+  - id: docker-explorer-linux-arm64
+    goos: linux
+    goarch: arm64
+    image_templates:
+    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-arm64"
+    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-arm64v8"
+    dockerfile: Explorer.Dockerfile
+    use: buildx
+    build_flag_templates:
+    - "--platform=linux/arm64"
+    - "--pull"
+    - "--label=org.opencontainers.image.title={{.ProjectName}}"
+    - "--label=org.opencontainers.image.description=Lightweight Cosmos DB emulator"
+    - "--label=org.opencontainers.image.url=https://github.com/pikami/cosmium"
+    - "--label=org.opencontainers.image.source=https://github.com/pikami/cosmium"
+    - "--label=org.opencontainers.image.created={{.Date}}"
+    - "--label=org.opencontainers.image.revision={{.FullCommit}}"
+    - "--label=org.opencontainers.image.version={{.Version}}"
 
 docker_manifests:
   - name_template: 'ghcr.io/pikami/{{ .ProjectName }}:latest'
-    image_templates:
-      - "ghcr.io/pikami/{{ .ProjectName }}:latest-amd64"
-      - "ghcr.io/pikami/{{ .ProjectName }}:latest-arm64"
-      - "ghcr.io/pikami/{{ .ProjectName }}:latest-arm64v8"
-  - name_template: 'ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}'
+    skip_push: auto
     image_templates:
       - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-amd64"
       - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64"
       - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64v8"
+  - name_template: 'ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}'
+    skip_push: auto
+    image_templates:
+      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-amd64"
+      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64"
+      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64v8"
+  - name_template: 'ghcr.io/pikami/{{ .ProjectName }}:explorer'
+    skip_push: auto
+    image_templates:
+      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-amd64"
+      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-arm64"
+      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-arm64v8"
 
 checksum:
   name_template: 'checksums.txt'

Dockerfile

@@ -1,4 +1,4 @@
-FROM scratch
+FROM alpine:latest
 
 WORKDIR /app
 COPY cosmium /app/cosmium

Explorer.Dockerfile

@@ -0,0 +1,9 @@
+FROM ghcr.io/cosmiumdev/cosmos-explorer-base:latest AS explorer-base
+FROM alpine:latest
+
+COPY --from=explorer-base /cosmos-explorer /cosmos-explorer
+
+WORKDIR /app
+COPY cosmium /app/cosmium
+
+ENTRYPOINT ["/app/cosmium", "-ExplorerDir", "/cosmos-explorer"]

Makefile

@@ -13,6 +13,12 @@ GOVERSION=1.22.0
 
 DIST_DIR=dist
 
+SHARED_LIB_TEST_CC=gcc
+SHARED_LIB_TEST_CFLAGS=-Wall -ldl
+SHARED_LIB_TEST_TARGET=$(DIST_DIR)/sharedlibrary_test
+SHARED_LIB_TEST_DIR=./sharedlibrary/tests
+SHARED_LIB_TEST_SOURCES=$(wildcard $(SHARED_LIB_TEST_DIR)/*.c)
+
 all: test build-all
 
 build-all: build-darwin-arm64 build-darwin-amd64 build-linux-amd64 build-linux-arm64 build-windows-amd64 build-windows-arm64
@@ -45,6 +51,14 @@ build-sharedlib-linux-amd64:
 	@echo "Building shared library for Linux x64..."
 	@GOOS=linux GOARCH=amd64 $(GOBUILD) $(SHARED_LIB_OPT) -o $(DIST_DIR)/$(BINARY_NAME)-linux-amd64.so $(SHARED_LIB_LOCATION)
 
+build-sharedlib-tests: build-sharedlib-linux-amd64
+	@echo "Building shared library tests..."
+	@$(SHARED_LIB_TEST_CC) $(SHARED_LIB_TEST_CFLAGS) -o $(SHARED_LIB_TEST_TARGET) $(SHARED_LIB_TEST_SOURCES)
+
+run-sharedlib-tests: build-sharedlib-tests
+	@echo "Running shared library tests..."
+	@$(SHARED_LIB_TEST_TARGET) $(DIST_DIR)/$(BINARY_NAME)-linux-amd64.so
+
 xgo-compile-sharedlib:
 	@echo "Building shared libraries using xgo..."
 	@mkdir -p $(DIST_DIR)

README.md

@@ -50,10 +50,17 @@ AccountEndpoint=https://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJI
 
 If you want to run Cosmos DB Explorer alongside Cosmium, you'll need to build it yourself and point the `-ExplorerDir` argument to the dist directory. Please refer to the [Cosmos DB Explorer repository](https://github.com/Azure/cosmos-explorer) for instructions on building the application.
 
+There's also a prebuilt docker image that includes the explorer: `ghcr.io/pikami/cosmium:explorer`
+
 Once running, the explorer can be reached by navigating following URL: `https://127.0.0.1:8081/_explorer/` (might be different depending on your configuration).
 
 ### Running with docker (optional)
 
+There are two docker tags available:
+
+- ghcr.io/pikami/cosmium:latest - Cosmium core service
+- ghcr.io/pikami/cosmium:explorer - Cosmium with database explorer available on `https://127.0.0.1:8081/_explorer/`
+
 If you wan to run the application using docker, configure it using environment variables see example:
 
 ```sh
@@ -61,7 +68,7 @@ docker run --rm \
   -e COSMIUM_PERSIST=/save.json \
   -v ./save.json:/save.json \
   -p 8081:8081 \
-  ghcr.io/pikami/cosmium
+  ghcr.io/pikami/cosmium # or `ghcr.io/pikami/cosmium:explorer`
 ```
 
 ### SSL Certificate
@@ -78,7 +85,7 @@ To disable SSL and run Cosmium on HTTP instead, you can use the `-DisableTls` fl
 - **-InitialData**: Path to JSON containing initial state
 - **-Persist**: Saves data to the given path on application exit (When `-InitialData` argument is not supplied, it will try to load data from path supplied in `-Persist`)
 - **-Port**: Listen port (default 8081)
-- **-Debug**: Runs application in debug mode, this provides additional logging
+- **-LogLevel**: Sets the logging level (one of: debug, info, error, silent) (default info)
 
 These arguments allow you to configure various aspects of Cosmium's behavior according to your requirements.
 
@@ -90,7 +97,7 @@ All mentioned arguments can also be set using environment variables:
 - **COSMIUM_INITIALDATA** for `-InitialData`
 - **COSMIUM_PERSIST** for `-Persist`
 - **COSMIUM_PORT** for `-Port`
-- **COSMIUM_DEBUG** for `-Debug`
+- **COSMIUM_LOGLEVEL** for `-LogLevel`
 
 # License
 

api/config/config.go

@@ -26,7 +26,8 @@ func ParseFlags() ServerConfig {
 	disableAuthentication := flag.Bool("DisableAuth", false, "Disable authentication")
 	disableTls := flag.Bool("DisableTls", false, "Disable TLS, serve over HTTP")
 	persistDataPath := flag.String("Persist", "", "Saves data to given path on application exit")
-	debug := flag.Bool("Debug", false, "Runs application in debug mode, this provides additional logging")
+	logLevel := NewEnumValue("info", []string{"debug", "info", "error", "silent"})
+	flag.Var(logLevel, "LogLevel", fmt.Sprintf("Sets the logging level %s", logLevel.AllowedValuesList()))
 
 	flag.Parse()
 	setFlagsFromEnvironment()
@@ -41,8 +42,8 @@ func ParseFlags() ServerConfig {
 	config.PersistDataFilePath = *persistDataPath
 	config.DisableAuth = *disableAuthentication
 	config.DisableTls = *disableTls
-	config.Debug = *debug
 	config.AccountKey = *accountKey
+	config.LogLevel = logLevel.value
 
 	config.PopulateCalculatedFields()
 
@@ -54,7 +55,31 @@ func (c *ServerConfig) PopulateCalculatedFields() {
 	c.DatabaseDomain = c.Host
 	c.DatabaseEndpoint = fmt.Sprintf("https://%s:%d/", c.Host, c.Port)
 	c.ExplorerBaseUrlLocation = ExplorerBaseUrlLocation
-	logger.EnableDebugOutput = c.Debug
+
+	switch c.LogLevel {
+	case "debug":
+		logger.SetLogLevel(logger.LogLevelDebug)
+	case "info":
+		logger.SetLogLevel(logger.LogLevelInfo)
+	case "error":
+		logger.SetLogLevel(logger.LogLevelError)
+	case "silent":
+		logger.SetLogLevel(logger.LogLevelSilent)
+	default:
+		logger.SetLogLevel(logger.LogLevelInfo)
+	}
+}
+
+func (c *ServerConfig) ApplyDefaultsToEmptyFields() {
+	if c.Host == "" {
+		c.Host = "localhost"
+	}
+	if c.Port == 0 {
+		c.Port = 8081
+	}
+	if c.AccountKey == "" {
+		c.AccountKey = DefaultAccountKey
+	}
 }
 
 func setFlagsFromEnvironment() (err error) {

api/config/enumFlag.go

@@ -0,0 +1,36 @@
+package config
+
+import (
+	"fmt"
+	"strings"
+)
+
+type EnumValue struct {
+	allowedValues []string
+	value         string
+}
+
+func (e *EnumValue) String() string {
+	return e.value
+}
+
+func (e *EnumValue) Set(v string) error {
+	for _, allowed := range e.allowedValues {
+		if v == allowed {
+			e.value = v
+			return nil
+		}
+	}
+	return fmt.Errorf("invalid value %q, must be one of: %s", v, strings.Join(e.allowedValues, ", "))
+}
+
+func NewEnumValue(defaultValue string, allowedValues []string) *EnumValue {
+	return &EnumValue{
+		allowedValues: allowedValues,
+		value:         defaultValue,
+	}
+}
+
+func (e *EnumValue) AllowedValuesList() string {
+	return fmt.Sprintf("(one of: %s)", strings.Join(e.allowedValues, ", "))
+}

api/config/models.go

@@ -1,20 +1,20 @@
 package config
 
 type ServerConfig struct {
-	DatabaseAccount  string
-	DatabaseDomain   string
-	DatabaseEndpoint string
-	AccountKey       string
+	DatabaseAccount  string `json:"databaseAccount"`
+	DatabaseDomain   string `json:"databaseDomain"`
+	DatabaseEndpoint string `json:"databaseEndpoint"`
+	AccountKey       string `json:"accountKey"`
 
-	ExplorerPath            string
-	Port                    int
-	Host                    string
-	TLS_CertificatePath     string
-	TLS_CertificateKey      string
-	InitialDataFilePath     string
-	PersistDataFilePath     string
-	DisableAuth             bool
-	DisableTls              bool
-	Debug                   bool
-	ExplorerBaseUrlLocation string
+	ExplorerPath            string `json:"explorerPath"`
+	Port                    int    `json:"port"`
+	Host                    string `json:"host"`
+	TLS_CertificatePath     string `json:"tlsCertificatePath"`
+	TLS_CertificateKey      string `json:"tlsCertificateKey"`
+	InitialDataFilePath     string `json:"initialDataFilePath"`
+	PersistDataFilePath     string `json:"persistDataFilePath"`
+	DisableAuth             bool   `json:"disableAuth"`
+	DisableTls              bool   `json:"disableTls"`
+	LogLevel                string `json:"logLevel"`
+	ExplorerBaseUrlLocation string `json:"explorerBaseUrlLocation"`
 }

api/handlers/documents.go

@@ -6,7 +6,7 @@ import (
 	"net/http"
 	"strconv"
 
-	jsonpatch "github.com/evanphx/json-patch/v5"
+	jsonpatch "github.com/cosmiumdev/json-patch/v5"
 	"github.com/gin-gonic/gin"
 	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/logger"
@@ -135,7 +135,7 @@ func (h *Handlers) PatchDocument(c *gin.Context) {
 
 	currentDocumentBytes, err := json.Marshal(document)
 	if err != nil {
-		logger.Error("Failed to marshal existing document:", err)
+		logger.ErrorLn("Failed to marshal existing document:", err)
 		c.JSON(http.StatusInternalServerError, gin.H{"message": "Failed to marshal existing document"})
 		return
 	}
@@ -149,7 +149,7 @@ func (h *Handlers) PatchDocument(c *gin.Context) {
 	var modifiedDocument map[string]interface{}
 	err = json.Unmarshal(modifiedDocumentBytes, &modifiedDocument)
 	if err != nil {
-		logger.Error("Failed to unmarshal modified document:", err)
+		logger.ErrorLn("Failed to unmarshal modified document:", err)
 		c.JSON(http.StatusInternalServerError, gin.H{"message": "Failed to unmarshal modified document"})
 		return
 	}

api/handlers/middleware/authentication.go

@@ -75,7 +75,8 @@ func requestToResourceId(c *gin.Context) string {
 
 	isFeed := c.Request.Header.Get("A-Im") == "Incremental Feed"
 	if resourceType == "pkranges" && isFeed {
-		resourceId = collId
+		// CosmosSDK replaces '/' with '-' in resource id requests
+		resourceId = strings.Replace(collId, "-", "/", -1)
 	}
 
 	return resourceId

api/handlers/middleware/loggers.go

@@ -16,7 +16,7 @@ func RequestLogger() gin.HandlerFunc {
 
 		bodyStr := readBody(rdr1)
 		if bodyStr != "" {
-			logger.Debug(bodyStr)
+			logger.DebugLn(bodyStr)
 		}
 
 		c.Request.Body = rdr2

api/handlers/stored_procedures.go

@@ -22,3 +22,97 @@ func (h *Handlers) GetAllStoredProcedures(c *gin.Context) {
 
 	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
+
+func (h *Handlers) GetStoredProcedure(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+	spId := c.Param("spId")
+
+	sp, status := h.repository.GetStoredProcedure(databaseId, collectionId, spId)
+
+	if status == repositorymodels.StatusOk {
+		c.IndentedJSON(http.StatusOK, sp)
+		return
+	}
+
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}
+
+func (h *Handlers) DeleteStoredProcedure(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+	spId := c.Param("spId")
+
+	status := h.repository.DeleteStoredProcedure(databaseId, collectionId, spId)
+	if status == repositorymodels.StatusOk {
+		c.Status(http.StatusNoContent)
+		return
+	}
+
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}
+
+func (h *Handlers) ReplaceStoredProcedure(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+	spId := c.Param("spId")
+
+	var sp repositorymodels.StoredProcedure
+	if err := c.BindJSON(&sp); err != nil {
+		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		return
+	}
+
+	status := h.repository.DeleteStoredProcedure(databaseId, collectionId, spId)
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		return
+	}
+
+	createdSP, status := h.repository.CreateStoredProcedure(databaseId, collectionId, sp)
+	if status == repositorymodels.Conflict {
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		return
+	}
+
+	if status == repositorymodels.StatusOk {
+		c.IndentedJSON(http.StatusOK, createdSP)
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}
+
+func (h *Handlers) CreateStoredProcedure(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+
+	var sp repositorymodels.StoredProcedure
+	if err := c.BindJSON(&sp); err != nil {
+		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		return
+	}
+
+	createdSP, status := h.repository.CreateStoredProcedure(databaseId, collectionId, sp)
+	if status == repositorymodels.Conflict {
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		return
+	}
+
+	if status == repositorymodels.StatusOk {
+		c.IndentedJSON(http.StatusCreated, createdSP)
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}

api/handlers/triggers.go

@@ -22,3 +22,97 @@ func (h *Handlers) GetAllTriggers(c *gin.Context) {
 
 	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
+
+func (h *Handlers) GetTrigger(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+	triggerId := c.Param("triggerId")
+
+	trigger, status := h.repository.GetTrigger(databaseId, collectionId, triggerId)
+
+	if status == repositorymodels.StatusOk {
+		c.IndentedJSON(http.StatusOK, trigger)
+		return
+	}
+
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}
+
+func (h *Handlers) DeleteTrigger(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+	triggerId := c.Param("triggerId")
+
+	status := h.repository.DeleteTrigger(databaseId, collectionId, triggerId)
+	if status == repositorymodels.StatusOk {
+		c.Status(http.StatusNoContent)
+		return
+	}
+
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}
+
+func (h *Handlers) ReplaceTrigger(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+	triggerId := c.Param("triggerId")
+
+	var trigger repositorymodels.Trigger
+	if err := c.BindJSON(&trigger); err != nil {
+		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		return
+	}
+
+	status := h.repository.DeleteTrigger(databaseId, collectionId, triggerId)
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		return
+	}
+
+	createdTrigger, status := h.repository.CreateTrigger(databaseId, collectionId, trigger)
+	if status == repositorymodels.Conflict {
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		return
+	}
+
+	if status == repositorymodels.StatusOk {
+		c.IndentedJSON(http.StatusOK, createdTrigger)
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}
+
+func (h *Handlers) CreateTrigger(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+
+	var trigger repositorymodels.Trigger
+	if err := c.BindJSON(&trigger); err != nil {
+		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		return
+	}
+
+	createdTrigger, status := h.repository.CreateTrigger(databaseId, collectionId, trigger)
+	if status == repositorymodels.Conflict {
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		return
+	}
+
+	if status == repositorymodels.StatusOk {
+		c.IndentedJSON(http.StatusCreated, createdTrigger)
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}

api/handlers/user_defined_functions.go

@@ -22,3 +22,97 @@ func (h *Handlers) GetAllUserDefinedFunctions(c *gin.Context) {
 
 	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
+
+func (h *Handlers) GetUserDefinedFunction(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+	udfId := c.Param("udfId")
+
+	udf, status := h.repository.GetUserDefinedFunction(databaseId, collectionId, udfId)
+
+	if status == repositorymodels.StatusOk {
+		c.IndentedJSON(http.StatusOK, udf)
+		return
+	}
+
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}
+
+func (h *Handlers) DeleteUserDefinedFunction(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+	udfId := c.Param("udfId")
+
+	status := h.repository.DeleteUserDefinedFunction(databaseId, collectionId, udfId)
+	if status == repositorymodels.StatusOk {
+		c.Status(http.StatusNoContent)
+		return
+	}
+
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}
+
+func (h *Handlers) ReplaceUserDefinedFunction(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+	udfId := c.Param("udfId")
+
+	var udf repositorymodels.UserDefinedFunction
+	if err := c.BindJSON(&udf); err != nil {
+		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		return
+	}
+
+	status := h.repository.DeleteUserDefinedFunction(databaseId, collectionId, udfId)
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		return
+	}
+
+	createdUdf, status := h.repository.CreateUserDefinedFunction(databaseId, collectionId, udf)
+	if status == repositorymodels.Conflict {
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		return
+	}
+
+	if status == repositorymodels.StatusOk {
+		c.IndentedJSON(http.StatusOK, createdUdf)
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}
+
+func (h *Handlers) CreateUserDefinedFunction(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+
+	var udf repositorymodels.UserDefinedFunction
+	if err := c.BindJSON(&udf); err != nil {
+		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		return
+	}
+
+	createdUdf, status := h.repository.CreateUserDefinedFunction(databaseId, collectionId, udf)
+	if status == repositorymodels.Conflict {
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		return
+	}
+
+	if status == repositorymodels.StatusOk {
+		c.IndentedJSON(http.StatusCreated, createdUdf)
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}

api/router.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"net/http"
+	"sync"
 
 	"github.com/gin-gonic/gin"
 	"github.com/pikami/cosmium/api/handlers"
@@ -13,18 +14,25 @@ import (
 	tlsprovider "github.com/pikami/cosmium/internal/tls_provider"
 )
 
+var ginMux sync.Mutex
+
 func (s *ApiServer) CreateRouter(repository *repositories.DataRepository) {
 	routeHandlers := handlers.NewHandlers(repository, s.config)
 
-	if !s.config.Debug {
+	ginMux.Lock()
+	gin.DefaultWriter = logger.InfoWriter()
+	gin.DefaultErrorWriter = logger.ErrorWriter()
+
+	if s.config.LogLevel != "debug" {
 		gin.SetMode(gin.ReleaseMode)
 	}
+	ginMux.Unlock()
 
 	router := gin.Default(func(e *gin.Engine) {
 		e.RedirectTrailingSlash = false
 	})
 
-	if s.config.Debug {
+	if s.config.LogLevel == "debug" {
 		router.Use(middleware.RequestLogger())
 	}
 
@@ -50,9 +58,23 @@ func (s *ApiServer) CreateRouter(repository *repositories.DataRepository) {
 	router.GET("/dbs/:databaseId", routeHandlers.GetDatabase)
 	router.DELETE("/dbs/:databaseId", routeHandlers.DeleteDatabase)
 
-	router.GET("/dbs/:databaseId/colls/:collId/udfs", routeHandlers.GetAllUserDefinedFunctions)
-	router.GET("/dbs/:databaseId/colls/:collId/sprocs", routeHandlers.GetAllStoredProcedures)
+	router.POST("/dbs/:databaseId/colls/:collId/triggers", routeHandlers.CreateTrigger)
 	router.GET("/dbs/:databaseId/colls/:collId/triggers", routeHandlers.GetAllTriggers)
+	router.GET("/dbs/:databaseId/colls/:collId/triggers/:triggerId", routeHandlers.GetTrigger)
+	router.PUT("/dbs/:databaseId/colls/:collId/triggers/:triggerId", routeHandlers.ReplaceTrigger)
+	router.DELETE("/dbs/:databaseId/colls/:collId/triggers/:triggerId", routeHandlers.DeleteTrigger)
+
+	router.POST("/dbs/:databaseId/colls/:collId/sprocs", routeHandlers.CreateStoredProcedure)
+	router.GET("/dbs/:databaseId/colls/:collId/sprocs", routeHandlers.GetAllStoredProcedures)
+	router.GET("/dbs/:databaseId/colls/:collId/sprocs/:sprocId", routeHandlers.GetStoredProcedure)
+	router.PUT("/dbs/:databaseId/colls/:collId/sprocs/:sprocId", routeHandlers.ReplaceStoredProcedure)
+	router.DELETE("/dbs/:databaseId/colls/:collId/sprocs/:sprocId", routeHandlers.DeleteStoredProcedure)
+
+	router.POST("/dbs/:databaseId/colls/:collId/udfs", routeHandlers.CreateUserDefinedFunction)
+	router.GET("/dbs/:databaseId/colls/:collId/udfs", routeHandlers.GetAllUserDefinedFunctions)
+	router.GET("/dbs/:databaseId/colls/:collId/udfs/:udfId", routeHandlers.GetUserDefinedFunction)
+	router.PUT("/dbs/:databaseId/colls/:collId/udfs/:udfId", routeHandlers.ReplaceUserDefinedFunction)
+	router.DELETE("/dbs/:databaseId/colls/:collId/udfs/:udfId", routeHandlers.DeleteUserDefinedFunction)
 
 	router.GET("/offers", handlers.GetOffers)
 	router.GET("/", routeHandlers.GetServerInfo)
@@ -75,10 +97,10 @@ func (s *ApiServer) Start() {
 
 	go func() {
 		<-s.stopServer
-		logger.Info("Shutting down server...")
+		logger.InfoLn("Shutting down server...")
 		err := server.Shutdown(context.TODO())
 		if err != nil {
-			logger.Error("Failed to shutdown server:", err)
+			logger.ErrorLn("Failed to shutdown server:", err)
 		}
 	}()
 
@@ -86,8 +108,8 @@ func (s *ApiServer) Start() {
 		if s.config.DisableTls {
 			logger.Infof("Listening and serving HTTP on %s\n", server.Addr)
 			err := server.ListenAndServe()
-			if err != nil {
-				logger.Error("Failed to start HTTP server:", err)
+			if err != nil && err != http.ErrServerClosed {
+				logger.ErrorLn("Failed to start HTTP server:", err)
 			}
 			s.isActive = false
 		} else if s.config.TLS_CertificatePath != "" && s.config.TLS_CertificateKey != "" {
@@ -95,8 +117,8 @@ func (s *ApiServer) Start() {
 			err := server.ListenAndServeTLS(
 				s.config.TLS_CertificatePath,
 				s.config.TLS_CertificateKey)
-			if err != nil {
-				logger.Error("Failed to start HTTPS server:", err)
+			if err != nil && err != http.ErrServerClosed {
+				logger.ErrorLn("Failed to start HTTPS server:", err)
 			}
 			s.isActive = false
 		} else {
@@ -105,8 +127,8 @@ func (s *ApiServer) Start() {
 
 			logger.Infof("Listening and serving HTTPS on %s\n", server.Addr)
 			err := server.ListenAndServeTLS("", "")
-			if err != nil {
-				logger.Error("Failed to start HTTPS server:", err)
+			if err != nil && err != http.ErrServerClosed {
+				logger.ErrorLn("Failed to start HTTPS server:", err)
 			}
 			s.isActive = false
 		}

api/tests/documents_test.go

@@ -147,6 +147,21 @@ func Test_Documents(t *testing.T) {
 		)
 	})
 
+	t.Run("Should query document with query parameters as accessor", func(t *testing.T) {
+		testCosmosQuery(t, collectionClient,
+			`select c.id
+			FROM c
+			WHERE c[@param]="67890"
+			ORDER BY c.id`,
+			[]azcosmos.QueryParameter{
+				{Name: "@param", Value: "id"},
+			},
+			[]interface{}{
+				map[string]interface{}{"id": "67890"},
+			},
+		)
+	})
+
 	t.Run("Should query array accessor", func(t *testing.T) {
 		testCosmosQuery(t, collectionClient,
 			`SELECT c.id,
@@ -220,11 +235,14 @@ func Test_Documents_Patch(t *testing.T) {
 
 	t.Run("Should PATCH document", func(t *testing.T) {
 		context := context.TODO()
-		expectedData := map[string]interface{}{"id": "67890", "pk": "456", "newField": "newValue"}
+		expectedData := map[string]interface{}{"id": "67890", "pk": "666", "newField": "newValue", "incr": 15., "setted": "isSet"}
 
 		patch := azcosmos.PatchOperations{}
 		patch.AppendAdd("/newField", "newValue")
+		patch.AppendIncrement("/incr", 15)
 		patch.AppendRemove("/isCool")
+		patch.AppendReplace("/pk", "666")
+		patch.AppendSet("/setted", "isSet")
 
 		itemResponse, err := collectionClient.PatchItem(
 			context,
@@ -237,13 +255,15 @@ func Test_Documents_Patch(t *testing.T) {
 		)
 		assert.Nil(t, err)
 
-		var itemResponseBody map[string]string
+		var itemResponseBody map[string]interface{}
 		json.Unmarshal(itemResponse.Value, &itemResponseBody)
 
 		assert.Equal(t, expectedData["id"], itemResponseBody["id"])
 		assert.Equal(t, expectedData["pk"], itemResponseBody["pk"])
 		assert.Empty(t, itemResponseBody["isCool"])
 		assert.Equal(t, expectedData["newField"], itemResponseBody["newField"])
+		assert.Equal(t, expectedData["incr"], itemResponseBody["incr"])
+		assert.Equal(t, expectedData["setted"], itemResponseBody["setted"])
 	})
 
 	t.Run("Should not allow to PATCH document ID", func(t *testing.T) {

docs/COMPATIBILITY.md

@@ -65,9 +65,9 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | Function           | Implemented |
 | ------------------ | ----------- |
 | ARRAY_CONCAT       | Yes         |
-| ARRAY_CONTAINS     | No          |
-| ARRAY_CONTAINS_ANY | No          |
-| ARRAY_CONTAINS_ALL | No          |
+| ARRAY_CONTAINS     | Yes         |
+| ARRAY_CONTAINS_ANY | Yes         |
+| ARRAY_CONTAINS_ALL | Yes         |
 | ARRAY_LENGTH       | Yes         |
 | ARRAY_SLICE        | Yes         |
 | CHOOSE             | No          |

go.mod

@@ -3,28 +3,27 @@ module github.com/pikami/cosmium
 go 1.22.0
 
 require (
-	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.9.2
+	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.12.0
 	github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v0.3.6
-	github.com/evanphx/json-patch/v5 v5.9.0
+	github.com/cosmiumdev/json-patch/v5 v5.9.3
 	github.com/gin-gonic/gin v1.10.0
 	github.com/google/uuid v1.6.0
-	github.com/stretchr/testify v1.9.0
-	golang.org/x/exp v0.0.0-20241217172543-b2144cdd0a67
+	github.com/stretchr/testify v1.10.0
+	golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8
 )
 
 require (
 	github.com/Azure/azure-sdk-for-go v68.0.0+incompatible // indirect
-	github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.2 // indirect
-	github.com/bytedance/sonic v1.12.6 // indirect
-	github.com/bytedance/sonic/loader v0.2.1 // indirect
-	github.com/cloudwego/base64x v0.1.4 // indirect
-	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 // indirect
+	github.com/bytedance/sonic v1.12.7 // indirect
+	github.com/bytedance/sonic/loader v0.2.3 // indirect
+	github.com/cloudwego/base64x v0.1.5 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.7 // indirect
-	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
+	github.com/gin-contrib/sse v1.0.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.23.0 // indirect
+	github.com/go-playground/validator/v10 v10.24.0 // indirect
 	github.com/goccy/go-json v0.10.4 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.9 // indirect
@@ -37,11 +36,11 @@ require (
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
-	golang.org/x/arch v0.12.0 // indirect
-	golang.org/x/crypto v0.31.0 // indirect
-	golang.org/x/net v0.32.0 // indirect
-	golang.org/x/sys v0.28.0 // indirect
+	golang.org/x/arch v0.13.0 // indirect
+	golang.org/x/crypto v0.32.0 // indirect
+	golang.org/x/net v0.34.0 // indirect
+	golang.org/x/sys v0.29.0 // indirect
 	golang.org/x/text v0.21.0 // indirect
-	google.golang.org/protobuf v1.36.0 // indirect
+	google.golang.org/protobuf v1.36.4 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,33 +1,32 @@
 github.com/Azure/azure-sdk-for-go v68.0.0+incompatible h1:fcYLmCpyNYRnvJbPerq7U0hS+6+I79yEDJBqVNcqUzU=
 github.com/Azure/azure-sdk-for-go v68.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.9.2 h1:c4k2FIYIh4xtwqrQwV0Ct1v5+ehlNXj5NI/MWVsiTkQ=
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.9.2/go.mod h1:5FDJtLEO/GxwNgUxbwrY3LP0pEoThTQJtk2oysdXHxM=
-github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.0.0 h1:Yoicul8bnVdQrhDMTHxdEckRGX01XvwXDHUT9zYZ3k0=
-github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.0.0/go.mod h1:+6sju8gk8FRmSajX3Oz4G5Gm7P+mbqE9FVaXXFYTkCM=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.12.0 h1:1nGuui+4POelzDwI7RG56yfQJHCnKvwfMoU7VsEp+Zg=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.12.0/go.mod h1:99EvauvlcJ1U06amZiksfYz/3aFGyIhWGHVyiZXtBAI=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0 h1:tfLQ34V6F7tVSwoTf/4lH5sE0o6eCJuNDTmH09nDpbc=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0/go.mod h1:9kIvujWAA58nmPmWB1m23fyWic1kYZMxD9CxaWn4Qpg=
 github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v0.3.6 h1:oBqQLSI1pZwGOdXJAoJJSzmff9tlfD4KroVfjQQmd0g=
 github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v0.3.6/go.mod h1:Beh5cHIXJ0oWEDWk9lNFtuklCojLLQ5hl+LqSNTTs0I=
-github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.2 h1:LqbJ/WzJUwBf8UiaSzgX7aMclParm9/5Vgp+TY51uBQ=
-github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.2/go.mod h1:yInRyqWXAuaPrgI7p70+lDDgh3mlBohis29jGMISnmc=
-github.com/AzureAD/microsoft-authentication-library-for-go v0.4.0 h1:WVsrXCnHlDDX8ls+tootqRE87/hL9S/g4ewig9RsD/c=
-github.com/AzureAD/microsoft-authentication-library-for-go v0.4.0/go.mod h1:Vt9sXTKwMyGcOxSmLDMnGPgqsUg7m8pe215qMLrDXw4=
-github.com/bytedance/sonic v1.12.6 h1:/isNmCUF2x3Sh8RAp/4mh4ZGkcFAX/hLrzrK3AvpRzk=
-github.com/bytedance/sonic v1.12.6/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 h1:ywEEhmNahHBihViHepv3xPBn1663uRv2t2q/ESv9seY=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0/go.mod h1:iZDifYGJTIgIIkYRNWPENUnqx6bJ2xnSDFI2tjwZNuY=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 h1:XHOnouVk1mxXfQidrMEnLlPk9UMeRtyBTnEFtxkV0kU=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI=
+github.com/bytedance/sonic v1.12.7 h1:CQU8pxOy9HToxhndH0Kx/S1qU/CuS9GnKYrGioDcU1Q=
+github.com/bytedance/sonic v1.12.7/go.mod h1:tnbal4mxOMju17EGfknm2XyYcpyCnIROYOEYuemj13I=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
-github.com/bytedance/sonic/loader v0.2.1 h1:1GgorWTqf12TA8mma4DDSbaQigE2wOgQo7iCjjJv3+E=
-github.com/bytedance/sonic/loader v0.2.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
-github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
-github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
-github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
+github.com/bytedance/sonic/loader v0.2.3 h1:yctD0Q3v2NOGfSWPLPvG2ggA2kV6TS6s4wioyEqssH0=
+github.com/bytedance/sonic/loader v0.2.3/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
+github.com/cloudwego/base64x v0.1.5 h1:XPciSp1xaq2VCSt6lF0phncD4koWyULpl5bUxbfCyP4=
+github.com/cloudwego/base64x v0.1.5/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
 github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
+github.com/cosmiumdev/json-patch/v5 v5.9.3 h1:l+Og3+5edqV2NHDo58sz72eS733lbXVYP61seYK43Do=
+github.com/cosmiumdev/json-patch/v5 v5.9.3/go.mod h1:WzSTCdia0WrlZtjnL19P4RiwWtfdyArm/E7stgEeP5g=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/evanphx/json-patch/v5 v5.9.0 h1:kcBlZQbplgElYIlo/n1hJbls2z/1awpXxpRi0/FOJfg=
-github.com/evanphx/json-patch/v5 v5.9.0/go.mod h1:VNkHZ/282BpEyt/tObQO8s5CMPmYYq14uClGH4abBuQ=
-github.com/gabriel-vasile/mimetype v1.4.7 h1:SKFKl7kD0RiPdbht0s7hFtjl489WcQ1VyPW8ZzUMYCA=
-github.com/gabriel-vasile/mimetype v1.4.7/go.mod h1:GDlAgAyIRT27BhFl53XNAFtfjzOkLaF35JdEG0P7LtU=
-github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
-github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
+github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
+github.com/gin-contrib/sse v1.0.0 h1:y3bT1mUWUxDpW4JLQg/HnTqV4rozuW4tC9eFKTxYI9E=
+github.com/gin-contrib/sse v1.0.0/go.mod h1:zNuFdwarAygJBht0NTKiSi3jRf6RbqeILZ9Sp6Slhe0=
 github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
 github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
@@ -36,12 +35,13 @@ github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/o
 github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
 github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.23.0 h1:/PwmTwZhS0dPkav3cdK9kV1FsAmrL8sThn8IHr/sO+o=
-github.com/go-playground/validator/v10 v10.23.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/go-playground/validator/v10 v10.24.0 h1:KHQckvo8G6hlWnrPX4NJJ+aBfWNAE/HH+qdL2cBpCmg=
+github.com/go-playground/validator/v10 v10.24.0/go.mod h1:GGzBIJMuE98Ic/kJsBXbz1x/7cByt++cQ+YOuDM5wus=
 github.com/goccy/go-json v0.10.4 h1:JSwxQzIqKfmFX1swYPpUThQZp/Ka4wzJdK0LWVytLPM=
 github.com/goccy/go-json v0.10.4/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/golang-jwt/jwt v3.2.1+incompatible h1:73Z+4BJcrTC+KczS6WvTPvRGOp1WmfEP4Q1lOd9Z/+c=
-github.com/golang-jwt/jwt v3.2.1+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
+github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
+github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
@@ -53,6 +53,10 @@ github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa02
 github.com/klauspost/cpuid/v2 v2.2.9 h1:66ze0taIn2H33fBvCkXuv9BmCwDfafmiIVpKV9kKGuY=
 github.com/klauspost/cpuid/v2 v2.2.9/go.mod h1:rqkxqrZ1EhYM9G+hXH7YdowN5R5RGN6NK4QwQ3WMXF8=
 github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
@@ -66,43 +70,48 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
 github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
-github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4 h1:Qj1ukM4GlMWXNdMBuXcXfz/Kw9s1qm0CLY32QxuSImI=
-github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4/go.mod h1:N6UoU20jOqggOuDwUaBQpluzLNDqif3kq9z2wpdYEfQ=
+github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
+github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
+github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
 github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
-golang.org/x/arch v0.12.0 h1:UsYJhbzPYGsT0HbEdmYcqtCv8UNGvnaL561NnIUvaKg=
-golang.org/x/arch v0.12.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
-golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
-golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
-golang.org/x/exp v0.0.0-20241217172543-b2144cdd0a67 h1:1UoZQm6f0P/ZO0w1Ri+f+ifG/gXhegadRdwBIXEFWDo=
-golang.org/x/exp v0.0.0-20241217172543-b2144cdd0a67/go.mod h1:qj5a5QZpwLU2NLQudwIN5koi3beDhSAlJwa67PuM98c=
-golang.org/x/net v0.32.0 h1:ZqPmj8Kzc+Y6e0+skZsuACbx+wzMgo5MQsJh9Qd6aYI=
-golang.org/x/net v0.32.0/go.mod h1:CwU0IoeOlnQQWJ6ioyFrfRuomB8GKF6KbYXZVyeXNfs=
+golang.org/x/arch v0.13.0 h1:KCkqVVV1kGg0X87TFysjCJ8MxtZEIU4Ja/yXGeoECdA=
+golang.org/x/arch v0.13.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
+golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8 h1:yqrTHse8TCMW1M1ZCP+VAR/l0kKxwaAIqN/il7x4voA=
+golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8/go.mod h1:tujkw807nyEEAamNbDrEGzRav+ilXA7PCRAd6xsmwiU=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
-golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
-google.golang.org/protobuf v1.36.0 h1:mjIs9gYtt56AzC4ZaffQuh88TZurBGhIJMBZGSxNerQ=
-google.golang.org/protobuf v1.36.0/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+google.golang.org/protobuf v1.36.4 h1:6A3ZDJHn/eNqc1i+IdefRzy/9PokBTPvcqMySR7NNIM=
+google.golang.org/protobuf v1.36.4/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/logger/logger.go

@@ -1,40 +1,140 @@
 package logger
 
 import (
+	"fmt"
 	"log"
 	"os"
+	"runtime"
+	"strings"
+	"sync"
 )
 
-var EnableDebugOutput = false
+type LogLevelType int
 
-var DebugLogger = log.New(os.Stdout, "", log.Ldate|log.Ltime|log.Lshortfile)
+var (
+	LogLevelDebug  LogLevelType = 0
+	LogLevelInfo   LogLevelType = 1
+	LogLevelError  LogLevelType = 2
+	LogLevelSilent LogLevelType = 10
+)
+
+type LogWriter struct {
+	WriterLevel LogLevelType
+}
+
+var logLevelMutex sync.RWMutex
+var logLevel = LogLevelInfo
+
+var DebugLogger = log.New(os.Stdout, "", log.Ldate|log.Ltime)
 var InfoLogger = log.New(os.Stdout, "", log.Ldate|log.Ltime)
-var ErrorLogger = log.New(os.Stderr, "", log.Ldate|log.Ltime|log.Lshortfile)
+var ErrorLogger = log.New(os.Stderr, "", log.Ldate|log.Ltime)
+
+func DebugLn(v ...any) {
+	if GetLogLevel() <= LogLevelDebug {
+		prefix := getCallerPrefix()
+		DebugLogger.Println(append([]interface{}{prefix}, v...)...)
+	}
+}
 
 func Debug(v ...any) {
-	if EnableDebugOutput {
-		DebugLogger.Println(v...)
+	if GetLogLevel() <= LogLevelDebug {
+		prefix := getCallerPrefix()
+		DebugLogger.Println(append([]interface{}{prefix}, v...)...)
 	}
 }
 
 func Debugf(format string, v ...any) {
-	if EnableDebugOutput {
-		DebugLogger.Printf(format, v...)
+	if GetLogLevel() <= LogLevelDebug {
+		prefix := getCallerPrefix()
+		DebugLogger.Printf(prefix+format, v...)
+	}
+}
+
+func InfoLn(v ...any) {
+	if GetLogLevel() <= LogLevelInfo {
+		InfoLogger.Println(v...)
 	}
 }
 
 func Info(v ...any) {
-	InfoLogger.Println(v...)
+	if GetLogLevel() <= LogLevelInfo {
+		InfoLogger.Print(v...)
+	}
 }
 
 func Infof(format string, v ...any) {
-	InfoLogger.Printf(format, v...)
+	if GetLogLevel() <= LogLevelInfo {
+		InfoLogger.Printf(format, v...)
+	}
+}
+
+func ErrorLn(v ...any) {
+	if GetLogLevel() <= LogLevelError {
+		prefix := getCallerPrefix()
+		ErrorLogger.Println(append([]interface{}{prefix}, v...)...)
+	}
 }
 
 func Error(v ...any) {
-	ErrorLogger.Println(v...)
+	if GetLogLevel() <= LogLevelError {
+		prefix := getCallerPrefix()
+		ErrorLogger.Print(append([]interface{}{prefix}, v...)...)
+	}
 }
 
 func Errorf(format string, v ...any) {
-	ErrorLogger.Printf(format, v...)
+	if GetLogLevel() <= LogLevelError {
+		prefix := getCallerPrefix()
+		ErrorLogger.Printf(prefix+format, v...)
+	}
+}
+
+func (lw *LogWriter) Write(p []byte) (n int, err error) {
+	switch lw.WriterLevel {
+	case LogLevelDebug:
+		Debug(string(p))
+	case LogLevelInfo:
+		Info(string(p))
+	case LogLevelError:
+		Error(string(p))
+	}
+
+	return len(p), nil
+}
+
+func ErrorWriter() *LogWriter {
+	return &LogWriter{WriterLevel: LogLevelError}
+}
+
+func InfoWriter() *LogWriter {
+	return &LogWriter{WriterLevel: LogLevelInfo}
+}
+
+func DebugWriter() *LogWriter {
+	return &LogWriter{WriterLevel: LogLevelDebug}
+}
+
+func SetLogLevel(level LogLevelType) {
+	logLevelMutex.Lock()
+	defer logLevelMutex.Unlock()
+	logLevel = level
+}
+
+func GetLogLevel() LogLevelType {
+	logLevelMutex.RLock()
+	defer logLevelMutex.RUnlock()
+	return logLevel
+}
+
+func getCallerPrefix() string {
+	_, file, line, ok := runtime.Caller(2)
+	if ok {
+		parts := strings.Split(file, "/")
+		if len(parts) > 0 {
+			file = parts[len(parts)-1]
+		}
+		return fmt.Sprintf("%s:%d - ", file, line)
+	}
+
+	return ""
 }

internal/repositories/collections.go

@@ -77,6 +77,9 @@ func (r *DataRepository) CreateCollection(databaseId string, newCollection repos
 
 	r.storeState.Collections[databaseId][newCollection.ID] = newCollection
 	r.storeState.Documents[databaseId][newCollection.ID] = make(map[string]repositorymodels.Document)
+	r.storeState.Triggers[databaseId][newCollection.ID] = make(map[string]repositorymodels.Trigger)
+	r.storeState.StoredProcedures[databaseId][newCollection.ID] = make(map[string]repositorymodels.StoredProcedure)
+	r.storeState.UserDefinedFunctions[databaseId][newCollection.ID] = make(map[string]repositorymodels.UserDefinedFunction)
 
 	return newCollection, repositorymodels.StatusOk
 }

internal/repositories/databases.go

@@ -57,6 +57,9 @@ func (r *DataRepository) CreateDatabase(newDatabase repositorymodels.Database) (
 	r.storeState.Databases[newDatabase.ID] = newDatabase
 	r.storeState.Collections[newDatabase.ID] = make(map[string]repositorymodels.Collection)
 	r.storeState.Documents[newDatabase.ID] = make(map[string]map[string]repositorymodels.Document)
+	r.storeState.Triggers[newDatabase.ID] = make(map[string]map[string]repositorymodels.Trigger)
+	r.storeState.StoredProcedures[newDatabase.ID] = make(map[string]map[string]repositorymodels.StoredProcedure)
+	r.storeState.UserDefinedFunctions[newDatabase.ID] = make(map[string]map[string]repositorymodels.UserDefinedFunction)
 
 	return newDatabase, repositorymodels.StatusOk
 }

internal/repositories/repositories.go

@@ -3,10 +3,7 @@ package repositories
 import repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 
 type DataRepository struct {
-	storedProcedures     []repositorymodels.StoredProcedure
-	triggers             []repositorymodels.Trigger
-	userDefinedFunctions []repositorymodels.UserDefinedFunction
-	storeState           repositorymodels.State
+	storeState repositorymodels.State
 
 	initialDataFilePath string
 	persistDataFilePath string
@@ -19,13 +16,13 @@ type RepositoryOptions struct {
 
 func NewDataRepository(options RepositoryOptions) *DataRepository {
 	repository := &DataRepository{
-		storedProcedures:     []repositorymodels.StoredProcedure{},
-		triggers:             []repositorymodels.Trigger{},
-		userDefinedFunctions: []repositorymodels.UserDefinedFunction{},
 		storeState: repositorymodels.State{
-			Databases:   make(map[string]repositorymodels.Database),
-			Collections: make(map[string]map[string]repositorymodels.Collection),
-			Documents:   make(map[string]map[string]map[string]repositorymodels.Document),
+			Databases:            make(map[string]repositorymodels.Database),
+			Collections:          make(map[string]map[string]repositorymodels.Collection),
+			Documents:            make(map[string]map[string]map[string]repositorymodels.Document),
+			Triggers:             make(map[string]map[string]map[string]repositorymodels.Trigger),
+			StoredProcedures:     make(map[string]map[string]map[string]repositorymodels.StoredProcedure),
+			UserDefinedFunctions: make(map[string]map[string]map[string]repositorymodels.UserDefinedFunction),
 		},
 		initialDataFilePath: options.InitialDataFilePath,
 		persistDataFilePath: options.PersistDataFilePath,

internal/repositories/state.go

@@ -23,7 +23,7 @@ func (r *DataRepository) InitializeRepository() {
 		}
 
 		if stat.IsDir() {
-			logger.Error("Argument '-Persist' must be a path to file, not a directory.")
+			logger.ErrorLn("Argument '-Persist' must be a path to file, not a directory.")
 			os.Exit(1)
 		}
 
@@ -39,20 +39,36 @@ func (r *DataRepository) LoadStateFS(filePath string) {
 		return
 	}
 
-	var state repositorymodels.State
-	if err := json.Unmarshal(data, &state); err != nil {
+	err = r.LoadStateJSON(string(data))
+	if err != nil {
 		log.Fatalf("Error unmarshalling state JSON: %v", err)
-		return
+	}
+}
+
+func (r *DataRepository) LoadStateJSON(jsonData string) error {
+	r.storeState.Lock()
+	defer r.storeState.Unlock()
+
+	var state repositorymodels.State
+	if err := json.Unmarshal([]byte(jsonData), &state); err != nil {
+		return err
 	}
 
-	logger.Info("Loaded state:")
-	logger.Infof("Databases: %d\n", getLength(state.Databases))
-	logger.Infof("Collections: %d\n", getLength(state.Collections))
-	logger.Infof("Documents: %d\n", getLength(state.Documents))
-
-	r.storeState = state
+	r.storeState.Collections = state.Collections
+	r.storeState.Databases = state.Databases
+	r.storeState.Documents = state.Documents
 
 	r.ensureStoreStateNoNullReferences()
+
+	logger.InfoLn("Loaded state:")
+	logger.Infof("Databases: %d\n", getLength(r.storeState.Databases))
+	logger.Infof("Collections: %d\n", getLength(r.storeState.Collections))
+	logger.Infof("Documents: %d\n", getLength(r.storeState.Documents))
+	logger.Infof("Triggers: %d\n", getLength(r.storeState.Triggers))
+	logger.Infof("Stored procedures: %d\n", getLength(r.storeState.StoredProcedures))
+	logger.Infof("User defined functions: %d\n", getLength(r.storeState.UserDefinedFunctions))
+
+	return nil
 }
 
 func (r *DataRepository) SaveStateFS(filePath string) {
@@ -67,10 +83,13 @@ func (r *DataRepository) SaveStateFS(filePath string) {
 
 	os.WriteFile(filePath, data, os.ModePerm)
 
-	logger.Info("Saved state:")
+	logger.InfoLn("Saved state:")
 	logger.Infof("Databases: %d\n", getLength(r.storeState.Databases))
 	logger.Infof("Collections: %d\n", getLength(r.storeState.Collections))
 	logger.Infof("Documents: %d\n", getLength(r.storeState.Documents))
+	logger.Infof("Triggers: %d\n", getLength(r.storeState.Triggers))
+	logger.Infof("Stored procedures: %d\n", getLength(r.storeState.StoredProcedures))
+	logger.Infof("User defined functions: %d\n", getLength(r.storeState.UserDefinedFunctions))
 }
 
 func (r *DataRepository) GetState() (string, error) {
@@ -90,7 +109,10 @@ func getLength(v interface{}) int {
 	switch v.(type) {
 	case repositorymodels.Database,
 		repositorymodels.Collection,
-		repositorymodels.Document:
+		repositorymodels.Document,
+		repositorymodels.Trigger,
+		repositorymodels.StoredProcedure,
+		repositorymodels.UserDefinedFunction:
 		return 1
 	}
 
@@ -124,6 +146,18 @@ func (r *DataRepository) ensureStoreStateNoNullReferences() {
 		r.storeState.Documents = make(map[string]map[string]map[string]repositorymodels.Document)
 	}
 
+	if r.storeState.Triggers == nil {
+		r.storeState.Triggers = make(map[string]map[string]map[string]repositorymodels.Trigger)
+	}
+
+	if r.storeState.StoredProcedures == nil {
+		r.storeState.StoredProcedures = make(map[string]map[string]map[string]repositorymodels.StoredProcedure)
+	}
+
+	if r.storeState.UserDefinedFunctions == nil {
+		r.storeState.UserDefinedFunctions = make(map[string]map[string]map[string]repositorymodels.UserDefinedFunction)
+	}
+
 	for database := range r.storeState.Databases {
 		if r.storeState.Collections[database] == nil {
 			r.storeState.Collections[database] = make(map[string]repositorymodels.Collection)
@@ -133,6 +167,18 @@ func (r *DataRepository) ensureStoreStateNoNullReferences() {
 			r.storeState.Documents[database] = make(map[string]map[string]repositorymodels.Document)
 		}
 
+		if r.storeState.Triggers[database] == nil {
+			r.storeState.Triggers[database] = make(map[string]map[string]repositorymodels.Trigger)
+		}
+
+		if r.storeState.StoredProcedures[database] == nil {
+			r.storeState.StoredProcedures[database] = make(map[string]map[string]repositorymodels.StoredProcedure)
+		}
+
+		if r.storeState.UserDefinedFunctions[database] == nil {
+			r.storeState.UserDefinedFunctions[database] = make(map[string]map[string]repositorymodels.UserDefinedFunction)
+		}
+
 		for collection := range r.storeState.Collections[database] {
 			if r.storeState.Documents[database][collection] == nil {
 				r.storeState.Documents[database][collection] = make(map[string]repositorymodels.Document)
@@ -143,6 +189,18 @@ func (r *DataRepository) ensureStoreStateNoNullReferences() {
 					delete(r.storeState.Documents[database][collection], document)
 				}
 			}
+
+			if r.storeState.Triggers[database][collection] == nil {
+				r.storeState.Triggers[database][collection] = make(map[string]repositorymodels.Trigger)
+			}
+
+			if r.storeState.StoredProcedures[database][collection] == nil {
+				r.storeState.StoredProcedures[database][collection] = make(map[string]repositorymodels.StoredProcedure)
+			}
+
+			if r.storeState.UserDefinedFunctions[database][collection] == nil {
+				r.storeState.UserDefinedFunctions[database][collection] = make(map[string]repositorymodels.UserDefinedFunction)
+			}
 		}
 	}
 }

internal/repositories/stored_procedures.go

@@ -1,7 +1,91 @@
 package repositories
 
-import repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+import (
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+	"github.com/pikami/cosmium/internal/resourceid"
+	"golang.org/x/exp/maps"
+)
 
 func (r *DataRepository) GetAllStoredProcedures(databaseId string, collectionId string) ([]repositorymodels.StoredProcedure, repositorymodels.RepositoryStatus) {
-	return r.storedProcedures, repositorymodels.StatusOk
+	r.storeState.RLock()
+	defer r.storeState.RUnlock()
+
+	return maps.Values(r.storeState.StoredProcedures[databaseId][collectionId]), repositorymodels.StatusOk
+}
+
+func (r *DataRepository) GetStoredProcedure(databaseId string, collectionId string, spId string) (repositorymodels.StoredProcedure, repositorymodels.RepositoryStatus) {
+	r.storeState.RLock()
+	defer r.storeState.RUnlock()
+
+	if _, ok := r.storeState.Databases[databaseId]; !ok {
+		return repositorymodels.StoredProcedure{}, repositorymodels.StatusNotFound
+	}
+
+	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.StoredProcedure{}, repositorymodels.StatusNotFound
+	}
+
+	if sp, ok := r.storeState.StoredProcedures[databaseId][collectionId][spId]; ok {
+		return sp, repositorymodels.StatusOk
+	}
+
+	return repositorymodels.StoredProcedure{}, repositorymodels.StatusNotFound
+}
+
+func (r *DataRepository) DeleteStoredProcedure(databaseId string, collectionId string, spId string) repositorymodels.RepositoryStatus {
+	r.storeState.Lock()
+	defer r.storeState.Unlock()
+
+	if _, ok := r.storeState.Databases[databaseId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	if _, ok := r.storeState.StoredProcedures[databaseId][collectionId][spId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	delete(r.storeState.StoredProcedures[databaseId][collectionId], spId)
+
+	return repositorymodels.StatusOk
+}
+
+func (r *DataRepository) CreateStoredProcedure(databaseId string, collectionId string, sp repositorymodels.StoredProcedure) (repositorymodels.StoredProcedure, repositorymodels.RepositoryStatus) {
+	r.storeState.Lock()
+	defer r.storeState.Unlock()
+
+	var ok bool
+	var database repositorymodels.Database
+	var collection repositorymodels.Collection
+	if sp.ID == "" {
+		return repositorymodels.StoredProcedure{}, repositorymodels.BadRequest
+	}
+
+	if database, ok = r.storeState.Databases[databaseId]; !ok {
+		return repositorymodels.StoredProcedure{}, repositorymodels.StatusNotFound
+	}
+
+	if collection, ok = r.storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.StoredProcedure{}, repositorymodels.StatusNotFound
+	}
+
+	if _, ok = r.storeState.StoredProcedures[databaseId][collectionId][sp.ID]; ok {
+		return repositorymodels.StoredProcedure{}, repositorymodels.Conflict
+	}
+
+	sp.TimeStamp = time.Now().Unix()
+	sp.ResourceID = resourceid.NewCombined(database.ResourceID, collection.ResourceID, resourceid.New())
+	sp.ETag = fmt.Sprintf("\"%s\"", uuid.New())
+	sp.Self = fmt.Sprintf("dbs/%s/colls/%s/sprocs/%s/", database.ResourceID, collection.ResourceID, sp.ResourceID)
+
+	r.storeState.StoredProcedures[databaseId][collectionId][sp.ID] = sp
+
+	return sp, repositorymodels.StatusOk
 }

internal/repositories/triggers.go

@@ -1,7 +1,91 @@
 package repositories
 
-import repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+import (
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+	"github.com/pikami/cosmium/internal/resourceid"
+	"golang.org/x/exp/maps"
+)
 
 func (r *DataRepository) GetAllTriggers(databaseId string, collectionId string) ([]repositorymodels.Trigger, repositorymodels.RepositoryStatus) {
-	return r.triggers, repositorymodels.StatusOk
+	r.storeState.RLock()
+	defer r.storeState.RUnlock()
+
+	return maps.Values(r.storeState.Triggers[databaseId][collectionId]), repositorymodels.StatusOk
+}
+
+func (r *DataRepository) GetTrigger(databaseId string, collectionId string, triggerId string) (repositorymodels.Trigger, repositorymodels.RepositoryStatus) {
+	r.storeState.RLock()
+	defer r.storeState.RUnlock()
+
+	if _, ok := r.storeState.Databases[databaseId]; !ok {
+		return repositorymodels.Trigger{}, repositorymodels.StatusNotFound
+	}
+
+	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.Trigger{}, repositorymodels.StatusNotFound
+	}
+
+	if trigger, ok := r.storeState.Triggers[databaseId][collectionId][triggerId]; ok {
+		return trigger, repositorymodels.StatusOk
+	}
+
+	return repositorymodels.Trigger{}, repositorymodels.StatusNotFound
+}
+
+func (r *DataRepository) DeleteTrigger(databaseId string, collectionId string, triggerId string) repositorymodels.RepositoryStatus {
+	r.storeState.Lock()
+	defer r.storeState.Unlock()
+
+	if _, ok := r.storeState.Databases[databaseId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	if _, ok := r.storeState.Triggers[databaseId][collectionId][triggerId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	delete(r.storeState.Triggers[databaseId][collectionId], triggerId)
+
+	return repositorymodels.StatusOk
+}
+
+func (r *DataRepository) CreateTrigger(databaseId string, collectionId string, trigger repositorymodels.Trigger) (repositorymodels.Trigger, repositorymodels.RepositoryStatus) {
+	r.storeState.Lock()
+	defer r.storeState.Unlock()
+
+	var ok bool
+	var database repositorymodels.Database
+	var collection repositorymodels.Collection
+	if trigger.ID == "" {
+		return repositorymodels.Trigger{}, repositorymodels.BadRequest
+	}
+
+	if database, ok = r.storeState.Databases[databaseId]; !ok {
+		return repositorymodels.Trigger{}, repositorymodels.StatusNotFound
+	}
+
+	if collection, ok = r.storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.Trigger{}, repositorymodels.StatusNotFound
+	}
+
+	if _, ok = r.storeState.Triggers[databaseId][collectionId][trigger.ID]; ok {
+		return repositorymodels.Trigger{}, repositorymodels.Conflict
+	}
+
+	trigger.TimeStamp = time.Now().Unix()
+	trigger.ResourceID = resourceid.NewCombined(database.ResourceID, collection.ResourceID, resourceid.New())
+	trigger.ETag = fmt.Sprintf("\"%s\"", uuid.New())
+	trigger.Self = fmt.Sprintf("dbs/%s/colls/%s/triggers/%s/", database.ResourceID, collection.ResourceID, trigger.ResourceID)
+
+	r.storeState.Triggers[databaseId][collectionId][trigger.ID] = trigger
+
+	return trigger, repositorymodels.StatusOk
 }

internal/repositories/user_defined_functions.go

@@ -1,7 +1,91 @@
 package repositories
 
-import repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+import (
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+	"github.com/pikami/cosmium/internal/resourceid"
+	"golang.org/x/exp/maps"
+)
 
 func (r *DataRepository) GetAllUserDefinedFunctions(databaseId string, collectionId string) ([]repositorymodels.UserDefinedFunction, repositorymodels.RepositoryStatus) {
-	return r.userDefinedFunctions, repositorymodels.StatusOk
+	r.storeState.RLock()
+	defer r.storeState.RUnlock()
+
+	return maps.Values(r.storeState.UserDefinedFunctions[databaseId][collectionId]), repositorymodels.StatusOk
+}
+
+func (r *DataRepository) GetUserDefinedFunction(databaseId string, collectionId string, udfId string) (repositorymodels.UserDefinedFunction, repositorymodels.RepositoryStatus) {
+	r.storeState.RLock()
+	defer r.storeState.RUnlock()
+
+	if _, ok := r.storeState.Databases[databaseId]; !ok {
+		return repositorymodels.UserDefinedFunction{}, repositorymodels.StatusNotFound
+	}
+
+	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.UserDefinedFunction{}, repositorymodels.StatusNotFound
+	}
+
+	if udf, ok := r.storeState.UserDefinedFunctions[databaseId][collectionId][udfId]; ok {
+		return udf, repositorymodels.StatusOk
+	}
+
+	return repositorymodels.UserDefinedFunction{}, repositorymodels.StatusNotFound
+}
+
+func (r *DataRepository) DeleteUserDefinedFunction(databaseId string, collectionId string, udfId string) repositorymodels.RepositoryStatus {
+	r.storeState.Lock()
+	defer r.storeState.Unlock()
+
+	if _, ok := r.storeState.Databases[databaseId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	if _, ok := r.storeState.UserDefinedFunctions[databaseId][collectionId][udfId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	delete(r.storeState.UserDefinedFunctions[databaseId][collectionId], udfId)
+
+	return repositorymodels.StatusOk
+}
+
+func (r *DataRepository) CreateUserDefinedFunction(databaseId string, collectionId string, udf repositorymodels.UserDefinedFunction) (repositorymodels.UserDefinedFunction, repositorymodels.RepositoryStatus) {
+	r.storeState.Lock()
+	defer r.storeState.Unlock()
+
+	var ok bool
+	var database repositorymodels.Database
+	var collection repositorymodels.Collection
+	if udf.ID == "" {
+		return repositorymodels.UserDefinedFunction{}, repositorymodels.BadRequest
+	}
+
+	if database, ok = r.storeState.Databases[databaseId]; !ok {
+		return repositorymodels.UserDefinedFunction{}, repositorymodels.StatusNotFound
+	}
+
+	if collection, ok = r.storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.UserDefinedFunction{}, repositorymodels.StatusNotFound
+	}
+
+	if _, ok := r.storeState.UserDefinedFunctions[databaseId][collectionId][udf.ID]; ok {
+		return repositorymodels.UserDefinedFunction{}, repositorymodels.Conflict
+	}
+
+	udf.TimeStamp = time.Now().Unix()
+	udf.ResourceID = resourceid.NewCombined(database.ResourceID, collection.ResourceID, resourceid.New())
+	udf.ETag = fmt.Sprintf("\"%s\"", uuid.New())
+	udf.Self = fmt.Sprintf("dbs/%s/colls/%s/udfs/%s/", database.ResourceID, collection.ResourceID, udf.ResourceID)
+
+	r.storeState.UserDefinedFunctions[databaseId][collectionId][udf.ID] = udf
+
+	return udf, repositorymodels.StatusOk
 }

internal/repository_models/models.go

@@ -19,6 +19,22 @@ const (
 	BadRequest     = 4
 )
 
+type TriggerOperation string
+
+const (
+	All     TriggerOperation = "All"
+	Create  TriggerOperation = "Create"
+	Delete  TriggerOperation = "Delete"
+	Replace TriggerOperation = "Replace"
+)
+
+type TriggerType string
+
+const (
+	Pre  TriggerType = "Pre"
+	Post TriggerType = "Post"
+)
+
 type Collection struct {
 	ID             string                   `json:"id"`
 	IndexingPolicy CollectionIndexingPolicy `json:"indexingPolicy"`
@@ -60,29 +76,29 @@ type UserDefinedFunction struct {
 	Body       string `json:"body"`
 	ID         string `json:"id"`
 	ResourceID string `json:"_rid"`
-	TimeStamp  int    `json:"_ts"`
+	TimeStamp  int64  `json:"_ts"`
 	Self       string `json:"_self"`
-	Etag       string `json:"_etag"`
+	ETag       string `json:"_etag"`
 }
 
 type StoredProcedure struct {
 	Body       string `json:"body"`
 	ID         string `json:"id"`
 	ResourceID string `json:"_rid"`
-	TimeStamp  int    `json:"_ts"`
+	TimeStamp  int64  `json:"_ts"`
 	Self       string `json:"_self"`
-	Etag       string `json:"_etag"`
+	ETag       string `json:"_etag"`
 }
 
 type Trigger struct {
-	Body             string `json:"body"`
-	ID               string `json:"id"`
-	TriggerOperation string `json:"triggerOperation"`
-	TriggerType      string `json:"triggerType"`
-	ResourceID       string `json:"_rid"`
-	TimeStamp        int    `json:"_ts"`
-	Self             string `json:"_self"`
-	Etag             string `json:"_etag"`
+	Body             string           `json:"body"`
+	ID               string           `json:"id"`
+	TriggerOperation TriggerOperation `json:"triggerOperation"`
+	TriggerType      TriggerType      `json:"triggerType"`
+	ResourceID       string           `json:"_rid"`
+	TimeStamp        int64            `json:"_ts"`
+	Self             string           `json:"_self"`
+	ETag             string           `json:"_etag"`
 }
 
 type Document map[string]interface{}
@@ -113,4 +129,13 @@ type State struct {
 
 	// Map databaseId -> collectionId -> documentId -> Documents
 	Documents map[string]map[string]map[string]Document `json:"documents"`
+
+	// Map databaseId -> collectionId -> triggerId -> Trigger
+	Triggers map[string]map[string]map[string]Trigger `json:"triggers"`
+
+	// Map databaseId -> collectionId -> spId -> StoredProcedure
+	StoredProcedures map[string]map[string]map[string]StoredProcedure `json:"sprocs"`
+
+	// Map databaseId -> collectionId -> udfId -> UserDefinedFunction
+	UserDefinedFunctions map[string]map[string]map[string]UserDefinedFunction `json:"udfs"`
 }

internal/tls_provider/tls_provider.go

@@ -9,7 +9,7 @@ import (
 func GetDefaultTlsConfig() *tls.Config {
 	cert, err := tls.X509KeyPair([]byte(certificate), []byte(certificateKey))
 	if err != nil {
-		logger.Error("Failed to parse certificate and key:", err)
+		logger.ErrorLn("Failed to parse certificate and key:", err)
 		return &tls.Config{}
 	}
 

parsers/models.go

@@ -123,11 +123,14 @@ const (
 	FunctionCallIsPrimitive    FunctionCallType = "IsPrimitive"
 	FunctionCallIsString       FunctionCallType = "IsString"
 
-	FunctionCallArrayConcat  FunctionCallType = "ArrayConcat"
-	FunctionCallArrayLength  FunctionCallType = "ArrayLength"
-	FunctionCallArraySlice   FunctionCallType = "ArraySlice"
-	FunctionCallSetIntersect FunctionCallType = "SetIntersect"
-	FunctionCallSetUnion     FunctionCallType = "SetUnion"
+	FunctionCallArrayConcat      FunctionCallType = "ArrayConcat"
+	FunctionCallArrayContains    FunctionCallType = "ArrayContains"
+	FunctionCallArrayContainsAny FunctionCallType = "ArrayContainsAny"
+	FunctionCallArrayContainsAll FunctionCallType = "ArrayContainsAll"
+	FunctionCallArrayLength      FunctionCallType = "ArrayLength"
+	FunctionCallArraySlice       FunctionCallType = "ArraySlice"
+	FunctionCallSetIntersect     FunctionCallType = "SetIntersect"
+	FunctionCallSetUnion         FunctionCallType = "SetUnion"
 
 	FunctionCallMathAbs              FunctionCallType = "MathAbs"
 	FunctionCallMathAcos             FunctionCallType = "MathAcos"

parsers/nosql/array_functions_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/pikami/cosmium/parsers"
+	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Parse_ArrayFunctions(t *testing.T) {
@@ -36,6 +37,119 @@ func Test_Parse_ArrayFunctions(t *testing.T) {
 		)
 	})
 
+	t.Run("Should parse function ARRAY_CONTAINS()", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT ARRAY_CONTAINS(c.a1, "value") FROM c`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Type: parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContains,
+							Arguments: []interface{}{
+								parsers.SelectItem{
+									Path: []string{"c", "a1"},
+									Type: parsers.SelectItemTypeField,
+								},
+								testutils.SelectItem_Constant_String("value"),
+								nil,
+							},
+						},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
+			},
+		)
+	})
+
+	t.Run("Should parse function ARRAY_CONTAINS() with partial match", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT ARRAY_CONTAINS(["a", "b"], "value", true) FROM c`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Type: parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContains,
+							Arguments: []interface{}{
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeArray,
+									SelectItems: []parsers.SelectItem{
+										testutils.SelectItem_Constant_String("a"),
+										testutils.SelectItem_Constant_String("b"),
+									},
+								},
+								testutils.SelectItem_Constant_String("value"),
+								testutils.SelectItem_Constant_Bool(true),
+							},
+						},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
+			},
+		)
+	})
+
+	t.Run("Should parse function ARRAY_CONTAINS_ANY()", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT ARRAY_CONTAINS_ANY(["a", "b"], "value", true) FROM c`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Type: parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAny,
+							Arguments: []interface{}{
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeArray,
+									SelectItems: []parsers.SelectItem{
+										testutils.SelectItem_Constant_String("a"),
+										testutils.SelectItem_Constant_String("b"),
+									},
+								},
+								testutils.SelectItem_Constant_String("value"),
+								testutils.SelectItem_Constant_Bool(true),
+							},
+						},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
+			},
+		)
+	})
+
+	t.Run("Should parse function ARRAY_CONTAINS_ALL()", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT ARRAY_CONTAINS_ALL(["a", "b"], "value", true) FROM c`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Type: parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAll,
+							Arguments: []interface{}{
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeArray,
+									SelectItems: []parsers.SelectItem{
+										testutils.SelectItem_Constant_String("a"),
+										testutils.SelectItem_Constant_String("b"),
+									},
+								},
+								testutils.SelectItem_Constant_String("value"),
+								testutils.SelectItem_Constant_Bool(true),
+							},
+						},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
+			},
+		)
+	})
+
 	t.Run("Should parse function ARRAY_LENGTH()", func(t *testing.T) {
 		testQueryParse(
 			t,
@@ -75,20 +189,8 @@ func Test_Parse_ArrayFunctions(t *testing.T) {
 									Path: []string{"c", "array"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 0,
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 2,
-									},
-								},
+								testutils.SelectItem_Constant_Int(0),
+								testutils.SelectItem_Constant_Int(2),
 							},
 						},
 					},

parsers/nosql/misc_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/pikami/cosmium/parsers"
 	"github.com/pikami/cosmium/parsers/nosql"
+	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 // For Parser Debugging
@@ -102,20 +103,8 @@ func Test_Parse(t *testing.T) {
 								Path: []string{"c", "id"},
 								Type: parsers.SelectItemTypeField,
 							},
-							parsers.SelectItem{
-								Type: parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{
-									Type:  parsers.ConstantTypeString,
-									Value: "123",
-								},
-							},
-							parsers.SelectItem{
-								Type: parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{
-									Type:  parsers.ConstantTypeString,
-									Value: "456",
-								},
-							},
+							testutils.SelectItem_Constant_String("123"),
+							testutils.SelectItem_Constant_String("456"),
 						},
 					},
 				},

parsers/nosql/nosql.peg

@@ -325,6 +325,7 @@ DotFieldAccess <- "." id:Identifier {
 
 ArrayFieldAccess <- "[\"" id:Identifier "\"]" { return id, nil }
   / "[" id:Integer "]" { return strconv.Itoa(id.(int)), nil }
+  / "[" id:ParameterConstant "]" { return id.(parsers.Constant).Value.(string), nil }
 
 Identifier <- [a-zA-Z_][a-zA-Z0-9_]* {
     return string(c.text), nil
@@ -456,6 +457,9 @@ AggregateFunctions <- AvgAggregateExpression
     / SumAggregateExpression
 
 ArrayFunctions <- ArrayConcatExpression
+    / ArrayContainsExpression
+    / ArrayContainsAnyExpression
+    / ArrayContainsAllExpression
     / ArrayLengthExpression
     / ArraySliceExpression
     / SetIntersectExpression
@@ -625,6 +629,18 @@ ArrayConcatExpression <- "ARRAY_CONCAT"i ws "(" ws arrays:SelectItem others:(ws
     return createFunctionCall(parsers.FunctionCallArrayConcat, append([]interface{}{arrays}, others.([]interface{})...))
 }
 
+ArrayContainsExpression <- "ARRAY_CONTAINS"i ws "(" ws array:SelectItem ws "," ws item:SelectItem partialMatch:(ws "," ws ex:SelectItem { return ex, nil })? ws ")" {
+    return createFunctionCall(parsers.FunctionCallArrayContains, []interface{}{array, item, partialMatch})
+}
+
+ArrayContainsAnyExpression <- "ARRAY_CONTAINS_ANY"i ws "(" ws array:SelectItem items:(ws "," ws ex:SelectItem { return ex, nil })+ ws ")" {
+    return createFunctionCall(parsers.FunctionCallArrayContainsAny, append([]interface{}{array}, items.([]interface{})...))
+}
+
+ArrayContainsAllExpression <- "ARRAY_CONTAINS_ALL"i ws "(" ws array:SelectItem items:(ws "," ws ex:SelectItem { return ex, nil })+ ws ")" {
+    return createFunctionCall(parsers.FunctionCallArrayContainsAll, append([]interface{}{array}, items.([]interface{})...))
+}
+
 ArrayLengthExpression <- "ARRAY_LENGTH"i ws "(" ws array:SelectItem ws ")" {
     return createFunctionCall(parsers.FunctionCallArrayLength, []interface{}{array})
 }

parsers/nosql/select_test.go

@@ -22,6 +22,20 @@ func Test_Parse_Select(t *testing.T) {
 		)
 	})
 
+	t.Run("Should parse SELECT with query parameters as accessor", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT c.id, c[@param] FROM c`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{Path: []string{"c", "id"}},
+					{Path: []string{"c", "@param"}},
+				},
+				Table: parsers.Table{Value: "c"},
+			},
+		)
+	})
+
 	t.Run("Should parse SELECT DISTINCT", func(t *testing.T) {
 		testQueryParse(
 			t,

parsers/nosql/string_functions_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/pikami/cosmium/parsers"
+	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Execute_StringFunctions(t *testing.T) {
@@ -23,20 +24,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "123",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeBoolean,
-										Value: true,
-									},
-								},
+								testutils.SelectItem_Constant_String("123"),
+								testutils.SelectItem_Constant_Bool(true),
 							},
 						},
 					},
@@ -61,13 +50,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "123",
-									},
-								},
+								testutils.SelectItem_Constant_String("123"),
 								nil,
 							},
 						},
@@ -93,13 +76,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "123",
-									},
-								},
+								testutils.SelectItem_Constant_String("123"),
 								parsers.SelectItem{
 									Path: []string{"c", "pk"},
 									Type: parsers.SelectItemTypeField,
@@ -128,20 +105,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "123",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeBoolean,
-										Value: true,
-									},
-								},
+								testutils.SelectItem_Constant_String("123"),
+								testutils.SelectItem_Constant_Bool(true),
 							},
 						},
 					},
@@ -166,20 +131,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "123",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeBoolean,
-										Value: true,
-									},
-								},
+								testutils.SelectItem_Constant_String("123"),
+								testutils.SelectItem_Constant_Bool(true),
 							},
 						},
 					},
@@ -204,20 +157,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "123",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeBoolean,
-										Value: true,
-									},
-								},
+								testutils.SelectItem_Constant_String("123"),
+								testutils.SelectItem_Constant_Bool(true),
 							},
 						},
 					},
@@ -242,20 +183,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "2",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 1,
-									},
-								},
+								testutils.SelectItem_Constant_String("2"),
+								testutils.SelectItem_Constant_Int(1),
 							},
 						},
 					},
@@ -352,13 +281,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 5,
-									},
-								},
+								testutils.SelectItem_Constant_Int(5),
 							},
 						},
 					},
@@ -431,20 +354,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "old",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "new",
-									},
-								},
+								testutils.SelectItem_Constant_String("old"),
+								testutils.SelectItem_Constant_String("new"),
 							},
 						},
 					},
@@ -469,13 +380,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 3,
-									},
-								},
+								testutils.SelectItem_Constant_Int(3),
 							},
 						},
 					},
@@ -524,13 +429,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 3,
-									},
-								},
+								testutils.SelectItem_Constant_Int(3),
 							},
 						},
 					},
@@ -579,20 +478,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 1,
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 5,
-									},
-								},
+								testutils.SelectItem_Constant_Int(1),
+								testutils.SelectItem_Constant_Int(5),
 							},
 						},
 					},

parsers/nosql/were_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/pikami/cosmium/parsers"
+	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Parse_Were(t *testing.T) {
@@ -22,10 +23,7 @@ func Test_Parse_Were(t *testing.T) {
 				Filters: parsers.ComparisonExpression{
 					Operation: "=",
 					Left:      parsers.SelectItem{Path: []string{"c", "isCool"}},
-					Right: parsers.SelectItem{
-						Type:  parsers.SelectItemTypeConstant,
-						Value: parsers.Constant{Type: parsers.ConstantTypeBoolean, Value: true},
-					},
+					Right:     testutils.SelectItem_Constant_Bool(true),
 				},
 			},
 		)
@@ -51,18 +49,12 @@ func Test_Parse_Were(t *testing.T) {
 						parsers.ComparisonExpression{
 							Operation: "=",
 							Left:      parsers.SelectItem{Path: []string{"c", "id"}},
-							Right: parsers.SelectItem{
-								Type:  parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{Type: parsers.ConstantTypeString, Value: "12345"},
-							},
+							Right:     testutils.SelectItem_Constant_String("12345"),
 						},
 						parsers.ComparisonExpression{
 							Operation: "=",
 							Left:      parsers.SelectItem{Path: []string{"c", "pk"}},
-							Right: parsers.SelectItem{
-								Type:  parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{Type: parsers.ConstantTypeInteger, Value: 123},
-							},
+							Right:     testutils.SelectItem_Constant_Int(123),
 						},
 					},
 				},
@@ -87,10 +79,7 @@ func Test_Parse_Were(t *testing.T) {
 						parsers.ComparisonExpression{
 							Operation: "=",
 							Left:      parsers.SelectItem{Path: []string{"c", "isCool"}},
-							Right: parsers.SelectItem{
-								Type:  parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{Type: parsers.ConstantTypeBoolean, Value: true},
-							},
+							Right:     testutils.SelectItem_Constant_Bool(true),
 						},
 						parsers.LogicalExpression{
 							Operation: parsers.LogicalExpressionTypeOr,
@@ -98,18 +87,12 @@ func Test_Parse_Were(t *testing.T) {
 								parsers.ComparisonExpression{
 									Operation: "=",
 									Left:      parsers.SelectItem{Path: []string{"c", "id"}},
-									Right: parsers.SelectItem{
-										Type:  parsers.SelectItemTypeConstant,
-										Value: parsers.Constant{Type: parsers.ConstantTypeString, Value: "123"},
-									},
+									Right:     testutils.SelectItem_Constant_String("123"),
 								},
 								parsers.ComparisonExpression{
 									Operation: "=",
 									Left:      parsers.SelectItem{Path: []string{"c", "id"}},
-									Right: parsers.SelectItem{
-										Type:  parsers.SelectItemTypeConstant,
-										Value: parsers.Constant{Type: parsers.ConstantTypeString, Value: "456"},
-									},
+									Right:     testutils.SelectItem_Constant_String("456"),
 								},
 							},
 						},
@@ -135,43 +118,28 @@ func Test_Parse_Were(t *testing.T) {
 				Filters: parsers.LogicalExpression{
 					Expressions: []interface{}{
 						parsers.ComparisonExpression{
-							Left: parsers.SelectItem{Path: []string{"c", "boolean"}},
-							Right: parsers.SelectItem{
-								Type:  parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{Type: parsers.ConstantTypeBoolean, Value: true},
-							},
+							Left:      parsers.SelectItem{Path: []string{"c", "boolean"}},
+							Right:     testutils.SelectItem_Constant_Bool(true),
 							Operation: "=",
 						},
 						parsers.ComparisonExpression{
-							Left: parsers.SelectItem{Path: []string{"c", "integer"}},
-							Right: parsers.SelectItem{
-								Type:  parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{Type: parsers.ConstantTypeInteger, Value: 1},
-							},
+							Left:      parsers.SelectItem{Path: []string{"c", "integer"}},
+							Right:     testutils.SelectItem_Constant_Int(1),
 							Operation: "=",
 						},
 						parsers.ComparisonExpression{
-							Left: parsers.SelectItem{Path: []string{"c", "float"}},
-							Right: parsers.SelectItem{
-								Type:  parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{Type: parsers.ConstantTypeFloat, Value: 6.9},
-							},
+							Left:      parsers.SelectItem{Path: []string{"c", "float"}},
+							Right:     testutils.SelectItem_Constant_Float(6.9),
 							Operation: "=",
 						},
 						parsers.ComparisonExpression{
-							Left: parsers.SelectItem{Path: []string{"c", "string"}},
-							Right: parsers.SelectItem{
-								Type:  parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{Type: parsers.ConstantTypeString, Value: "hello"},
-							},
+							Left:      parsers.SelectItem{Path: []string{"c", "string"}},
+							Right:     testutils.SelectItem_Constant_String("hello"),
 							Operation: "=",
 						},
 						parsers.ComparisonExpression{
-							Left: parsers.SelectItem{Path: []string{"c", "param"}},
-							Right: parsers.SelectItem{
-								Type:  parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{Type: parsers.ConstantTypeParameterConstant, Value: "@param_id1"},
-							},
+							Left:      parsers.SelectItem{Path: []string{"c", "param"}},
+							Right:     testutils.SelectItem_Constant_Parameter("@param_id1"),
 							Operation: "=",
 						},
 					},

query_executors/memory_executor/array_functions.go

@@ -16,6 +16,86 @@ func (r rowContext) array_Concat(arguments []interface{}) []interface{} {
 	return result
 }
 
+func (r rowContext) array_Contains(arguments []interface{}) bool {
+	array := r.parseArray(arguments[0])
+	if array == nil {
+		return false
+	}
+
+	exprToSearch := r.resolveSelectItem(arguments[1].(parsers.SelectItem))
+
+	partialSearch := false
+	if len(arguments) > 2 {
+		boolExpr := r.resolveSelectItem(arguments[2].(parsers.SelectItem))
+		if boolValue, ok := boolExpr.(bool); ok {
+			partialSearch = boolValue
+		} else {
+			logger.ErrorLn("array_Contains - got parameters of wrong type")
+			return false
+		}
+	}
+
+	for _, item := range array {
+		if partialSearch {
+			if r.partialMatch(item, exprToSearch) {
+				return true
+			}
+		} else {
+			if reflect.DeepEqual(item, exprToSearch) {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func (r rowContext) array_Contains_Any(arguments []interface{}) bool {
+	array := r.parseArray(arguments[0])
+	if array == nil {
+		return false
+	}
+
+	valueSelectItems := arguments[1:]
+
+	for _, valueSelectItem := range valueSelectItems {
+		value := r.resolveSelectItem(valueSelectItem.(parsers.SelectItem))
+		for _, item := range array {
+			if reflect.DeepEqual(item, value) {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func (r rowContext) array_Contains_All(arguments []interface{}) bool {
+	array := r.parseArray(arguments[0])
+	if array == nil {
+		return false
+	}
+
+	valueSelectItems := arguments[1:]
+
+	for _, valueSelectItem := range valueSelectItems {
+		value := r.resolveSelectItem(valueSelectItem.(parsers.SelectItem))
+
+		found := false
+		for _, item := range array {
+			if reflect.DeepEqual(item, value) {
+				found = true
+				break
+			}
+		}
+		if !found {
+			return false
+		}
+	}
+
+	return true
+}
+
 func (r rowContext) array_Length(arguments []interface{}) int {
 	array := r.parseArray(arguments[0])
 	if array == nil {
@@ -36,13 +116,13 @@ func (r rowContext) array_Slice(arguments []interface{}) []interface{} {
 		lengthEx := r.resolveSelectItem(arguments[2].(parsers.SelectItem))
 
 		if length, ok = lengthEx.(int); !ok {
-			logger.Error("array_Slice - got length parameters of wrong type")
+			logger.ErrorLn("array_Slice - got length parameters of wrong type")
 			return []interface{}{}
 		}
 	}
 
 	if start, ok = startEx.(int); !ok {
-		logger.Error("array_Slice - got start parameters of wrong type")
+		logger.ErrorLn("array_Slice - got start parameters of wrong type")
 		return []interface{}{}
 	}
 
@@ -117,7 +197,7 @@ func (r rowContext) parseArray(argument interface{}) []interface{} {
 
 	arrValue := reflect.ValueOf(ex)
 	if arrValue.Kind() != reflect.Slice {
-		logger.Error("parseArray got parameters of wrong type")
+		logger.ErrorLn("parseArray got parameters of wrong type")
 		return nil
 	}
 
@@ -129,3 +209,21 @@ func (r rowContext) parseArray(argument interface{}) []interface{} {
 
 	return result
 }
+
+func (r rowContext) partialMatch(item interface{}, exprToSearch interface{}) bool {
+	itemValue := reflect.ValueOf(item)
+	exprValue := reflect.ValueOf(exprToSearch)
+
+	if itemValue.Kind() != reflect.Map || exprValue.Kind() != reflect.Map {
+		logger.ErrorLn("partialMatch got parameters of wrong type")
+		return false
+	}
+
+	for _, key := range exprValue.MapKeys() {
+		if itemValue.MapIndex(key).Interface() != exprValue.MapIndex(key).Interface() {
+			return false
+		}
+	}
+
+	return true
+}

query_executors/memory_executor/array_functions_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/pikami/cosmium/parsers"
 	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
+	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Execute_ArrayFunctions(t *testing.T) {
@@ -52,6 +53,286 @@ func Test_Execute_ArrayFunctions(t *testing.T) {
 		)
 	})
 
+	t.Run("Should execute function ARRAY_CONTAINS()", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				Parameters: map[string]interface{}{
+					"@categories":                []interface{}{"coats", "jackets", "sweatshirts"},
+					"@objectArray":               []interface{}{map[string]interface{}{"category": "shirts", "color": "blue"}},
+					"@fullMatchObject":           map[string]interface{}{"category": "shirts", "color": "blue"},
+					"@partialMatchObject":        map[string]interface{}{"category": "shirts"},
+					"@missingPartialMatchObject": map[string]interface{}{"category": "shorts", "color": "blue"},
+				},
+				SelectItems: []parsers.SelectItem{
+					{
+						Alias: "ContainsItem",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContains,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@categories"),
+								testutils.SelectItem_Constant_String("coats"),
+							},
+						},
+					},
+					{
+						Alias: "MissingItem",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContains,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@categories"),
+								testutils.SelectItem_Constant_String("hoodies"),
+							},
+						},
+					},
+					{
+						Alias: "ContainsFullMatchObject",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContains,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@objectArray"),
+								testutils.SelectItem_Constant_Parameter("@fullMatchObject"),
+							},
+						},
+					},
+					{
+						Alias: "MissingFullMatchObject",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContains,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@objectArray"),
+								testutils.SelectItem_Constant_Parameter("@partialMatchObject"),
+							},
+						},
+					},
+					{
+						Alias: "ContainsPartialMatchObject",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContains,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@objectArray"),
+								testutils.SelectItem_Constant_Parameter("@partialMatchObject"),
+								testutils.SelectItem_Constant_Bool(true),
+							},
+						},
+					},
+					{
+						Alias: "MissingPartialMatchObject",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContains,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@objectArray"),
+								testutils.SelectItem_Constant_Parameter("@missingPartialMatchObject"),
+								testutils.SelectItem_Constant_Bool(true),
+							},
+						},
+					},
+				},
+			},
+			[]memoryexecutor.RowType{map[string]interface{}{"id": "123"}},
+			[]memoryexecutor.RowType{
+				map[string]interface{}{
+					"ContainsItem":               true,
+					"MissingItem":                false,
+					"ContainsFullMatchObject":    true,
+					"MissingFullMatchObject":     false,
+					"ContainsPartialMatchObject": true,
+					"MissingPartialMatchObject":  false,
+				},
+			},
+		)
+	})
+
+	t.Run("Should execute function ARRAY_CONTAINS_ANY()", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				Parameters: map[string]interface{}{
+					"@mixedArray": []interface{}{1, true, "3", []int{1, 2, 3}},
+					"@numbers":    []interface{}{1, 2, 3, 4},
+					"@emptyArray": []interface{}{},
+					"@arr123":     []interface{}{1, 2, 3},
+				},
+				SelectItems: []parsers.SelectItem{
+					{
+						Alias: "matchesEntireArray",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAny,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@mixedArray"),
+								testutils.SelectItem_Constant_Int(1),
+								testutils.SelectItem_Constant_Bool(true),
+								testutils.SelectItem_Constant_String("3"),
+								testutils.SelectItem_Constant_Parameter("@arr123"),
+							},
+						},
+					},
+					{
+						Alias: "matchesSomeValues",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAny,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@numbers"),
+								testutils.SelectItem_Constant_Int(2),
+								testutils.SelectItem_Constant_Int(3),
+								testutils.SelectItem_Constant_Int(4),
+								testutils.SelectItem_Constant_Int(5),
+							},
+						},
+					},
+					{
+						Alias: "matchSingleValue",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAny,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@numbers"),
+								testutils.SelectItem_Constant_Int(1),
+							},
+						},
+					},
+					{
+						Alias: "noMatches",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAny,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@numbers"),
+								testutils.SelectItem_Constant_Int(5),
+								testutils.SelectItem_Constant_Int(6),
+								testutils.SelectItem_Constant_Int(7),
+								testutils.SelectItem_Constant_Int(8),
+							},
+						},
+					},
+					{
+						Alias: "emptyArray",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAny,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@emptyArray"),
+								testutils.SelectItem_Constant_Int(1),
+								testutils.SelectItem_Constant_Int(2),
+								testutils.SelectItem_Constant_Int(3),
+							},
+						},
+					},
+				},
+			},
+			[]memoryexecutor.RowType{map[string]interface{}{"id": "123"}},
+			[]memoryexecutor.RowType{
+				map[string]interface{}{
+					"matchesEntireArray": true,
+					"matchesSomeValues":  true,
+					"matchSingleValue":   true,
+					"noMatches":          false,
+					"emptyArray":         false,
+				},
+			},
+		)
+	})
+
+	t.Run("Should execute function ARRAY_CONTAINS_ALL()", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				Parameters: map[string]interface{}{
+					"@mixedArray": []interface{}{1, true, "3", []interface{}{1, 2, 3}},
+					"@numbers":    []interface{}{1, 2, 3, 4},
+					"@emptyArray": []interface{}{},
+					"@arr123":     []interface{}{1, 2, 3},
+				},
+				SelectItems: []parsers.SelectItem{
+					{
+						Alias: "matchesEntireArray",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAll,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@mixedArray"),
+								testutils.SelectItem_Constant_Int(1),
+								testutils.SelectItem_Constant_Bool(true),
+								testutils.SelectItem_Constant_String("3"),
+								testutils.SelectItem_Constant_Parameter("@arr123"),
+							},
+						},
+					},
+					{
+						Alias: "matchesSomeValues",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAll,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@numbers"),
+								testutils.SelectItem_Constant_Int(2),
+								testutils.SelectItem_Constant_Int(3),
+								testutils.SelectItem_Constant_Int(4),
+								testutils.SelectItem_Constant_Int(5),
+							},
+						},
+					},
+					{
+						Alias: "matchSingleValue",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAll,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@numbers"),
+								testutils.SelectItem_Constant_Int(1),
+							},
+						},
+					},
+					{
+						Alias: "noMatches",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAll,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@numbers"),
+								testutils.SelectItem_Constant_Int(5),
+								testutils.SelectItem_Constant_Int(6),
+								testutils.SelectItem_Constant_Int(7),
+								testutils.SelectItem_Constant_Int(8),
+							},
+						},
+					},
+					{
+						Alias: "emptyArray",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallArrayContainsAll,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Parameter("@emptyArray"),
+								testutils.SelectItem_Constant_Int(1),
+								testutils.SelectItem_Constant_Int(2),
+								testutils.SelectItem_Constant_Int(3),
+							},
+						},
+					},
+				},
+			},
+			[]memoryexecutor.RowType{map[string]interface{}{"id": "123"}},
+			[]memoryexecutor.RowType{
+				map[string]interface{}{
+					"matchesEntireArray": true,
+					"matchesSomeValues":  false,
+					"matchSingleValue":   true,
+					"noMatches":          false,
+					"emptyArray":         false,
+				},
+			},
+		)
+	})
+
 	t.Run("Should execute function ARRAY_LENGTH()", func(t *testing.T) {
 		testQueryExecute(
 			t,
@@ -105,20 +386,8 @@ func Test_Execute_ArrayFunctions(t *testing.T) {
 									Path: []string{"c", "arr2"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 1,
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 2,
-									},
-								},
+								testutils.SelectItem_Constant_Int(1),
+								testutils.SelectItem_Constant_Int(2),
 							},
 						},
 					},

query_executors/memory_executor/math_functions.go

@@ -21,7 +21,7 @@ func (r rowContext) math_Abs(arguments []interface{}) interface{} {
 		}
 		return val
 	default:
-		logger.Debug("math_Abs - got parameters of wrong type")
+		logger.DebugLn("math_Abs - got parameters of wrong type")
 		return 0
 	}
 }
@@ -32,12 +32,12 @@ func (r rowContext) math_Acos(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Acos - got parameters of wrong type")
+		logger.DebugLn("math_Acos - got parameters of wrong type")
 		return nil
 	}
 
 	if val < -1 || val > 1 {
-		logger.Debug("math_Acos - value out of domain for acos")
+		logger.DebugLn("math_Acos - value out of domain for acos")
 		return nil
 	}
 
@@ -50,12 +50,12 @@ func (r rowContext) math_Asin(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Asin - got parameters of wrong type")
+		logger.DebugLn("math_Asin - got parameters of wrong type")
 		return nil
 	}
 
 	if val < -1 || val > 1 {
-		logger.Debug("math_Asin - value out of domain for acos")
+		logger.DebugLn("math_Asin - value out of domain for acos")
 		return nil
 	}
 
@@ -68,7 +68,7 @@ func (r rowContext) math_Atan(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Atan - got parameters of wrong type")
+		logger.DebugLn("math_Atan - got parameters of wrong type")
 		return nil
 	}
 
@@ -85,7 +85,7 @@ func (r rowContext) math_Ceiling(arguments []interface{}) interface{} {
 	case int:
 		return val
 	default:
-		logger.Debug("math_Ceiling - got parameters of wrong type")
+		logger.DebugLn("math_Ceiling - got parameters of wrong type")
 		return 0
 	}
 }
@@ -96,7 +96,7 @@ func (r rowContext) math_Cos(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Cos - got parameters of wrong type")
+		logger.DebugLn("math_Cos - got parameters of wrong type")
 		return nil
 	}
 
@@ -109,12 +109,12 @@ func (r rowContext) math_Cot(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Cot - got parameters of wrong type")
+		logger.DebugLn("math_Cot - got parameters of wrong type")
 		return nil
 	}
 
 	if val == 0 {
-		logger.Debug("math_Cot - cotangent undefined for zero")
+		logger.DebugLn("math_Cot - cotangent undefined for zero")
 		return nil
 	}
 
@@ -127,7 +127,7 @@ func (r rowContext) math_Degrees(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Degrees - got parameters of wrong type")
+		logger.DebugLn("math_Degrees - got parameters of wrong type")
 		return nil
 	}
 
@@ -140,7 +140,7 @@ func (r rowContext) math_Exp(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Exp - got parameters of wrong type")
+		logger.DebugLn("math_Exp - got parameters of wrong type")
 		return nil
 	}
 
@@ -157,7 +157,7 @@ func (r rowContext) math_Floor(arguments []interface{}) interface{} {
 	case int:
 		return val
 	default:
-		logger.Debug("math_Floor - got parameters of wrong type")
+		logger.DebugLn("math_Floor - got parameters of wrong type")
 		return 0
 	}
 }
@@ -170,7 +170,7 @@ func (r rowContext) math_IntBitNot(arguments []interface{}) interface{} {
 	case int:
 		return ^val
 	default:
-		logger.Debug("math_IntBitNot - got parameters of wrong type")
+		logger.DebugLn("math_IntBitNot - got parameters of wrong type")
 		return nil
 	}
 }
@@ -181,12 +181,12 @@ func (r rowContext) math_Log10(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Log10 - got parameters of wrong type")
+		logger.DebugLn("math_Log10 - got parameters of wrong type")
 		return nil
 	}
 
 	if val <= 0 {
-		logger.Debug("math_Log10 - value must be greater than 0")
+		logger.DebugLn("math_Log10 - value must be greater than 0")
 		return nil
 	}
 
@@ -199,7 +199,7 @@ func (r rowContext) math_Radians(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Radians - got parameters of wrong type")
+		logger.DebugLn("math_Radians - got parameters of wrong type")
 		return nil
 	}
 
@@ -216,7 +216,7 @@ func (r rowContext) math_Round(arguments []interface{}) interface{} {
 	case int:
 		return val
 	default:
-		logger.Debug("math_Round - got parameters of wrong type")
+		logger.DebugLn("math_Round - got parameters of wrong type")
 		return nil
 	}
 }
@@ -243,7 +243,7 @@ func (r rowContext) math_Sign(arguments []interface{}) interface{} {
 			return 0
 		}
 	default:
-		logger.Debug("math_Sign - got parameters of wrong type")
+		logger.DebugLn("math_Sign - got parameters of wrong type")
 		return nil
 	}
 }
@@ -254,7 +254,7 @@ func (r rowContext) math_Sin(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Sin - got parameters of wrong type")
+		logger.DebugLn("math_Sin - got parameters of wrong type")
 		return nil
 	}
 
@@ -267,7 +267,7 @@ func (r rowContext) math_Sqrt(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Sqrt - got parameters of wrong type")
+		logger.DebugLn("math_Sqrt - got parameters of wrong type")
 		return nil
 	}
 
@@ -280,7 +280,7 @@ func (r rowContext) math_Square(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Square - got parameters of wrong type")
+		logger.DebugLn("math_Square - got parameters of wrong type")
 		return nil
 	}
 
@@ -293,7 +293,7 @@ func (r rowContext) math_Tan(arguments []interface{}) interface{} {
 
 	val, valIsNumber := numToFloat64(ex)
 	if !valIsNumber {
-		logger.Debug("math_Tan - got parameters of wrong type")
+		logger.DebugLn("math_Tan - got parameters of wrong type")
 		return nil
 	}
 
@@ -310,7 +310,7 @@ func (r rowContext) math_Trunc(arguments []interface{}) interface{} {
 	case int:
 		return float64(val)
 	default:
-		logger.Debug("math_Trunc - got parameters of wrong type")
+		logger.DebugLn("math_Trunc - got parameters of wrong type")
 		return nil
 	}
 }
@@ -325,7 +325,7 @@ func (r rowContext) math_Atn2(arguments []interface{}) interface{} {
 	x, xIsNumber := numToFloat64(ex2)
 
 	if !yIsNumber || !xIsNumber {
-		logger.Debug("math_Atn2 - got parameters of wrong type")
+		logger.DebugLn("math_Atn2 - got parameters of wrong type")
 		return nil
 	}
 
@@ -342,7 +342,7 @@ func (r rowContext) math_IntAdd(arguments []interface{}) interface{} {
 	ex2Number, ex2IsNumber := numToInt(ex2)
 
 	if !ex1IsNumber || !ex2IsNumber {
-		logger.Debug("math_IntAdd - got parameters of wrong type")
+		logger.DebugLn("math_IntAdd - got parameters of wrong type")
 		return nil
 	}
 
@@ -359,7 +359,7 @@ func (r rowContext) math_IntBitAnd(arguments []interface{}) interface{} {
 	ex2Int, ex2IsInt := numToInt(ex2)
 
 	if !ex1IsInt || !ex2IsInt {
-		logger.Debug("math_IntBitAnd - got parameters of wrong type")
+		logger.DebugLn("math_IntBitAnd - got parameters of wrong type")
 		return nil
 	}
 
@@ -376,7 +376,7 @@ func (r rowContext) math_IntBitLeftShift(arguments []interface{}) interface{} {
 	num2, num2IsInt := numToInt(ex2)
 
 	if !num1IsInt || !num2IsInt {
-		logger.Debug("math_IntBitLeftShift - got parameters of wrong type")
+		logger.DebugLn("math_IntBitLeftShift - got parameters of wrong type")
 		return nil
 	}
 
@@ -393,7 +393,7 @@ func (r rowContext) math_IntBitOr(arguments []interface{}) interface{} {
 	num2, num2IsInt := ex2.(int)
 
 	if !num1IsInt || !num2IsInt {
-		logger.Debug("math_IntBitOr - got parameters of wrong type")
+		logger.DebugLn("math_IntBitOr - got parameters of wrong type")
 		return nil
 	}
 
@@ -410,7 +410,7 @@ func (r rowContext) math_IntBitRightShift(arguments []interface{}) interface{} {
 	num2, num2IsInt := numToInt(ex2)
 
 	if !num1IsInt || !num2IsInt {
-		logger.Debug("math_IntBitRightShift - got parameters of wrong type")
+		logger.DebugLn("math_IntBitRightShift - got parameters of wrong type")
 		return nil
 	}
 
@@ -427,7 +427,7 @@ func (r rowContext) math_IntBitXor(arguments []interface{}) interface{} {
 	num2, num2IsInt := ex2.(int)
 
 	if !num1IsInt || !num2IsInt {
-		logger.Debug("math_IntBitXor - got parameters of wrong type")
+		logger.DebugLn("math_IntBitXor - got parameters of wrong type")
 		return nil
 	}
 
@@ -444,7 +444,7 @@ func (r rowContext) math_IntDiv(arguments []interface{}) interface{} {
 	num2, num2IsInt := ex2.(int)
 
 	if !num1IsInt || !num2IsInt || num2 == 0 {
-		logger.Debug("math_IntDiv - got parameters of wrong type or divide by zero")
+		logger.DebugLn("math_IntDiv - got parameters of wrong type or divide by zero")
 		return nil
 	}
 
@@ -461,7 +461,7 @@ func (r rowContext) math_IntMul(arguments []interface{}) interface{} {
 	num2, num2IsInt := ex2.(int)
 
 	if !num1IsInt || !num2IsInt {
-		logger.Debug("math_IntMul - got parameters of wrong type")
+		logger.DebugLn("math_IntMul - got parameters of wrong type")
 		return nil
 	}
 
@@ -478,7 +478,7 @@ func (r rowContext) math_IntSub(arguments []interface{}) interface{} {
 	num2, num2IsInt := ex2.(int)
 
 	if !num1IsInt || !num2IsInt {
-		logger.Debug("math_IntSub - got parameters of wrong type")
+		logger.DebugLn("math_IntSub - got parameters of wrong type")
 		return nil
 	}
 
@@ -495,7 +495,7 @@ func (r rowContext) math_IntMod(arguments []interface{}) interface{} {
 	num2, num2IsInt := ex2.(int)
 
 	if !num1IsInt || !num2IsInt || num2 == 0 {
-		logger.Debug("math_IntMod - got parameters of wrong type or divide by zero")
+		logger.DebugLn("math_IntMod - got parameters of wrong type or divide by zero")
 		return nil
 	}
 
@@ -512,7 +512,7 @@ func (r rowContext) math_Power(arguments []interface{}) interface{} {
 	exponent, exponentIsNumber := numToFloat64(ex2)
 
 	if !baseIsNumber || !exponentIsNumber {
-		logger.Debug("math_Power - got parameters of wrong type")
+		logger.DebugLn("math_Power - got parameters of wrong type")
 		return nil
 	}
 
@@ -530,21 +530,21 @@ func (r rowContext) math_Log(arguments []interface{}) interface{} {
 		baseValue, baseValueIsNumber := numToFloat64(baseValueObject)
 
 		if !baseValueIsNumber {
-			logger.Debug("math_Log - base parameter must be a numeric value")
+			logger.DebugLn("math_Log - base parameter must be a numeric value")
 			return nil
 		}
 
 		if baseValue > 0 && baseValue != 1 {
 			base = baseValue
 		} else {
-			logger.Debug("math_Log - base must be greater than 0 and not equal to 1")
+			logger.DebugLn("math_Log - base must be greater than 0 and not equal to 1")
 			return nil
 		}
 	}
 
 	num, numIsNumber := numToFloat64(ex)
 	if !numIsNumber || num <= 0 {
-		logger.Debug("math_Log - parameter must be a positive numeric value")
+		logger.DebugLn("math_Log - parameter must be a positive numeric value")
 		return nil
 	}
 
@@ -563,21 +563,21 @@ func (r rowContext) math_NumberBin(arguments []interface{}) interface{} {
 		binSizeValue, binSizeValueIsNumber := numToFloat64(binSizeValueObject)
 
 		if !binSizeValueIsNumber {
-			logger.Debug("math_NumberBin - base parameter must be a numeric value")
+			logger.DebugLn("math_NumberBin - base parameter must be a numeric value")
 			return nil
 		}
 
 		if binSizeValue != 0 {
 			binSize = binSizeValue
 		} else {
-			logger.Debug("math_NumberBin - base must not be equal to 0")
+			logger.DebugLn("math_NumberBin - base must not be equal to 0")
 			return nil
 		}
 	}
 
 	num, numIsNumber := numToFloat64(ex)
 	if !numIsNumber {
-		logger.Debug("math_NumberBin - parameter must be a numeric value")
+		logger.DebugLn("math_NumberBin - parameter must be a numeric value")
 		return nil
 	}
 

query_executors/memory_executor/memory_executor.go

@@ -172,7 +172,7 @@ func (r rowContext) filters_ComparisonExpression(expression parsers.ComparisonEx
 	rightExpression, rightExpressionOk := expression.Right.(parsers.SelectItem)
 
 	if !leftExpressionOk || !rightExpressionOk {
-		logger.Error("ComparisonExpression has incorrect Left or Right type")
+		logger.ErrorLn("ComparisonExpression has incorrect Left or Right type")
 		return false
 	}
 
@@ -317,6 +317,10 @@ func (r rowContext) applyProjection(selectItems []parsers.SelectItem) RowType {
 			} else {
 				destinationName = fmt.Sprintf("$%d", index+1)
 			}
+
+			if destinationName[0] == '@' {
+				destinationName = r.parameters[destinationName].(string)
+			}
 		}
 
 		row[destinationName] = r.resolveSelectItem(selectItem)
@@ -347,7 +351,7 @@ func (r rowContext) resolveSelectItem(selectItem parsers.SelectItem) interface{}
 			return r.selectItem_SelectItemTypeFunctionCall(typedFunctionCall)
 		}
 
-		logger.Error("parsers.SelectItem has incorrect Value type (expected parsers.FunctionCall)")
+		logger.ErrorLn("parsers.SelectItem has incorrect Value type (expected parsers.FunctionCall)")
 		return nil
 	}
 
@@ -375,7 +379,7 @@ func (r rowContext) selectItem_SelectItemTypeConstant(selectItem parsers.SelectI
 	var ok bool
 	if typedValue, ok = selectItem.Value.(parsers.Constant); !ok {
 		// TODO: Handle error
-		logger.Error("parsers.Constant has incorrect Value type")
+		logger.ErrorLn("parsers.Constant has incorrect Value type")
 	}
 
 	if typedValue.Type == parsers.ConstantTypeParameterConstant &&
@@ -466,6 +470,12 @@ func (r rowContext) selectItem_SelectItemTypeFunctionCall(functionCall parsers.F
 
 	case parsers.FunctionCallArrayConcat:
 		return r.array_Concat(functionCall.Arguments)
+	case parsers.FunctionCallArrayContains:
+		return r.array_Contains(functionCall.Arguments)
+	case parsers.FunctionCallArrayContainsAny:
+		return r.array_Contains_Any(functionCall.Arguments)
+	case parsers.FunctionCallArrayContainsAll:
+		return r.array_Contains_All(functionCall.Arguments)
 	case parsers.FunctionCallArrayLength:
 		return r.array_Length(functionCall.Arguments)
 	case parsers.FunctionCallArraySlice:
@@ -572,6 +582,9 @@ func (r rowContext) selectItem_SelectItemTypeField(selectItem parsers.SelectItem
 
 	if len(selectItem.Path) > 1 {
 		for _, pathSegment := range selectItem.Path[1:] {
+			if pathSegment[0] == '@' {
+				pathSegment = r.parameters[pathSegment].(string)
+			}
 
 			switch nestedValue := value.(type) {
 			case map[string]interface{}:

query_executors/memory_executor/misc_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/pikami/cosmium/parsers"
 	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
+	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func testQueryExecute(
@@ -111,20 +112,8 @@ func Test_Execute(t *testing.T) {
 								Path: []string{"c", "id"},
 								Type: parsers.SelectItemTypeField,
 							},
-							parsers.SelectItem{
-								Type: parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{
-									Type:  parsers.ConstantTypeString,
-									Value: "123",
-								},
-							},
-							parsers.SelectItem{
-								Type: parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{
-									Type:  parsers.ConstantTypeString,
-									Value: "456",
-								},
-							},
+							testutils.SelectItem_Constant_String("123"),
+							testutils.SelectItem_Constant_String("456"),
 						},
 					},
 				},

query_executors/memory_executor/select_test.go

@@ -35,6 +35,29 @@ func Test_Execute_Select(t *testing.T) {
 		)
 	})
 
+	t.Run("Should execute SELECT with query parameters as accessor", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{Path: []string{"c", "id"}},
+					{Path: []string{"c", "@param"}},
+				},
+				Table: parsers.Table{Value: "c"},
+				Parameters: map[string]interface{}{
+					"@param": "pk",
+				},
+			},
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"id": "12345", "pk": 123},
+				map[string]interface{}{"id": "67890", "pk": 456},
+				map[string]interface{}{"id": "456", "pk": 456},
+				map[string]interface{}{"id": "123", "pk": 456},
+			},
+		)
+	})
+
 	t.Run("Should execute SELECT DISTINCT", func(t *testing.T) {
 		testQueryExecute(
 			t,

query_executors/memory_executor/string_functions.go

@@ -119,7 +119,7 @@ func (r rowContext) strings_Left(arguments []interface{}) string {
 	lengthEx := r.resolveSelectItem(arguments[1].(parsers.SelectItem))
 
 	if length, ok = lengthEx.(int); !ok {
-		logger.Error("strings_Left - got parameters of wrong type")
+		logger.ErrorLn("strings_Left - got parameters of wrong type")
 		return ""
 	}
 
@@ -158,7 +158,7 @@ func (r rowContext) strings_Replicate(arguments []interface{}) string {
 	timesEx := r.resolveSelectItem(arguments[1].(parsers.SelectItem))
 
 	if times, ok = timesEx.(int); !ok {
-		logger.Error("strings_Replicate - got parameters of wrong type")
+		logger.ErrorLn("strings_Replicate - got parameters of wrong type")
 		return ""
 	}
 
@@ -191,7 +191,7 @@ func (r rowContext) strings_Right(arguments []interface{}) string {
 	lengthEx := r.resolveSelectItem(arguments[1].(parsers.SelectItem))
 
 	if length, ok = lengthEx.(int); !ok {
-		logger.Error("strings_Right - got parameters of wrong type")
+		logger.ErrorLn("strings_Right - got parameters of wrong type")
 		return ""
 	}
 
@@ -220,11 +220,11 @@ func (r rowContext) strings_Substring(arguments []interface{}) string {
 	lengthEx := r.resolveSelectItem(arguments[2].(parsers.SelectItem))
 
 	if startPos, ok = startPosEx.(int); !ok {
-		logger.Error("strings_Substring - got start parameters of wrong type")
+		logger.ErrorLn("strings_Substring - got start parameters of wrong type")
 		return ""
 	}
 	if length, ok = lengthEx.(int); !ok {
-		logger.Error("strings_Substring - got length parameters of wrong type")
+		logger.ErrorLn("strings_Substring - got length parameters of wrong type")
 		return ""
 	}
 
@@ -264,7 +264,7 @@ func (r rowContext) parseString(argument interface{}) string {
 		return str1
 	}
 
-	logger.Error("StringEquals got parameters of wrong type")
+	logger.ErrorLn("StringEquals got parameters of wrong type")
 	return ""
 }
 

query_executors/memory_executor/string_functions_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/pikami/cosmium/parsers"
 	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
+	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Execute_StringFunctions(t *testing.T) {
@@ -33,20 +34,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "pk"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "aaa",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeBoolean,
-										Value: true,
-									},
-								},
+								testutils.SelectItem_Constant_String("aaa"),
+								testutils.SelectItem_Constant_Bool(true),
 							},
 						},
 					},
@@ -81,13 +70,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "pk"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "aaa",
-									},
-								},
+								testutils.SelectItem_Constant_String("aaa"),
 								nil,
 							},
 						},
@@ -119,20 +102,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: " ",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: 123,
-									},
-								},
+								testutils.SelectItem_Constant_String(" "),
+								testutils.SelectItem_Constant_Int(123),
 								parsers.SelectItem{
 									Path: []string{"c", "pk"},
 									Type: parsers.SelectItemTypeField,
@@ -171,20 +142,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "2",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeBoolean,
-										Value: true,
-									},
-								},
+								testutils.SelectItem_Constant_String("2"),
+								testutils.SelectItem_Constant_Bool(true),
 							},
 						},
 					},
@@ -219,20 +178,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "3",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeBoolean,
-										Value: true,
-									},
-								},
+								testutils.SelectItem_Constant_String("3"),
+								testutils.SelectItem_Constant_Bool(true),
 							},
 						},
 					},
@@ -267,20 +214,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "1",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeBoolean,
-										Value: true,
-									},
-								},
+								testutils.SelectItem_Constant_String("1"),
+								testutils.SelectItem_Constant_Bool(true),
 							},
 						},
 					},
@@ -315,20 +250,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "str"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "o",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 4,
-									},
-								},
+								testutils.SelectItem_Constant_String("o"),
+								testutils.SelectItem_Constant_Int(4),
 							},
 						},
 					},
@@ -397,13 +320,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "str"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 3,
-									},
-								},
+								testutils.SelectItem_Constant_Int(3),
 							},
 						},
 					},
@@ -506,20 +423,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "str"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "world",
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeString,
-										Value: "universe",
-									},
-								},
+								testutils.SelectItem_Constant_String("world"),
+								testutils.SelectItem_Constant_String("universe"),
 							},
 						},
 					},
@@ -554,13 +459,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "str"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 3,
-									},
-								},
+								testutils.SelectItem_Constant_Int(3),
 							},
 						},
 					},
@@ -629,13 +528,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "str"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 3,
-									},
-								},
+								testutils.SelectItem_Constant_Int(3),
 							},
 						},
 					},
@@ -704,20 +597,8 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "str"},
 									Type: parsers.SelectItemTypeField,
 								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 2,
-									},
-								},
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeConstant,
-									Value: parsers.Constant{
-										Type:  parsers.ConstantTypeInteger,
-										Value: 4,
-									},
-								},
+								testutils.SelectItem_Constant_Int(2),
+								testutils.SelectItem_Constant_Int(4),
 							},
 						},
 					},

query_executors/memory_executor/were_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/pikami/cosmium/parsers"
 	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
+	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Execute_Where(t *testing.T) {
@@ -26,10 +27,7 @@ func Test_Execute_Where(t *testing.T) {
 				Filters: parsers.ComparisonExpression{
 					Operation: "=",
 					Left:      parsers.SelectItem{Path: []string{"c", "isCool"}},
-					Right: parsers.SelectItem{
-						Type:  parsers.SelectItemTypeConstant,
-						Value: parsers.Constant{Type: parsers.ConstantTypeBoolean, Value: true},
-					},
+					Right:     testutils.SelectItem_Constant_Bool(true),
 				},
 			},
 			mockData,
@@ -52,10 +50,7 @@ func Test_Execute_Where(t *testing.T) {
 				Filters: parsers.ComparisonExpression{
 					Operation: "=",
 					Left:      parsers.SelectItem{Path: []string{"c", "id"}},
-					Right: parsers.SelectItem{
-						Type:  parsers.SelectItemTypeConstant,
-						Value: parsers.Constant{Type: parsers.ConstantTypeParameterConstant, Value: "@param_id"},
-					},
+					Right:     testutils.SelectItem_Constant_Parameter("@param_id"),
 				},
 				Parameters: map[string]interface{}{
 					"@param_id": "456",
@@ -83,18 +78,12 @@ func Test_Execute_Where(t *testing.T) {
 						parsers.ComparisonExpression{
 							Operation: "=",
 							Left:      parsers.SelectItem{Path: []string{"c", "id"}},
-							Right: parsers.SelectItem{
-								Type:  parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{Type: parsers.ConstantTypeString, Value: "67890"},
-							},
+							Right:     testutils.SelectItem_Constant_String("67890"),
 						},
 						parsers.ComparisonExpression{
 							Operation: "=",
 							Left:      parsers.SelectItem{Path: []string{"c", "pk"}},
-							Right: parsers.SelectItem{
-								Type:  parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{Type: parsers.ConstantTypeInteger, Value: 456},
-							},
+							Right:     testutils.SelectItem_Constant_Int(456),
 						},
 					},
 				},
@@ -120,10 +109,7 @@ func Test_Execute_Where(t *testing.T) {
 						parsers.ComparisonExpression{
 							Operation: "=",
 							Left:      parsers.SelectItem{Path: []string{"c", "isCool"}},
-							Right: parsers.SelectItem{
-								Type:  parsers.SelectItemTypeConstant,
-								Value: parsers.Constant{Type: parsers.ConstantTypeBoolean, Value: true},
-							},
+							Right:     testutils.SelectItem_Constant_Bool(true),
 						},
 						parsers.LogicalExpression{
 							Operation: parsers.LogicalExpressionTypeOr,
@@ -131,18 +117,12 @@ func Test_Execute_Where(t *testing.T) {
 								parsers.ComparisonExpression{
 									Operation: "=",
 									Left:      parsers.SelectItem{Path: []string{"c", "id"}},
-									Right: parsers.SelectItem{
-										Type:  parsers.SelectItemTypeConstant,
-										Value: parsers.Constant{Type: parsers.ConstantTypeString, Value: "123"},
-									},
+									Right:     testutils.SelectItem_Constant_String("123"),
 								},
 								parsers.ComparisonExpression{
 									Operation: "=",
 									Left:      parsers.SelectItem{Path: []string{"c", "id"}},
-									Right: parsers.SelectItem{
-										Type:  parsers.SelectItemTypeConstant,
-										Value: parsers.Constant{Type: parsers.ConstantTypeString, Value: "456"},
-									},
+									Right:     testutils.SelectItem_Constant_String("456"),
 								},
 							},
 						},

sharedlibrary/collections.go

@@ -0,0 +1,95 @@
+package main
+
+import "C"
+import (
+	"encoding/json"
+
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+)
+
+//export CreateCollection
+func CreateCollection(serverName *C.char, databaseId *C.char, collectionJson *C.char) int {
+	serverNameStr := C.GoString(serverName)
+	databaseIdStr := C.GoString(databaseId)
+	collectionStr := C.GoString(collectionJson)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return ResponseServerInstanceNotFound
+	}
+
+	var collection repositorymodels.Collection
+	err := json.Unmarshal([]byte(collectionStr), &collection)
+	if err != nil {
+		return ResponseFailedToParseRequest
+	}
+
+	_, code := serverInstance.repository.CreateCollection(databaseIdStr, collection)
+
+	return repositoryStatusToResponseCode(code)
+}
+
+//export GetCollection
+func GetCollection(serverName *C.char, databaseId *C.char, collectionId *C.char) *C.char {
+	serverNameStr := C.GoString(serverName)
+	databaseIdStr := C.GoString(databaseId)
+	collectionIdStr := C.GoString(collectionId)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return C.CString("")
+	}
+
+	collection, code := serverInstance.repository.GetCollection(databaseIdStr, collectionIdStr)
+	if code != repositorymodels.StatusOk {
+		return C.CString("")
+	}
+
+	collectionJson, err := json.Marshal(collection)
+	if err != nil {
+		return C.CString("")
+	}
+	return C.CString(string(collectionJson))
+}
+
+//export GetAllCollections
+func GetAllCollections(serverName *C.char, databaseId *C.char) *C.char {
+	serverNameStr := C.GoString(serverName)
+	databaseIdStr := C.GoString(databaseId)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return C.CString("")
+	}
+
+	collections, code := serverInstance.repository.GetAllCollections(databaseIdStr)
+	if code != repositorymodels.StatusOk {
+		return C.CString("")
+	}
+
+	collectionsJson, err := json.Marshal(collections)
+	if err != nil {
+		return C.CString("")
+	}
+	return C.CString(string(collectionsJson))
+}
+
+//export DeleteCollection
+func DeleteCollection(serverName *C.char, databaseId *C.char, collectionId *C.char) int {
+	serverNameStr := C.GoString(serverName)
+	databaseIdStr := C.GoString(databaseId)
+	collectionIdStr := C.GoString(collectionId)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return ResponseServerInstanceNotFound
+	}
+
+	code := serverInstance.repository.DeleteCollection(databaseIdStr, collectionIdStr)
+
+	return repositoryStatusToResponseCode(code)
+}

sharedlibrary/databases.go

@@ -0,0 +1,92 @@
+package main
+
+import "C"
+import (
+	"encoding/json"
+
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+)
+
+//export CreateDatabase
+func CreateDatabase(serverName *C.char, databaseJson *C.char) int {
+	serverNameStr := C.GoString(serverName)
+	databaseStr := C.GoString(databaseJson)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return ResponseServerInstanceNotFound
+	}
+
+	var database repositorymodels.Database
+	err := json.Unmarshal([]byte(databaseStr), &database)
+	if err != nil {
+		return ResponseFailedToParseRequest
+	}
+
+	_, code := serverInstance.repository.CreateDatabase(database)
+
+	return repositoryStatusToResponseCode(code)
+}
+
+//export GetDatabase
+func GetDatabase(serverName *C.char, databaseId *C.char) *C.char {
+	serverNameStr := C.GoString(serverName)
+	databaseIdStr := C.GoString(databaseId)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return C.CString("")
+	}
+
+	database, code := serverInstance.repository.GetDatabase(databaseIdStr)
+	if code != repositorymodels.StatusOk {
+		return C.CString("")
+	}
+
+	databaseJson, err := json.Marshal(database)
+	if err != nil {
+		return C.CString("")
+	}
+	return C.CString(string(databaseJson))
+}
+
+//export GetAllDatabases
+func GetAllDatabases(serverName *C.char) *C.char {
+	serverNameStr := C.GoString(serverName)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return C.CString("")
+	}
+
+	databases, code := serverInstance.repository.GetAllDatabases()
+	if code != repositorymodels.StatusOk {
+		return C.CString("")
+	}
+
+	databasesJson, err := json.Marshal(databases)
+	if err != nil {
+		return C.CString("")
+	}
+
+	return C.CString(string(databasesJson))
+}
+
+//export DeleteDatabase
+func DeleteDatabase(serverName *C.char, databaseId *C.char) int {
+	serverNameStr := C.GoString(serverName)
+	databaseIdStr := C.GoString(databaseId)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return ResponseServerInstanceNotFound
+	}
+
+	code := serverInstance.repository.DeleteDatabase(databaseIdStr)
+
+	return repositoryStatusToResponseCode(code)
+}

sharedlibrary/documents.go

@@ -0,0 +1,128 @@
+package main
+
+import "C"
+import (
+	"encoding/json"
+
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+)
+
+//export CreateDocument
+func CreateDocument(serverName *C.char, databaseId *C.char, collectionId *C.char, documentJson *C.char) int {
+	serverNameStr := C.GoString(serverName)
+	databaseIdStr := C.GoString(databaseId)
+	collectionIdStr := C.GoString(collectionId)
+	documentStr := C.GoString(documentJson)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return ResponseServerInstanceNotFound
+	}
+
+	var document repositorymodels.Document
+	err := json.Unmarshal([]byte(documentStr), &document)
+	if err != nil {
+		return ResponseFailedToParseRequest
+	}
+
+	_, code := serverInstance.repository.CreateDocument(databaseIdStr, collectionIdStr, document)
+
+	return repositoryStatusToResponseCode(code)
+}
+
+//export GetDocument
+func GetDocument(serverName *C.char, databaseId *C.char, collectionId *C.char, documentId *C.char) *C.char {
+	serverNameStr := C.GoString(serverName)
+	databaseIdStr := C.GoString(databaseId)
+	collectionIdStr := C.GoString(collectionId)
+	documentIdStr := C.GoString(documentId)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return C.CString("")
+	}
+
+	document, code := serverInstance.repository.GetDocument(databaseIdStr, collectionIdStr, documentIdStr)
+	if code != repositorymodels.StatusOk {
+		return C.CString("")
+	}
+
+	documentJson, err := json.Marshal(document)
+	if err != nil {
+		return C.CString("")
+	}
+	return C.CString(string(documentJson))
+}
+
+//export GetAllDocuments
+func GetAllDocuments(serverName *C.char, databaseId *C.char, collectionId *C.char) *C.char {
+	serverNameStr := C.GoString(serverName)
+	databaseIdStr := C.GoString(databaseId)
+	collectionIdStr := C.GoString(collectionId)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return C.CString("")
+	}
+
+	documents, code := serverInstance.repository.GetAllDocuments(databaseIdStr, collectionIdStr)
+	if code != repositorymodels.StatusOk {
+		return C.CString("")
+	}
+
+	documentsJson, err := json.Marshal(documents)
+	if err != nil {
+		return C.CString("")
+	}
+	return C.CString(string(documentsJson))
+}
+
+//export UpdateDocument
+func UpdateDocument(serverName *C.char, databaseId *C.char, collectionId *C.char, documentId *C.char, documentJson *C.char) int {
+	serverNameStr := C.GoString(serverName)
+	databaseIdStr := C.GoString(databaseId)
+	collectionIdStr := C.GoString(collectionId)
+	documentIdStr := C.GoString(documentId)
+	documentStr := C.GoString(documentJson)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return ResponseServerInstanceNotFound
+	}
+
+	var document repositorymodels.Document
+	err := json.Unmarshal([]byte(documentStr), &document)
+	if err != nil {
+		return ResponseFailedToParseRequest
+	}
+
+	code := serverInstance.repository.DeleteDocument(databaseIdStr, collectionIdStr, documentIdStr)
+	if code != repositorymodels.StatusOk {
+		return repositoryStatusToResponseCode(code)
+	}
+
+	_, code = serverInstance.repository.CreateDocument(databaseIdStr, collectionIdStr, document)
+	return repositoryStatusToResponseCode(code)
+}
+
+//export DeleteDocument
+func DeleteDocument(serverName *C.char, databaseId *C.char, collectionId *C.char, documentId *C.char) int {
+	serverNameStr := C.GoString(serverName)
+	databaseIdStr := C.GoString(databaseId)
+	collectionIdStr := C.GoString(collectionId)
+	documentIdStr := C.GoString(documentId)
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = getInstance(serverNameStr); !ok {
+		return ResponseServerInstanceNotFound
+	}
+
+	code := serverInstance.repository.DeleteDocument(databaseIdStr, collectionIdStr, documentIdStr)
+
+	return repositoryStatusToResponseCode(code)
+}

sharedlibrary/shared.go

@@ -0,0 +1,86 @@
+package main
+
+import (
+	"sync"
+
+	"github.com/pikami/cosmium/api"
+	"github.com/pikami/cosmium/internal/repositories"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+)
+
+type ServerInstance struct {
+	server     *api.ApiServer
+	repository *repositories.DataRepository
+}
+
+var serverInstances map[string]*ServerInstance
+var mutex sync.Mutex
+
+const (
+	ResponseSuccess = 0
+
+	ResponseUnknown                     = 100
+	ResponseFailedToParseConfiguration  = 101
+	ResponseFailedToLoadState           = 102
+	ResponseFailedToParseRequest        = 103
+	ResponseServerInstanceAlreadyExists = 104
+	ResponseServerInstanceNotFound      = 105
+
+	ResponseRepositoryNotFound   = 200
+	ResponseRepositoryConflict   = 201
+	ResponseRepositoryBadRequest = 202
+)
+
+func getInstance(serverName string) (*ServerInstance, bool) {
+	mutex.Lock()
+	defer mutex.Unlock()
+
+	if serverInstances == nil {
+		serverInstances = make(map[string]*ServerInstance)
+	}
+
+	var ok bool
+	var serverInstance *ServerInstance
+	if serverInstance, ok = serverInstances[serverName]; !ok {
+		return nil, false
+	}
+
+	return serverInstance, true
+}
+
+func addInstance(serverName string, serverInstance *ServerInstance) {
+	mutex.Lock()
+	defer mutex.Unlock()
+
+	if serverInstances == nil {
+		serverInstances = make(map[string]*ServerInstance)
+	}
+
+	serverInstances[serverName] = serverInstance
+}
+
+func removeInstance(serverName string) {
+	mutex.Lock()
+	defer mutex.Unlock()
+
+	if serverInstances == nil {
+		return
+	}
+
+	delete(serverInstances, serverName)
+}
+
+func repositoryStatusToResponseCode(status repositorymodels.RepositoryStatus) int {
+	switch status {
+	case repositorymodels.StatusOk:
+		return ResponseSuccess
+	case repositorymodels.StatusNotFound:
+		return ResponseRepositoryNotFound
+	case repositorymodels.Conflict:
+		return ResponseRepositoryConflict
+	case repositorymodels.BadRequest:
+		return ResponseRepositoryBadRequest
+	default:
+		return ResponseUnknown
+	}
+}

sharedlibrary/sharedlibrary.go

@@ -9,31 +9,12 @@ import (
 	"github.com/pikami/cosmium/internal/repositories"
 )
 
-type ServerInstance struct {
-	server     *api.ApiServer
-	repository *repositories.DataRepository
-}
-
-var serverInstances map[string]*ServerInstance
-
-const (
-	ResponseSuccess                     = 0
-	ResponseUnknown                     = 1
-	ResponseServerInstanceAlreadyExists = 2
-	ResponseFailedToParseConfiguration  = 3
-	ResponseServerInstanceNotFound      = 4
-)
-
 //export CreateServerInstance
 func CreateServerInstance(serverName *C.char, configurationJSON *C.char) int {
 	configStr := C.GoString(configurationJSON)
 	serverNameStr := C.GoString(serverName)
 
-	if serverInstances == nil {
-		serverInstances = make(map[string]*ServerInstance)
-	}
-
-	if _, ok := serverInstances[serverNameStr]; ok {
+	if _, ok := getInstance(serverNameStr); ok {
 		return ResponseServerInstanceAlreadyExists
 	}
 
@@ -44,6 +25,7 @@ func CreateServerInstance(serverName *C.char, configurationJSON *C.char) int {
 	}
 
 	configuration.PopulateCalculatedFields()
+	configuration.ApplyDefaultsToEmptyFields()
 
 	repository := repositories.NewDataRepository(repositories.RepositoryOptions{
 		InitialDataFilePath: configuration.InitialDataFilePath,
@@ -53,19 +35,21 @@ func CreateServerInstance(serverName *C.char, configurationJSON *C.char) int {
 	server := api.NewApiServer(repository, configuration)
 	server.Start()
 
-	serverInstances[serverNameStr] = &ServerInstance{
+	addInstance(serverNameStr, &ServerInstance{
 		server:     server,
 		repository: repository,
-	}
+	})
 
 	return ResponseSuccess
 }
 
 //export StopServerInstance
 func StopServerInstance(serverName *C.char) int {
-	if serverInstance, ok := serverInstances[C.GoString(serverName)]; ok {
+	serverNameStr := C.GoString(serverName)
+
+	if serverInstance, ok := getInstance(serverNameStr); ok {
 		serverInstance.server.Stop()
-		delete(serverInstances, C.GoString(serverName))
+		removeInstance(serverNameStr)
 		return ResponseSuccess
 	}
 
@@ -74,7 +58,9 @@ func StopServerInstance(serverName *C.char) int {
 
 //export GetServerInstanceState
 func GetServerInstanceState(serverName *C.char) *C.char {
-	if serverInstance, ok := serverInstances[C.GoString(serverName)]; ok {
+	serverNameStr := C.GoString(serverName)
+
+	if serverInstance, ok := getInstance(serverNameStr); ok {
 		stateJSON, err := serverInstance.repository.GetState()
 		if err != nil {
 			return nil
@@ -85,4 +71,20 @@ func GetServerInstanceState(serverName *C.char) *C.char {
 	return nil
 }
 
+//export LoadServerInstanceState
+func LoadServerInstanceState(serverName *C.char, stateJSON *C.char) int {
+	serverNameStr := C.GoString(serverName)
+	stateJSONStr := C.GoString(stateJSON)
+
+	if serverInstance, ok := getInstance(serverNameStr); ok {
+		err := serverInstance.repository.LoadStateJSON(stateJSONStr)
+		if err != nil {
+			return ResponseFailedToLoadState
+		}
+		return ResponseSuccess
+	}
+
+	return ResponseServerInstanceNotFound
+}
+
 func main() {}

sharedlibrary/tests/main.c

@@ -0,0 +1,46 @@
+#include "shared.h"
+
+int test_CreateServerInstance();
+int test_StopServerInstance();
+int test_ServerInstanceStateMethods();
+int test_Databases();
+
+int main(int argc, char *argv[])
+{
+    if (argc < 2)
+    {
+        fprintf(stderr, "Usage: %s <path_to_shared_library>\n", argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    const char *libPath = argv[1];
+    handle = dlopen(libPath, RTLD_LAZY);
+    if (!handle)
+    {
+        fprintf(stderr, "Failed to load shared library: %s\n", dlerror());
+        return EXIT_FAILURE;
+    }
+
+    printf("Running tests for library: %s\n", libPath);
+    int results[] = {
+        test_CreateServerInstance(),
+        test_Databases(),
+        test_ServerInstanceStateMethods(),
+        test_StopServerInstance(),
+    };
+
+    int numTests = sizeof(results) / sizeof(results[0]);
+    int numPassed = 0;
+    for (int i = 0; i < numTests; i++)
+    {
+        if (results[i])
+        {
+            numPassed++;
+        }
+    }
+
+    printf("Tests passed: %d/%d\n", numPassed, numTests);
+
+    dlclose(handle);
+    return EXIT_SUCCESS;
+}

sharedlibrary/tests/shared.c

@@ -0,0 +1,36 @@
+#include "shared.h"
+
+void *handle = NULL;
+
+void *load_function(const char *func_name)
+{
+    void *func = dlsym(handle, func_name);
+    if (!func)
+    {
+        fprintf(stderr, "Failed to load function %s: %s\n", func_name, dlerror());
+    }
+    return func;
+}
+
+char *compact_json(const char *json)
+{
+    size_t len = strlen(json);
+    char *compact = (char *)malloc(len + 1);
+    if (!compact)
+    {
+        fprintf(stderr, "Failed to allocate memory for compacted JSON\n");
+        return NULL;
+    }
+
+    char *dest = compact;
+    for (const char *src = json; *src != '\0'; ++src)
+    {
+        if (!isspace((unsigned char)*src)) // Skip spaces, newlines, tabs, etc.
+        {
+            *dest++ = *src;
+        }
+    }
+    *dest = '\0'; // Null-terminate the string
+
+    return compact;
+}

sharedlibrary/tests/shared.h

@@ -0,0 +1,15 @@
+#ifndef SHARED_H
+#define SHARED_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <string.h>
+#include <ctype.h>
+
+extern void *handle;
+
+void *load_function(const char *func_name);
+char *compact_json(const char *json);
+
+#endif

sharedlibrary/tests/test_create.c

@@ -0,0 +1,29 @@
+#include "shared.h"
+
+int test_CreateServerInstance()
+{
+    typedef int (*CreateServerInstanceFn)(char *, char *);
+    CreateServerInstanceFn CreateServerInstance = (CreateServerInstanceFn)load_function("CreateServerInstance");
+
+    if (!CreateServerInstance)
+    {
+        fprintf(stderr, "Failed to find CreateServerInstance function\n");
+        return 0;
+    }
+
+    char *serverName = "TestServer";
+    char *configJSON = "{\"host\":\"localhost\",\"port\":8080}";
+
+    int result = CreateServerInstance(serverName, configJSON);
+    if (result == 0)
+    {
+        printf("CreateServerInstance: SUCCESS\n");
+    }
+    else
+    {
+        printf("CreateServerInstance: FAILED (result = %d)\n", result);
+        return 0;
+    }
+
+    return 1;
+}

sharedlibrary/tests/test_databases.c

@@ -0,0 +1,47 @@
+#include "shared.h"
+
+int test_Databases()
+{
+    typedef int (*CreateDatabaseFn)(char *, char *);
+    CreateDatabaseFn CreateDatabase = (CreateDatabaseFn)load_function("CreateDatabase");
+    if (!CreateDatabase)
+    {
+        fprintf(stderr, "Failed to find CreateDatabase function\n");
+        return 0;
+    }
+
+    char *serverName = "TestServer";
+    char *configJSON = "{\"id\":\"test-db\"}";
+
+    int result = CreateDatabase(serverName, configJSON);
+    if (result == 0)
+    {
+        printf("CreateDatabase: SUCCESS\n");
+    }
+    else
+    {
+        printf("CreateDatabase: FAILED (result = %d)\n", result);
+        return 0;
+    }
+
+    typedef char *(*GetDatabaseFn)(char *, char *);
+    GetDatabaseFn GetDatabase = (GetDatabaseFn)load_function("GetDatabase");
+    if (!GetDatabase)
+    {
+        fprintf(stderr, "Failed to find GetDatabase function\n");
+        return 0;
+    }
+
+    char *database = GetDatabase(serverName, "test-db");
+    if (database)
+    {
+        printf("GetDatabase: SUCCESS (database = %s)\n", database);
+    }
+    else
+    {
+        printf("GetDatabase: FAILED\n");
+        return 0;
+    }
+
+    return 1;
+}

sharedlibrary/tests/test_instance_state.c

@@ -0,0 +1,68 @@
+#include "shared.h"
+
+int test_ServerInstanceStateMethods()
+{
+    typedef int (*LoadServerInstanceStateFn)(char *, char *);
+    LoadServerInstanceStateFn LoadServerInstanceState = (LoadServerInstanceStateFn)load_function("LoadServerInstanceState");
+    if (!LoadServerInstanceState)
+    {
+        fprintf(stderr, "Failed to find LoadServerInstanceState function\n");
+        return 0;
+    }
+
+    char *serverName = "TestServer";
+    char *stateJSON = "{\"databases\":{\"test-db\":{\"id\":\"test-db\"}}}";
+    int result = LoadServerInstanceState(serverName, stateJSON);
+    if (result == 0)
+    {
+        printf("LoadServerInstanceState: SUCCESS\n");
+    }
+    else
+    {
+        printf("LoadServerInstanceState: FAILED (result = %d)\n", result);
+        return 0;
+    }
+
+    typedef char *(*GetServerInstanceStateFn)(char *);
+    GetServerInstanceStateFn GetServerInstanceState = (GetServerInstanceStateFn)load_function("GetServerInstanceState");
+    if (!GetServerInstanceState)
+    {
+        fprintf(stderr, "Failed to find GetServerInstanceState function\n");
+        return 0;
+    }
+
+    char *state = GetServerInstanceState(serverName);
+    if (state)
+    {
+        printf("GetServerInstanceState: SUCCESS (state = %s)\n", state);
+    }
+    else
+    {
+        printf("GetServerInstanceState: FAILED\n");
+        return 0;
+    }
+
+    const char *expected_state = "{\"databases\":{\"test-db\":{\"id\":\"test-db\",\"_ts\":0,\"_rid\":\"\",\"_etag\":\"\",\"_self\":\"\"}},\"collections\":{\"test-db\":{}},\"documents\":{\"test-db\":{}},\"triggers\":{\"test-db\":{}},\"sprocs\":{\"test-db\":{}},\"udfs\":{\"test-db\":{}}}";
+    char *compact_state = compact_json(state);
+    if (!compact_state)
+    {
+        free(state);
+        return 0;
+    }
+
+    if (strcmp(compact_state, expected_state) == 0)
+    {
+        printf("GetServerInstanceState: State matches expected value.\n");
+    }
+    else
+    {
+        printf("GetServerInstanceState: State does not match expected value.\n");
+        printf("Expected: %s\n", expected_state);
+        printf("Actual:   %s\n", compact_state);
+        return 0;
+    }
+
+    free(state);
+    free(compact_state);
+    return 1;
+}

sharedlibrary/tests/test_stop.c

@@ -0,0 +1,27 @@
+#include "shared.h"
+
+int test_StopServerInstance()
+{
+    typedef int (*StopServerInstanceFn)(char *);
+    StopServerInstanceFn StopServerInstance = (StopServerInstanceFn)load_function("StopServerInstance");
+
+    if (!StopServerInstance)
+    {
+        fprintf(stderr, "Failed to find StopServerInstance function\n");
+        return 0;
+    }
+
+    char *serverName = "TestServer";
+    int result = StopServerInstance(serverName);
+    if (result == 0)
+    {
+        printf("StopServerInstance: SUCCESS\n");
+    }
+    else
+    {
+        printf("StopServerInstance: FAILED (result = %d)\n", result);
+        return 0;
+    }
+
+    return 1;
+}

test_utils/parser_model_gen.go

@@ -0,0 +1,53 @@
+package testutils
+
+import "github.com/pikami/cosmium/parsers"
+
+func SelectItem_Constant_String(value string) parsers.SelectItem {
+	return parsers.SelectItem{
+		Type: parsers.SelectItemTypeConstant,
+		Value: parsers.Constant{
+			Type:  parsers.ConstantTypeString,
+			Value: value,
+		},
+	}
+}
+
+func SelectItem_Constant_Int(value int) parsers.SelectItem {
+	return parsers.SelectItem{
+		Type: parsers.SelectItemTypeConstant,
+		Value: parsers.Constant{
+			Type:  parsers.ConstantTypeInteger,
+			Value: value,
+		},
+	}
+}
+
+func SelectItem_Constant_Float(value float64) parsers.SelectItem {
+	return parsers.SelectItem{
+		Type: parsers.SelectItemTypeConstant,
+		Value: parsers.Constant{
+			Type:  parsers.ConstantTypeFloat,
+			Value: value,
+		},
+	}
+}
+
+func SelectItem_Constant_Bool(value bool) parsers.SelectItem {
+	return parsers.SelectItem{
+		Type: parsers.SelectItemTypeConstant,
+		Value: parsers.Constant{
+			Type:  parsers.ConstantTypeBoolean,
+			Value: value,
+		},
+	}
+}
+
+func SelectItem_Constant_Parameter(name string) parsers.SelectItem {
+	return parsers.SelectItem{
+		Type: parsers.SelectItemTypeConstant,
+		Value: parsers.Constant{
+			Type:  parsers.ConstantTypeParameterConstant,
+			Value: name,
+		},
+	}
+}