Fix cosmos explorer incorrect redirect

* check isUpsert header in POST document request

* Verify response code on "CreateItem that already exists" test

---------

Co-authored-by: Pijus Kamandulis <pikami@users.noreply.github.com>

.github/workflows/release.yml

@@ -7,6 +7,7 @@ on:
 
 permissions:
   contents: write
+  packages: write
 
 jobs:
   goreleaser:
@@ -20,6 +21,12 @@ jobs:
         uses: actions/setup-go@v5
         with:
           go-version: 1.21.6
+      - 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,2 +1,6 @@
 dist/
 ignored/
+explorer_www/
+main
+save.json
+.vscode/

.goreleaser.yaml

@@ -31,5 +31,22 @@ brews:
       name: pikami
       email: git@pikami.org
 
+dockers:
+  - image_templates:
+    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}"
+    - "ghcr.io/pikami/{{ .ProjectName }}:latest"
+    dockerfile: Dockerfile
+    use: docker
+    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}}"
+
 checksum:
   name_template: 'checksums.txt'

Dockerfile

@@ -0,0 +1,6 @@
+FROM scratch
+
+WORKDIR /app
+COPY cosmium /app/cosmium
+
+ENTRYPOINT ["/app/cosmium"]

README.md

@@ -1,11 +1,13 @@
 # Cosmium
 
-Cosmium is a lightweight Cosmos DB emulator designed to facilitate local development and testing. While it aims to provide developers with a solution for running a local database during development, it's important to note that it's not 100% compatible with Cosmos DB. However, it serves as a convenient tool for E2E or integration tests during the CI/CD pipeline. Read more about compatibility [here](docs/compatibility.md).
+Cosmium is a lightweight Cosmos DB emulator designed to facilitate local development and testing. While it aims to provide developers with a solution for running a local database during development, it's important to note that it's not 100% compatible with Cosmos DB. However, it serves as a convenient tool for E2E or integration tests during the CI/CD pipeline. Read more about compatibility [here](./docs/COMPATIBILITY.md).
 
 One of Cosmium's notable features is its ability to save and load state to a single JSON file. This feature makes it easy to load different test cases or share state with other developers, enhancing collaboration and efficiency in development workflows.
 
 # Getting Started
+
 ### Installation via Homebrew
+
 You can install Cosmium using Homebrew by adding the `pikami/brew` tap and then installing the package.
 
 ```sh
@@ -23,10 +25,10 @@ You can download the latest version of Cosmium from the [GitHub Releases page](h
 
 Cosmium is available for the following platforms:
 
-* **Linux**: cosmium-linux-amd64
+- **Linux**: cosmium-linux-amd64
-* **macOS**: cosmium-darwin-amd64
+- **macOS**: cosmium-darwin-amd64
-* **macOS on Apple Silicon**: cosmium-darwin-arm64
+- **macOS on Apple Silicon**: cosmium-darwin-arm64
-* **Windows**: cosmium-windows-amd64.exe
+- **Windows**: cosmium-windows-amd64.exe
 
 ### Running Cosmium
 
@@ -37,16 +39,29 @@ cosmium -Persist "./save.json"
 ```
 
 Connection String Example:
+
 ```
 AccountEndpoint=https://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==;
 ```
 
-###  Running Cosmos DB Explorer
+### Running Cosmos DB Explorer
 
 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.
 
 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)
+
+If you wan to run the application using docker, configure it using environment variables see example:
+
+```sh
+docker run --rm \
+  -e COSMIUM_PERSIST=/save.json \
+  -v ./save.json:/save.json \
+  -p 8081:8081 \
+  ghcr.io/pikami/cosmium
+```
+
 ### SSL Certificate
 
 By default, Cosmium uses a pre-generated SSL certificate. You can provide your own certificates by specifying paths to the SSL certificate and key (PEM format) using the `-Cert` and `-CertKey` arguments, respectively.
@@ -55,15 +70,26 @@ To disable SSL and run Cosmium on HTTP instead, you can use the `-DisableTls` fl
 
 ### Other Available Arguments
 
-* **-AccountKey**: Account key for authentication (default "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==")
+- **-AccountKey**: Account key for authentication (default "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==")
-* **-DisableAuth**: Disable authentication
+- **-DisableAuth**: Disable authentication
-* **-Host**: Hostname (default "localhost")
+- **-Host**: Hostname (default "localhost")
-* **-InitialData**: Path to JSON containing initial state
+- **-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`)
+- **-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)
+- **-Port**: Listen port (default 8081)
-* **-Debug**: Runs application in debug mode, this provides additional logging
+- **-Debug**: Runs application in debug mode, this provides additional logging
 
 These arguments allow you to configure various aspects of Cosmium's behavior according to your requirements.
 
+All mentioned arguments can also be set using environment variables:
+
+- **COSMIUM_ACCOUNTKEY** for `-AccountKey`
+- **COSMIUM_DISABLEAUTH** for `-DisableAuth`
+- **COSMIUM_HOST** for `-Host`
+- **COSMIUM_INITIALDATA** for `-InitialData`
+- **COSMIUM_PERSIST** for `-Persist`
+- **COSMIUM_PORT** for `-Port`
+- **COSMIUM_DEBUG** for `-Debug`
+
 # License
+
 This project is [MIT licensed](./LICENSE).

api/config/config.go

@@ -3,10 +3,14 @@ package config
 import (
 	"flag"
 	"fmt"
+	"os"
+	"strings"
 )
 
 const (
-	DefaultAccountKey = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
+	DefaultAccountKey       = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
+	EnvPrefix               = "COSMIUM_"
+	ExplorerBaseUrlLocation = "/_explorer"
 )
 
 var Config = ServerConfig{}
@@ -25,6 +29,7 @@ func ParseFlags() {
 	debug := flag.Bool("Debug", false, "Runs application in debug mode, this provides additional logging")
 
 	flag.Parse()
+	setFlagsFromEnvironment()
 
 	Config.Host = *host
 	Config.Port = *port
@@ -41,4 +46,19 @@ func ParseFlags() {
 	Config.DatabaseDomain = Config.Host
 	Config.DatabaseEndpoint = fmt.Sprintf("https://%s:%d/", Config.Host, Config.Port)
 	Config.AccountKey = *accountKey
+	Config.ExplorerBaseUrlLocation = ExplorerBaseUrlLocation
+}
+
+func setFlagsFromEnvironment() (err error) {
+	flag.VisitAll(func(f *flag.Flag) {
+		name := EnvPrefix + strings.ToUpper(strings.Replace(f.Name, "-", "_", -1))
+		if value, ok := os.LookupEnv(name); ok {
+			err2 := flag.Set(f.Name, value)
+			if err2 != nil {
+				err = fmt.Errorf("failed setting flag from environment: %w", err2)
+			}
+		}
+	})
+
+	return
 }

api/config/models.go

@@ -6,14 +6,15 @@ type ServerConfig struct {
 	DatabaseEndpoint string
 	AccountKey       string
 
-	ExplorerPath        string
+	ExplorerPath            string
-	Port                int
+	Port                    int
-	Host                string
+	Host                    string
-	TLS_CertificatePath string
+	TLS_CertificatePath     string
-	TLS_CertificateKey  string
+	TLS_CertificateKey      string
-	InitialDataFilePath string
+	InitialDataFilePath     string
-	PersistDataFilePath string
+	PersistDataFilePath     string
-	DisableAuth         bool
+	DisableAuth             bool
-	DisableTls          bool
+	DisableTls              bool
-	Debug               bool
+	Debug                   bool
+	ExplorerBaseUrlLocation string
 }

api/handlers/collections.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"fmt"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -15,6 +16,7 @@ func GetAllCollections(c *gin.Context) {
 	if status == repositorymodels.StatusOk {
 		database, _ := repositories.GetDatabase(databaseId)
 
+		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(collections)))
 		c.IndentedJSON(http.StatusOK, gin.H{
 			"_rid":                database.ResourceID,
 			"DocumentCollections": collections,

api/handlers/databases.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"fmt"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -11,6 +12,7 @@ import (
 func GetAllDatabases(c *gin.Context) {
 	databases, status := repositories.GetAllDatabases()
 	if status == repositorymodels.StatusOk {
+		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(databases)))
 		c.IndentedJSON(http.StatusOK, gin.H{
 			"_rid":      "",
 			"Databases": databases,

api/handlers/documents.go

@@ -1,10 +1,15 @@
 package handlers
 
 import (
+	"encoding/json"
+	"fmt"
 	"net/http"
+	"strconv"
 
+	jsonpatch "github.com/evanphx/json-patch/v5"
 	"github.com/gin-gonic/gin"
 	"github.com/pikami/cosmium/internal/constants"
+	"github.com/pikami/cosmium/internal/logger"
 	"github.com/pikami/cosmium/internal/repositories"
 	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 )
@@ -17,6 +22,7 @@ func GetAllDocuments(c *gin.Context) {
 	if status == repositorymodels.StatusOk {
 		collection, _ := repositories.GetCollection(databaseId, collectionId)
 
+		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(documents)))
 		c.IndentedJSON(http.StatusOK, gin.H{
 			"_rid":      collection.ID,
 			"Documents": documents,
@@ -98,6 +104,82 @@ func ReplaceDocument(c *gin.Context) {
 	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
+func PatchDocument(c *gin.Context) {
+	databaseId := c.Param("databaseId")
+	collectionId := c.Param("collId")
+	documentId := c.Param("docId")
+
+	document, status := repositories.GetDocument(databaseId, collectionId, documentId)
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		return
+	}
+
+	var requestBody map[string]interface{}
+	if err := c.BindJSON(&requestBody); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
+		return
+	}
+
+	operations := requestBody["operations"]
+	operationsBytes, err := json.Marshal(operations)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"message": "Could not decode operations"})
+		return
+	}
+
+	patch, err := jsonpatch.DecodePatch(operationsBytes)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
+		return
+	}
+
+	currentDocumentBytes, err := json.Marshal(document)
+	if err != nil {
+		logger.Error("Failed to marshal existing document:", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Failed to marshal existing document"})
+		return
+	}
+
+	modifiedDocumentBytes, err := patch.Apply(currentDocumentBytes)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
+		return
+	}
+
+	var modifiedDocument map[string]interface{}
+	err = json.Unmarshal(modifiedDocumentBytes, &modifiedDocument)
+	if err != nil {
+		logger.Error("Failed to unmarshal modified document:", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Failed to unmarshal modified document"})
+		return
+	}
+
+	if modifiedDocument["id"] != document["id"] {
+		c.JSON(http.StatusUnprocessableEntity, gin.H{"message": "The ID field cannot be modified"})
+		return
+	}
+
+	status = repositories.DeleteDocument(databaseId, collectionId, documentId)
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		return
+	}
+
+	createdDocument, status := repositories.CreateDocument(databaseId, collectionId, modifiedDocument)
+	if status == repositorymodels.Conflict {
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		return
+	}
+
+	if status == repositorymodels.StatusOk {
+		c.IndentedJSON(http.StatusCreated, createdDocument)
+		return
+	}
+
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+}
+
 func DocumentsPost(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
@@ -128,6 +210,7 @@ func DocumentsPost(c *gin.Context) {
 		}
 
 		collection, _ := repositories.GetCollection(databaseId, collectionId)
+		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(docs)))
 		c.IndentedJSON(http.StatusOK, gin.H{
 			"_rid":      collection.ResourceID,
 			"Documents": docs,
@@ -141,6 +224,11 @@ func DocumentsPost(c *gin.Context) {
 		return
 	}
 
+	isUpsert, _ := strconv.ParseBool(c.GetHeader("x-ms-documentdb-is-upsert"))
+	if isUpsert {
+		repositories.DeleteDocument(databaseId, collectionId, requestBody["id"].(string))
+	}
+
 	createdDocument, status := repositories.CreateDocument(databaseId, collectionId, requestBody)
 	if status == repositorymodels.Conflict {
 		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})

api/handlers/explorer.go

@@ -8,7 +8,7 @@ import (
 )
 
 func RegisterExplorerHandlers(router *gin.Engine) {
-	explorer := router.Group("/_explorer")
+	explorer := router.Group(config.Config.ExplorerBaseUrlLocation)
 	{
 		explorer.Use(func(ctx *gin.Context) {
 			if ctx.Param("filepath") == "/config.json" {

api/handlers/middleware/authentication.go

@@ -14,35 +14,13 @@ func Authentication() gin.HandlerFunc {
 	return func(c *gin.Context) {
 		requestUrl := c.Request.URL.String()
 		if config.Config.DisableAuth ||
-			strings.HasPrefix(requestUrl, "/_explorer") ||
+			strings.HasPrefix(requestUrl, config.Config.ExplorerBaseUrlLocation) ||
 			strings.HasPrefix(requestUrl, "/cosmium") {
 			return
 		}
 
-		var resourceType string
+		resourceType := urlToResourceType(requestUrl)
-		parts := strings.Split(requestUrl, "/")
+		resourceId := requestToResourceId(c)
-		switch len(parts) {
-		case 2, 3:
-			resourceType = parts[1]
-		case 4, 5:
-			resourceType = parts[3]
-		case 6, 7:
-			resourceType = parts[5]
-		}
-
-		databaseId, _ := c.Params.Get("databaseId")
-		collId, _ := c.Params.Get("collId")
-		docId, _ := c.Params.Get("docId")
-		var resourceId string
-		if databaseId != "" {
-			resourceId += "dbs/" + databaseId
-		}
-		if collId != "" {
-			resourceId += "/colls/" + collId
-		}
-		if docId != "" {
-			resourceId += "/docs/" + docId
-		}
 
 		authHeader := c.Request.Header.Get("authorization")
 		date := c.Request.Header.Get("x-ms-date")
@@ -62,3 +40,43 @@ func Authentication() gin.HandlerFunc {
 		}
 	}
 }
+
+func urlToResourceType(requestUrl string) string {
+	var resourceType string
+	parts := strings.Split(requestUrl, "/")
+	switch len(parts) {
+	case 2, 3:
+		resourceType = parts[1]
+	case 4, 5:
+		resourceType = parts[3]
+	case 6, 7:
+		resourceType = parts[5]
+	}
+
+	return resourceType
+}
+
+func requestToResourceId(c *gin.Context) string {
+	databaseId, _ := c.Params.Get("databaseId")
+	collId, _ := c.Params.Get("collId")
+	docId, _ := c.Params.Get("docId")
+	resourceType := urlToResourceType(c.Request.URL.String())
+
+	var resourceId string
+	if databaseId != "" {
+		resourceId += "dbs/" + databaseId
+	}
+	if collId != "" {
+		resourceId += "/colls/" + collId
+	}
+	if docId != "" {
+		resourceId += "/docs/" + docId
+	}
+
+	isFeed := c.Request.Header.Get("A-Im") == "Incremental Feed"
+	if resourceType == "pkranges" && isFeed {
+		resourceId = collId
+	}
+
+	return resourceId
+}

api/handlers/middleware/strip_trailing_slashes.go

@@ -0,0 +1,21 @@
+package middleware
+
+import (
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/api/config"
+)
+
+func StripTrailingSlashes(r *gin.Engine) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		path := c.Request.URL.Path
+		if len(path) > 1 && path[len(path)-1] == '/' && !strings.Contains(path, config.Config.ExplorerBaseUrlLocation) {
+			c.Request.URL.Path = path[:len(path)-1]
+			r.HandleContext(c)
+			c.Abort()
+			return
+		}
+		c.Next()
+	}
+}

api/handlers/offers.go

@@ -7,6 +7,7 @@ import (
 )
 
 func GetOffers(c *gin.Context) {
+	c.Header("x-ms-item-count", "0")
 	c.IndentedJSON(http.StatusOK, gin.H{
 		"_rid":   "",
 		"_count": 0,

api/handlers/stored_procedures.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"fmt"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -15,6 +16,7 @@ func GetAllStoredProcedures(c *gin.Context) {
 	sps, status := repositories.GetAllStoredProcedures(databaseId, collectionId)
 
 	if status == repositorymodels.StatusOk {
+		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(sps)))
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "StoredProcedures": sps, "_count": len(sps)})
 		return
 	}

api/handlers/triggers.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"fmt"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -15,6 +16,7 @@ func GetAllTriggers(c *gin.Context) {
 	triggers, status := repositories.GetAllTriggers(databaseId, collectionId)
 
 	if status == repositorymodels.StatusOk {
+		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(triggers)))
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "Triggers": triggers, "_count": len(triggers)})
 		return
 	}

api/handlers/user_defined_functions.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"fmt"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -15,6 +16,7 @@ func GetAllUserDefinedFunctions(c *gin.Context) {
 	udfs, status := repositories.GetAllUserDefinedFunctions(databaseId, collectionId)
 
 	if status == repositorymodels.StatusOk {
+		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(udfs)))
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "UserDefinedFunctions": udfs, "_count": len(udfs)})
 		return
 	}

api/router.go

@@ -13,12 +13,15 @@ import (
 )
 
 func CreateRouter() *gin.Engine {
-	router := gin.Default()
+	router := gin.Default(func(e *gin.Engine) {
+		e.RedirectTrailingSlash = false
+	})
 
 	if config.Config.Debug {
 		router.Use(middleware.RequestLogger())
 	}
 
+	router.Use(middleware.StripTrailingSlashes(router))
 	router.Use(middleware.Authentication())
 
 	router.GET("/dbs/:databaseId/colls/:collId/pkranges", handlers.GetPartitionKeyRanges)
@@ -27,6 +30,7 @@ func CreateRouter() *gin.Engine {
 	router.GET("/dbs/:databaseId/colls/:collId/docs", handlers.GetAllDocuments)
 	router.GET("/dbs/:databaseId/colls/:collId/docs/:docId", handlers.GetDocument)
 	router.PUT("/dbs/:databaseId/colls/:collId/docs/:docId", handlers.ReplaceDocument)
+	router.PATCH("/dbs/:databaseId/colls/:collId/docs/:docId", handlers.PatchDocument)
 	router.DELETE("/dbs/:databaseId/colls/:collId/docs/:docId", handlers.DeleteDocument)
 
 	router.POST("/dbs/:databaseId/colls", handlers.CreateCollection)

api/tests/config_test.go

@@ -10,6 +10,7 @@ import (
 func runTestServer() *httptest.Server {
 	config.Config.AccountKey = config.DefaultAccountKey
 	config.Config.ExplorerPath = "/tmp/nothing"
+	config.Config.ExplorerBaseUrlLocation = config.ExplorerBaseUrlLocation
 
 	return httptest.NewServer(api.CreateRouter())
 }

api/tests/documents_test.go

@@ -3,10 +3,14 @@ package tests_test
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"net/http"
+	"net/http/httptest"
 	"reflect"
 	"testing"
 
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
 	"github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
 	"github.com/pikami/cosmium/api/config"
 	"github.com/pikami/cosmium/internal/repositories"
@@ -49,7 +53,7 @@ func testCosmosQuery(t *testing.T,
 	}
 }
 
-func Test_Documents(t *testing.T) {
+func documents_InitializeDb(t *testing.T) (*httptest.Server, *azcosmos.ContainerClient) {
 	repositories.CreateDatabase(repositorymodels.Database{ID: testDatabaseName})
 	repositories.CreateCollection(testDatabaseName, repositorymodels.Collection{
 		ID: testCollectionName,
@@ -61,11 +65,10 @@ func Test_Documents(t *testing.T) {
 			Paths: []string{"/pk"},
 		},
 	})
-	repositories.CreateDocument(testDatabaseName, testCollectionName, map[string]interface{}{"id": "12345", "pk": "123", "isCool": false})
+	repositories.CreateDocument(testDatabaseName, testCollectionName, map[string]interface{}{"id": "12345", "pk": "123", "isCool": false, "arr": []int{1, 2, 3}})
-	repositories.CreateDocument(testDatabaseName, testCollectionName, map[string]interface{}{"id": "67890", "pk": "456", "isCool": true})
+	repositories.CreateDocument(testDatabaseName, testCollectionName, map[string]interface{}{"id": "67890", "pk": "456", "isCool": true, "arr": []int{6, 7, 8}})
 
 	ts := runTestServer()
-	defer ts.Close()
 
 	client, err := azcosmos.NewClientFromConnectionString(
 		fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, config.Config.AccountKey),
@@ -76,6 +79,13 @@ func Test_Documents(t *testing.T) {
 	collectionClient, err := client.NewContainer(testDatabaseName, testCollectionName)
 	assert.Nil(t, err)
 
+	return ts, collectionClient
+}
+
+func Test_Documents(t *testing.T) {
+	ts, collectionClient := documents_InitializeDb(t)
+	defer ts.Close()
+
 	t.Run("Should query document", func(t *testing.T) {
 		testCosmosQuery(t, collectionClient,
 			"SELECT c.id, c[\"pk\"] FROM c ORDER BY c.id",
@@ -136,4 +146,166 @@ func Test_Documents(t *testing.T) {
 			},
 		)
 	})
+
+	t.Run("Should query array accessor", func(t *testing.T) {
+		testCosmosQuery(t, collectionClient,
+			`SELECT c.id,
+				c["arr"][0] AS arr0,
+				c["arr"][1] AS arr1,
+				c["arr"][2] AS arr2,
+				c["arr"][3] AS arr3
+			FROM c ORDER BY c.id`,
+			nil,
+			[]interface{}{
+				map[string]interface{}{"id": "12345", "arr0": 1.0, "arr1": 2.0, "arr2": 3.0, "arr3": nil},
+				map[string]interface{}{"id": "67890", "arr0": 6.0, "arr1": 7.0, "arr2": 8.0, "arr3": nil},
+			},
+		)
+	})
+}
+
+func Test_Documents_Patch(t *testing.T) {
+	ts, collectionClient := documents_InitializeDb(t)
+	defer ts.Close()
+
+	t.Run("Should PATCH document", func(t *testing.T) {
+		context := context.TODO()
+		expectedData := map[string]interface{}{"id": "67890", "pk": "456", "newField": "newValue"}
+
+		patch := azcosmos.PatchOperations{}
+		patch.AppendAdd("/newField", "newValue")
+		patch.AppendRemove("/isCool")
+
+		itemResponse, err := collectionClient.PatchItem(
+			context,
+			azcosmos.PartitionKey{},
+			"67890",
+			patch,
+			&azcosmos.ItemOptions{
+				EnableContentResponseOnWrite: false,
+			},
+		)
+		assert.Nil(t, err)
+
+		var itemResponseBody map[string]string
+		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"])
+	})
+
+	t.Run("Should not allow to PATCH document ID", func(t *testing.T) {
+		context := context.TODO()
+
+		patch := azcosmos.PatchOperations{}
+		patch.AppendReplace("/id", "newValue")
+
+		_, err := collectionClient.PatchItem(
+			context,
+			azcosmos.PartitionKey{},
+			"67890",
+			patch,
+			&azcosmos.ItemOptions{
+				EnableContentResponseOnWrite: false,
+			},
+		)
+		assert.NotNil(t, err)
+
+		var respErr *azcore.ResponseError
+		if errors.As(err, &respErr) {
+			assert.Equal(t, http.StatusUnprocessableEntity, respErr.StatusCode)
+		} else {
+			panic(err)
+		}
+	})
+
+	t.Run("CreateItem", func(t *testing.T) {
+		context := context.TODO()
+
+		item := map[string]interface{}{
+			"Id":       "6789011",
+			"pk":       "456",
+			"newField": "newValue2",
+		}
+		bytes, err := json.Marshal(item)
+		assert.Nil(t, err)
+
+		r, err2 := collectionClient.CreateItem(
+			context,
+			azcosmos.PartitionKey{},
+			bytes,
+			&azcosmos.ItemOptions{
+				EnableContentResponseOnWrite: false,
+			},
+		)
+		assert.NotNil(t, r)
+		assert.Nil(t, err2)
+	})
+
+	t.Run("CreateItem that already exists", func(t *testing.T) {
+		context := context.TODO()
+
+		item := map[string]interface{}{"id": "12345", "pk": "123", "isCool": false, "arr": []int{1, 2, 3}}
+		bytes, err := json.Marshal(item)
+		assert.Nil(t, err)
+
+		r, err := collectionClient.CreateItem(
+			context,
+			azcosmos.PartitionKey{},
+			bytes,
+			&azcosmos.ItemOptions{
+				EnableContentResponseOnWrite: false,
+			},
+		)
+		assert.NotNil(t, r)
+		assert.NotNil(t, err)
+
+		var respErr *azcore.ResponseError
+		if errors.As(err, &respErr) {
+			assert.Equal(t, http.StatusConflict, respErr.StatusCode)
+		} else {
+			panic(err)
+		}
+	})
+
+	t.Run("UpsertItem new", func(t *testing.T) {
+		context := context.TODO()
+
+		item := map[string]interface{}{"id": "123456", "pk": "1234", "isCool": false, "arr": []int{1, 2, 3}}
+		bytes, err := json.Marshal(item)
+		assert.Nil(t, err)
+
+		r, err2 := collectionClient.UpsertItem(
+			context,
+			azcosmos.PartitionKey{},
+			bytes,
+			&azcosmos.ItemOptions{
+				EnableContentResponseOnWrite: false,
+			},
+		)
+		assert.NotNil(t, r)
+		assert.Nil(t, err2)
+	})
+
+	t.Run("UpsertItem that already exists", func(t *testing.T) {
+		context := context.TODO()
+
+		item := map[string]interface{}{"id": "12345", "pk": "123", "isCool": false, "arr": []int{1, 2, 3, 4}}
+		bytes, err := json.Marshal(item)
+		assert.Nil(t, err)
+
+		r, err2 := collectionClient.UpsertItem(
+			context,
+			azcosmos.PartitionKey{},
+			bytes,
+			&azcosmos.ItemOptions{
+				EnableContentResponseOnWrite: false,
+			},
+		)
+		assert.NotNil(t, r)
+		assert.Nil(t, err2)
+	})
+
 }

api/tests/documents_trailingslash_test.go

@@ -0,0 +1,41 @@
+package tests_test
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"testing"
+	"time"
+
+	"github.com/pikami/cosmium/api/config"
+	"github.com/pikami/cosmium/internal/authentication"
+	"github.com/stretchr/testify/assert"
+)
+
+// Request document with trailing slash like python cosmosdb client does.
+func Test_Documents_Read_Trailing_Slash(t *testing.T) {
+	ts, _ := documents_InitializeDb(t)
+	defer ts.Close()
+
+	t.Run("Read doc with client that appends slash to path", func(t *testing.T) {
+		resourceIdTemplate := "dbs/%s/colls/%s/docs/%s"
+		path := fmt.Sprintf(resourceIdTemplate, testDatabaseName, testCollectionName, "12345")
+		testUrl := ts.URL + "/" + path + "/"
+		date := time.Now().Format(time.RFC1123)
+		signature := authentication.GenerateSignature("GET", "docs", path, date, config.Config.AccountKey)
+		httpClient := &http.Client{}
+		req, _ := http.NewRequest("GET", testUrl, nil)
+		req.Header.Add("x-ms-date", date)
+		req.Header.Add("authorization", "sig="+url.QueryEscape(signature))
+		res, err := httpClient.Do(req)
+
+		assert.Nil(t, err)
+
+		if res != nil {
+			defer res.Body.Close()
+			assert.Equal(t, http.StatusOK, res.StatusCode, "Expected HTTP status 200 OK")
+		} else {
+			t.FailNow()
+		}
+	})
+}

docs/COMPATIBILITY.md

@@ -15,8 +15,9 @@ Cosmium strives to support the core features of Cosmos DB, including:
 ## Compatibility Matrix
 
 ### Features
+
 | Feature                       | Implemented |
-|-------------------------------|-------------|
+| ----------------------------- | ----------- |
 | Subqueries                    | No          |
 | Joins                         | No          |
 | Computed properties           | No          |
@@ -29,8 +30,9 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | User-defined functions (UDFs) | No          |
 
 ### Clauses
+
 | Clause       | Implemented |
-|--------------|-------------|
+| ------------ | ----------- |
 | SELECT       | Yes         |
 | FROM         | Yes         |
 | WHERE        | Yes         |
@@ -39,8 +41,9 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | OFFSET LIMIT | Yes         |
 
 ### Keywords
+
 | Keyword  | Implemented |
-|----------|-------------|
+| -------- | ----------- |
 | BETWEEN  | No          |
 | DISTINCT | Yes         |
 | LIKE     | No          |
@@ -48,8 +51,9 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | TOP      | Yes         |
 
 ### Aggregate Functions
+
 | Function | Implemented |
-|----------|-------------|
+| -------- | ----------- |
 | AVG      | Yes         |
 | COUNT    | Yes         |
 | MAX      | Yes         |
@@ -57,8 +61,9 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | SUM      | Yes         |
 
 ### Array Functions
+
 | Function       | Implemented |
-|----------------|-------------|
+| -------------- | ----------- |
 | ARRAY_CONCAT   | Yes         |
 | ARRAY_CONTAINS | No          |
 | ARRAY_LENGTH   | Yes         |
@@ -69,13 +74,15 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | SetUnion       | Yes         |
 
 ### Conditional Functions
+
 | Function | Implemented |
-|----------|-------------|
+| -------- | ----------- |
 | IIF      | No          |
 
 ### Date and time Functions
+
 | Function                  | Implemented |
-|---------------------------|-------------|
+| ------------------------- | ----------- |
 | DateTimeAdd               | No          |
 | DateTimeBin               | No          |
 | DateTimeDiff              | No          |
@@ -93,53 +100,56 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | TimestampToDateTime       | No          |
 
 ### Item Functions
+
 | Function   | Implemented |
-|------------|-------------|
+| ---------- | ----------- |
 | DocumentId | No          |
 
 ### Mathematical Functions
+
 | Function         | Implemented |
-|------------------|-------------|
+| ---------------- | ----------- |
-| ABS              | No          |
+| ABS              | Yes         |
-| ACOS             | No          |
+| ACOS             | Yes         |
-| ASIN             | No          |
+| ASIN             | Yes         |
-| ATAN             | No          |
+| ATAN             | Yes         |
-| ATN2             | No          |
+| ATN2             | Yes         |
-| CEILING          | No          |
+| CEILING          | Yes         |
-| COS              | No          |
+| COS              | Yes         |
-| COT              | No          |
+| COT              | Yes         |
-| DEGREES          | No          |
+| DEGREES          | Yes         |
-| EXP              | No          |
+| EXP              | Yes         |
-| FLOOR            | No          |
+| FLOOR            | Yes         |
-| IntAdd           | No          |
+| IntAdd           | Yes         |
-| IntBitAnd        | No          |
+| IntBitAnd        | Yes         |
-| IntBitLeftShift  | No          |
+| IntBitLeftShift  | Yes         |
-| IntBitNot        | No          |
+| IntBitNot        | Yes         |
-| IntBitOr         | No          |
+| IntBitOr         | Yes         |
-| IntBitRightShift | No          |
+| IntBitRightShift | Yes         |
-| IntBitXor        | No          |
+| IntBitXor        | Yes         |
-| IntDiv           | No          |
+| IntDiv           | Yes         |
-| IntMod           | No          |
+| IntMod           | Yes         |
-| IntMul           | No          |
+| IntMul           | Yes         |
-| IntSub           | No          |
+| IntSub           | Yes         |
-| LOG              | No          |
+| LOG              | Yes         |
-| LOG10            | No          |
+| LOG10            | Yes         |
-| NumberBin        | No          |
+| NumberBin        | Yes         |
-| PI               | No          |
+| PI               | Yes         |
-| POWER            | No          |
+| POWER            | Yes         |
-| RADIANS          | No          |
+| RADIANS          | Yes         |
-| RAND             | No          |
+| RAND             | Yes         |
-| ROUND            | No          |
+| ROUND            | Yes         |
-| SIGN             | No          |
+| SIGN             | Yes         |
-| SIN              | No          |
+| SIN              | Yes         |
-| SQRT             | No          |
+| SQRT             | Yes         |
-| SQUARE           | No          |
+| SQUARE           | Yes         |
-| TAN              | No          |
+| TAN              | Yes         |
-| TRUNC            | No          |
+| TRUNC            | Yes         |
 
 ### Spatial Functions
+
 | Function           | Implemented |
-|--------------------|-------------|
+| ------------------ | ----------- |
 | ST_AREA            | No          |
 | ST_DISTANCE        | No          |
 | ST_WITHIN          | No          |
@@ -148,8 +158,9 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | ST_ISVALIDDETAILED | No          |
 
 ### String Functions
+
 | Function        | Implemented |
-|-----------------|-------------|
+| --------------- | ----------- |
 | CONCAT          | Yes         |
 | CONTAINS        | Yes         |
 | ENDSWITH        | Yes         |
@@ -177,8 +188,9 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | UPPER           | Yes         |
 
 ### Type checking Functions
+
 | Function         | Implemented |
-|------------------|-------------|
+| ---------------- | ----------- |
 | IS_ARRAY         | Yes         |
 | IS_BOOL          | Yes         |
 | IS_DEFINED       | Yes         |

go.mod

@@ -5,39 +5,43 @@ go 1.21.6
 require (
 	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.9.2
 	github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v0.3.6
-	github.com/gin-gonic/gin v1.9.1
+	github.com/evanphx/json-patch/v5 v5.9.0
-	github.com/google/uuid v1.1.1
+	github.com/gin-gonic/gin v1.10.0
-	github.com/stretchr/testify v1.8.4
+	github.com/google/uuid v1.6.0
-	golang.org/x/exp v0.0.0-20240222234643-814bf88cf225
+	github.com/stretchr/testify v1.9.0
+	golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc
 )
 
 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.9.1 // indirect
+	github.com/bytedance/sonic v1.11.8 // indirect
-	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/bytedance/sonic/loader v0.1.1 // indirect
+	github.com/cloudwego/base64x v0.1.4 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.4 // indirect
 	github.com/gin-contrib/sse v0.1.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.14.0 // indirect
+	github.com/go-playground/validator/v10 v10.21.0 // indirect
-	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/goccy/go-json v0.10.3 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
-	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
-	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
 	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.11 // indirect
+	github.com/ugorji/go/codec v1.2.12 // indirect
-	golang.org/x/arch v0.3.0 // indirect
+	golang.org/x/arch v0.8.0 // indirect
-	golang.org/x/crypto v0.18.0 // indirect
+	golang.org/x/crypto v0.23.0 // indirect
-	golang.org/x/net v0.20.0 // indirect
+	golang.org/x/net v0.25.0 // indirect
-	golang.org/x/sys v0.16.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
+	golang.org/x/text v0.15.0 // indirect
-	google.golang.org/protobuf v1.30.0 // indirect
+	google.golang.org/protobuf v1.34.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -10,100 +10,104 @@ github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.2 h1:LqbJ/WzJUwBf8UiaSzgX7aM
 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.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
+github.com/bytedance/sonic v1.11.8 h1:Zw/j1KfiS+OYTi9lyB3bb0CFxPJVkM17k1wyDG32LRA=
-github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s=
+github.com/bytedance/sonic v1.11.8/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
-github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
+github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
-github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
+github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
-github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
+github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
-github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
+github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
+github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
 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/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
+github.com/evanphx/json-patch/v5 v5.9.0 h1:kcBlZQbplgElYIlo/n1hJbls2z/1awpXxpRi0/FOJfg=
-github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/evanphx/json-patch/v5 v5.9.0/go.mod h1:VNkHZ/282BpEyt/tObQO8s5CMPmYYq14uClGH4abBuQ=
+github.com/gabriel-vasile/mimetype v1.4.4 h1:QjV6pZ7/XZ7ryI2KuyeEDE8wnh7fHP9YnQy+R0LnH8I=
+github.com/gabriel-vasile/mimetype v1.4.4/go.mod h1:JwLei5XPtWdGiMFB5Pjle1oEeoSeEuJfJE+TtfvdB/s=
 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/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
+github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
-github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
+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=
 github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
 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.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js=
+github.com/go-playground/validator/v10 v10.21.0 h1:4fZA11ovvtkdgaeev9RGWPgc1uj3H8W+rNYyH/ySBb0=
-github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/go-playground/validator/v10 v10.21.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
-github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
-github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/goccy/go-json v0.10.3/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/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
-github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
+github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
-github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
 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.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
-github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
-github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
+github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
-github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
+github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 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/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/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.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+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/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.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
-github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
-golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k=
+golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
-golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
-golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
+golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
-golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
-golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 h1:LfspQV/FYTatPTr/3HzIcmiUFH7PGP+OQ6mgDYo3yuQ=
+golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc h1:O9NuF4s+E/PvMIy+9IUZB9znFwUIXEWSstNjek6VpVg=
-golang.org/x/exp v0.0.0-20240222234643-814bf88cf225/go.mod h1:CxmFvTBINI24O/j8iY7H1xHzx2i4OsyguNBmN/uPtqc=
+golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
-golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
+golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
-golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
-golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
-google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
-google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 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=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
 rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

internal/authentication/authentication.go

@@ -10,6 +10,11 @@ import (
 
 // https://learn.microsoft.com/en-us/rest/api/cosmos-db/access-control-on-cosmosdb-resources
 func GenerateSignature(verb string, resourceType string, resourceId string, date string, masterKey string) string {
+	isNameBased := resourceId != "" && ((len(resourceId) > 4 && resourceId[3] == '/') || strings.HasPrefix(strings.ToLower(resourceId), "interopusers"))
+	if !isNameBased {
+		resourceId = strings.ToLower(resourceId)
+	}
+
 	payload := fmt.Sprintf(
 		"%s\n%s\n%s\n%s\n%s\n",
 		strings.ToLower(verb),

internal/authentication/authentication_test.go

@@ -27,4 +27,14 @@ func Test_GenerateSignature(t *testing.T) {
 		signature := authentication.GenerateSignature("DELETE", "dbs", "dbs/Test Database", testDate, config.DefaultAccountKey)
 		assert.Equal(t, "LcuXXg0TcXxZG0kUCj9tZIWRy2yCzim3oiqGiHpRqGs=", signature)
 	})
+
+	t.Run("Should generate PKRANGES signature", func(t *testing.T) {
+		signature := authentication.GenerateSignature("GET", "pkranges", "m4d+xG08uVM=", testDate, config.DefaultAccountKey)
+		assert.Equal(t, "6S5ceZsl2EXWB3Jo5bJcK7zv8NxXnsxWPWD9TH3nNMo=", signature)
+	})
+
+	t.Run("Should generate PATCH signature", func(t *testing.T) {
+		signature := authentication.GenerateSignature("PATCH", "docs", "dbs/test-db/colls/test-coll/docs/67890", testDate, config.DefaultAccountKey)
+		assert.Equal(t, "VR1ddfxKBXnoaT+b3WkhyYVc9JmGNpTnaRmyDM44398=", signature)
+	})
 }

internal/repositories/documents.go

@@ -66,7 +66,8 @@ func CreateDocument(databaseId string, collectionId string, document map[string]
 	var database repositorymodels.Database
 	var collection repositorymodels.Collection
 	if documentId, ok = document["id"].(string); !ok || documentId == "" {
-		return repositorymodels.Document{}, repositorymodels.BadRequest
+		documentId = fmt.Sprint(uuid.New())
+		document["id"] = documentId
 	}
 
 	if database, ok = storeState.Databases[databaseId]; !ok {

internal/resourceid/resourceid.go

@@ -2,6 +2,7 @@ package resourceid
 
 import (
 	"encoding/base64"
+	"math/rand"
 
 	"github.com/google/uuid"
 )
@@ -10,6 +11,12 @@ func New() string {
 	id := uuid.New().ID()
 	idBytes := uintToBytes(id)
 
+	// first byte should be bigger than 0x80 for collection ids
+	// clients classify this id as "user" otherwise
+	if (idBytes[0] & 0x80) <= 0 {
+		idBytes[0] = byte(rand.Intn(0x80) + 0x80)
+	}
+
 	return base64.StdEncoding.EncodeToString(idBytes)
 }
 

parsers/models.go

@@ -3,6 +3,7 @@ package parsers
 type SelectStmt struct {
 	SelectItems      []SelectItem
 	Table            Table
+	JoinItems        []JoinItem
 	Filters          interface{}
 	Distinct         bool
 	Count            int
@@ -16,6 +17,11 @@ type Table struct {
 	Value string
 }
 
+type JoinItem struct {
+	Table      Table
+	SelectItem SelectItem
+}
+
 type SelectItemType int
 
 const (
@@ -120,6 +126,43 @@ const (
 	FunctionCallSetIntersect FunctionCallType = "SetIntersect"
 	FunctionCallSetUnion     FunctionCallType = "SetUnion"
 
+	FunctionCallMathAbs              FunctionCallType = "MathAbs"
+	FunctionCallMathAcos             FunctionCallType = "MathAcos"
+	FunctionCallMathAsin             FunctionCallType = "MathAsin"
+	FunctionCallMathAtan             FunctionCallType = "MathAtan"
+	FunctionCallMathAtn2             FunctionCallType = "MathAtn2"
+	FunctionCallMathCeiling          FunctionCallType = "MathCeiling"
+	FunctionCallMathCos              FunctionCallType = "MathCos"
+	FunctionCallMathCot              FunctionCallType = "MathCot"
+	FunctionCallMathDegrees          FunctionCallType = "MathDegrees"
+	FunctionCallMathExp              FunctionCallType = "MathExp"
+	FunctionCallMathFloor            FunctionCallType = "MathFloor"
+	FunctionCallMathIntAdd           FunctionCallType = "MathIntAdd"
+	FunctionCallMathIntBitAnd        FunctionCallType = "MathIntBitAnd"
+	FunctionCallMathIntBitLeftShift  FunctionCallType = "MathIntBitLeftShift"
+	FunctionCallMathIntBitNot        FunctionCallType = "MathIntBitNot"
+	FunctionCallMathIntBitOr         FunctionCallType = "MathIntBitOr"
+	FunctionCallMathIntBitRightShift FunctionCallType = "MathIntBitRightShift"
+	FunctionCallMathIntBitXor        FunctionCallType = "MathIntBitXor"
+	FunctionCallMathIntDiv           FunctionCallType = "MathIntDiv"
+	FunctionCallMathIntMod           FunctionCallType = "MathIntMod"
+	FunctionCallMathIntMul           FunctionCallType = "MathIntMul"
+	FunctionCallMathIntSub           FunctionCallType = "MathIntSub"
+	FunctionCallMathLog              FunctionCallType = "MathLog"
+	FunctionCallMathLog10            FunctionCallType = "MathLog10"
+	FunctionCallMathNumberBin        FunctionCallType = "MathNumberBin"
+	FunctionCallMathPi               FunctionCallType = "MathPi"
+	FunctionCallMathPower            FunctionCallType = "MathPower"
+	FunctionCallMathRadians          FunctionCallType = "MathRadians"
+	FunctionCallMathRand             FunctionCallType = "MathRand"
+	FunctionCallMathRound            FunctionCallType = "MathRound"
+	FunctionCallMathSign             FunctionCallType = "MathSign"
+	FunctionCallMathSin              FunctionCallType = "MathSin"
+	FunctionCallMathSqrt             FunctionCallType = "MathSqrt"
+	FunctionCallMathSquare           FunctionCallType = "MathSquare"
+	FunctionCallMathTan              FunctionCallType = "MathTan"
+	FunctionCallMathTrunc            FunctionCallType = "MathTrunc"
+
 	FunctionCallAggregateAvg   FunctionCallType = "AggregateAvg"
 	FunctionCallAggregateCount FunctionCallType = "AggregateCount"
 	FunctionCallAggregateMax   FunctionCallType = "AggregateMax"

parsers/nosql/join_test.go

@@ -0,0 +1,57 @@
+package nosql_test
+
+import (
+	"testing"
+
+	"github.com/pikami/cosmium/parsers"
+)
+
+func Test_Parse_Join(t *testing.T) {
+
+	t.Run("Should parse simple JOIN", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT c.id, c["pk"] FROM c JOIN cc IN c["tags"]`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{Path: []string{"c", "id"}},
+					{Path: []string{"c", "pk"}},
+				},
+				Table: parsers.Table{Value: "c"},
+				JoinItems: []parsers.JoinItem{
+					{
+						Table: parsers.Table{
+							Value: "cc",
+						},
+						SelectItem: parsers.SelectItem{
+							Path: []string{"c", "tags"},
+						},
+					},
+				},
+			},
+		)
+	})
+
+	t.Run("Should parse JOIN VALUE", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT VALUE cc FROM c JOIN cc IN c["tags"]`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{Path: []string{"cc"}, IsTopLevel: true},
+				},
+				Table: parsers.Table{Value: "c"},
+				JoinItems: []parsers.JoinItem{
+					{
+						Table: parsers.Table{
+							Value: "cc",
+						},
+						SelectItem: parsers.SelectItem{
+							Path: []string{"c", "tags"},
+						},
+					},
+				},
+			},
+		)
+	})
+}

parsers/nosql/math_functions_test.go

@@ -0,0 +1,650 @@
+package nosql_test
+
+import (
+	"testing"
+
+	"github.com/pikami/cosmium/parsers"
+)
+
+func Test_Execute_MathFunctions(t *testing.T) {
+	t.Run("Should parse function ABS(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT ABS(c.value) FROM c`,
+			parsers.FunctionCallMathAbs,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function ACOS(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT ACOS(c.value) FROM c`,
+			parsers.FunctionCallMathAcos,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function ASIN(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT ASIN(c.value) FROM c`,
+			parsers.FunctionCallMathAsin,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function ATAN(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT ATAN(c.value) FROM c`,
+			parsers.FunctionCallMathAtan,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function CEILING(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT CEILING(c.value) FROM c`,
+			parsers.FunctionCallMathCeiling,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function COS(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT COS(c.value) FROM c`,
+			parsers.FunctionCallMathCos,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function COT(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT COT(c.value) FROM c`,
+			parsers.FunctionCallMathCot,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function DEGREES(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT DEGREES(c.value) FROM c`,
+			parsers.FunctionCallMathDegrees,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function EXP(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT EXP(c.value) FROM c`,
+			parsers.FunctionCallMathExp,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function FLOOR(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT FLOOR(c.value) FROM c`,
+			parsers.FunctionCallMathFloor,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function IntBitNot(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT IntBitNot(c.value) FROM c`,
+			parsers.FunctionCallMathIntBitNot,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function LOG10(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT LOG10(c.value) FROM c`,
+			parsers.FunctionCallMathLog10,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function RADIANS(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT RADIANS(c.value) FROM c`,
+			parsers.FunctionCallMathRadians,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function ROUND(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT ROUND(c.value) FROM c`,
+			parsers.FunctionCallMathRound,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function SIGN(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT SIGN(c.value) FROM c`,
+			parsers.FunctionCallMathSign,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function SIN(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT SIN(c.value) FROM c`,
+			parsers.FunctionCallMathSin,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function SQRT(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT SQRT(c.value) FROM c`,
+			parsers.FunctionCallMathSqrt,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function SQUARE(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT SQUARE(c.value) FROM c`,
+			parsers.FunctionCallMathSquare,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function TAN(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT TAN(c.value) FROM c`,
+			parsers.FunctionCallMathTan,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function TRUNC(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT TRUNC(c.value) FROM c`,
+			parsers.FunctionCallMathTrunc,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function ATN2(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT ATN2(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathAtn2,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function IntAdd(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT IntAdd(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathIntAdd,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function IntBitAnd(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT IntBitAnd(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathIntBitAnd,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function IntBitLeftShift(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT IntBitLeftShift(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathIntBitLeftShift,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function IntBitOr(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT IntBitOr(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathIntBitOr,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function IntBitRightShift(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT IntBitRightShift(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathIntBitRightShift,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function IntBitXor(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT IntBitXor(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathIntBitXor,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function IntDiv(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT IntDiv(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathIntDiv,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function IntMod(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT IntMod(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathIntMod,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function IntMul(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT IntMul(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathIntMul,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function IntSub(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT IntSub(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathIntSub,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function POWER(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT POWER(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathPower,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function LOG(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT LOG(c.value) FROM c`,
+			parsers.FunctionCallMathLog,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function LOG(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT LOG(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathLog,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function NumberBin(ex)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT NumberBin(c.value) FROM c`,
+			parsers.FunctionCallMathNumberBin,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function NumberBin(ex1, ex2)", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT NumberBin(c.value, c.secondValue) FROM c`,
+			parsers.FunctionCallMathNumberBin,
+			[]interface{}{
+				parsers.SelectItem{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				parsers.SelectItem{
+					Path: []string{"c", "secondValue"},
+					Type: parsers.SelectItemTypeField,
+				},
+			},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function PI()", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT PI() FROM c`,
+			parsers.FunctionCallMathPi,
+			[]interface{}{},
+			"c",
+		)
+	})
+
+	t.Run("Should parse function RAND()", func(t *testing.T) {
+		testMathFunctionParse(
+			t,
+			`SELECT RAND() FROM c`,
+			parsers.FunctionCallMathRand,
+			[]interface{}{},
+			"c",
+		)
+	})
+}
+
+func testMathFunctionParse(
+	t *testing.T,
+	query string,
+	expectedFunctionType parsers.FunctionCallType,
+	expectedArguments []interface{},
+	expectedTable string,
+) {
+	testQueryParse(
+		t,
+		query,
+		parsers.SelectStmt{
+			SelectItems: []parsers.SelectItem{
+				{
+					Type: parsers.SelectItemTypeFunctionCall,
+					Value: parsers.FunctionCall{
+						Type:      expectedFunctionType,
+						Arguments: expectedArguments,
+					},
+				},
+			},
+			Table: parsers.Table{Value: expectedTable},
+		},
+	)
+}

parsers/nosql/nosql.peg

@@ -4,7 +4,7 @@ package nosql
 import "github.com/pikami/cosmium/parsers"
 
 func makeSelectStmt(
-	columns, table,
+	columns, table, joinItems,
 	whereClause interface{}, distinctClause interface{},
 	count interface{}, groupByClause interface{}, orderList interface{},
 	offsetClause interface{},
@@ -14,6 +14,13 @@ func makeSelectStmt(
 		Table:       table.(parsers.Table),
 	}
 
+    if joinItemsArray, ok := joinItems.([]interface{}); ok && len(joinItemsArray) > 0 {
+		selectStmt.JoinItems = make([]parsers.JoinItem, len(joinItemsArray))
+		for i, joinItem := range joinItemsArray {
+			selectStmt.JoinItems[i] = joinItem.(parsers.JoinItem)
+		}
+	}
+
 	switch v := whereClause.(type) {
 	case parsers.ComparisonExpression, parsers.LogicalExpression, parsers.Constant, parsers.SelectItem:
 		selectStmt.Filters = v
@@ -48,6 +55,13 @@ func makeSelectStmt(
 	return selectStmt, nil
 }
 
+func makeJoin(table interface{}, column interface{}) (parsers.JoinItem, error) {
+    return parsers.JoinItem{
+        Table:      table.(parsers.Table),
+        SelectItem: column.(parsers.SelectItem),
+    }, nil
+}
+
 func makeSelectItem(name interface{}, path interface{}, selectItemType parsers.SelectItemType) (parsers.SelectItem, error) {
 	ps := path.([]interface{})
 
@@ -161,13 +175,15 @@ Input <- selectStmt:SelectStmt {
 
 SelectStmt <- Select ws
     distinctClause:DistinctClause? ws
-    topClause:TopClause? ws columns:Selection ws
+    topClause:TopClause? ws
+    columns:Selection ws
     From ws table:TableName ws
+    joinClauses:JoinClause* ws
     whereClause:(ws Where ws condition:Condition { return condition, nil })?
     groupByClause:(ws GroupBy ws columns:ColumnList { return columns, nil })?
     orderByClause:OrderByClause?
     offsetClause:OffsetClause? {
-    return makeSelectStmt(columns, table, whereClause,
+    return makeSelectStmt(columns, table, joinClauses, whereClause,
         distinctClause, topClause, groupByClause, orderByClause, offsetClause)
 }
 
@@ -177,6 +193,10 @@ TopClause <- Top ws count:Integer {
     return count, nil
 }
 
+JoinClause <- Join ws table:TableName ws "IN"i ws column:SelectItem {
+    return makeJoin(table, column)
+}
+
 OffsetClause <- "OFFSET"i ws offset:IntegerLiteral ws "LIMIT"i ws limit:IntegerLiteral {
     return []interface{}{offset.(parsers.Constant).Value, limit.(parsers.Constant).Value}, nil
 }
@@ -251,9 +271,8 @@ DotFieldAccess <- "." id:Identifier {
     return id, nil
 }
 
-ArrayFieldAccess <- "[\"" id:Identifier "\"]" {
+ArrayFieldAccess <- "[\"" id:Identifier "\"]" { return id, nil }
-    return id, nil
+  / "[" id:Integer "]" { return strconv.Itoa(id.(int)), nil }
-}
 
 Identifier <- [a-zA-Z_][a-zA-Z0-9_]* {
     return string(c.text), nil
@@ -301,6 +320,8 @@ As <- "AS"i
 
 From <- "FROM"i
 
+Join <- "JOIN"i
+
 Where <- "WHERE"i
 
 And <- "AND"i
@@ -344,6 +365,7 @@ FunctionCall <- StringFunctions
     / ArrayFunctions
     / InFunction
     / AggregateFunctions
+    / MathFunctions
 
 StringFunctions <- StringEqualsExpression
     / ToStringExpression
@@ -385,6 +407,43 @@ ArrayFunctions <- ArrayConcatExpression
     / SetIntersectExpression
     / SetUnionExpression
 
+MathFunctions <- MathAbsExpression
+    / MathAcosExpression
+    / MathAsinExpression
+    / MathAtanExpression
+    / MathCeilingExpression
+    / MathCosExpression
+    / MathCotExpression
+    / MathDegreesExpression
+    / MathExpExpression
+    / MathFloorExpression
+    / MathIntBitNotExpression
+    / MathLog10Expression
+    / MathRadiansExpression
+    / MathRoundExpression
+    / MathSignExpression
+    / MathSinExpression
+    / MathSqrtExpression
+    / MathSquareExpression
+    / MathTanExpression
+    / MathTruncExpression
+    / MathAtn2Expression
+    / MathIntAddExpression
+    / MathIntBitAndExpression
+    / MathIntBitLeftShiftExpression
+    / MathIntBitOrExpression
+    / MathIntBitRightShiftExpression
+    / MathIntBitXorExpression
+    / MathIntDivExpression
+    / MathIntModExpression
+    / MathIntMulExpression
+    / MathIntSubExpression
+    / MathPowerExpression
+    / MathLogExpression
+    / MathNumberBinExpression
+    / MathPiExpression
+    / MathRandExpression
+
 UpperExpression <- "UPPER"i ws "(" ex:SelectItem ")" {
     return createFunctionCall(parsers.FunctionCallUpper, []interface{}{ex})
 }
@@ -528,6 +587,49 @@ SetUnionExpression <- "SetUnion"i ws "(" ws set1:SelectItem ws "," ws set2:Selec
     return createFunctionCall(parsers.FunctionCallSetUnion, []interface{}{set1, set2})
 }
 
+MathAbsExpression <- "ABS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAbs, []interface{}{ex}) }
+MathAcosExpression <- "ACOS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAcos, []interface{}{ex}) }
+MathAsinExpression <- "ASIN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAsin, []interface{}{ex}) }
+MathAtanExpression <- "ATAN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAtan, []interface{}{ex}) }
+MathCeilingExpression <- "CEILING"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathCeiling, []interface{}{ex}) }
+MathCosExpression <- "COS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathCos, []interface{}{ex}) }
+MathCotExpression <- "COT"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathCot, []interface{}{ex}) }
+MathDegreesExpression <- "DEGREES"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathDegrees, []interface{}{ex}) }
+MathExpExpression <- "EXP"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathExp, []interface{}{ex}) }
+MathFloorExpression <- "FLOOR"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathFloor, []interface{}{ex}) }
+MathIntBitNotExpression <- "IntBitNot"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitNot, []interface{}{ex}) }
+MathLog10Expression <- "LOG10"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathLog10, []interface{}{ex}) }
+MathRadiansExpression <- "RADIANS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathRadians, []interface{}{ex}) }
+MathRoundExpression <- "ROUND"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathRound, []interface{}{ex}) }
+MathSignExpression <- "SIGN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSign, []interface{}{ex}) }
+MathSinExpression <- "SIN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSin, []interface{}{ex}) }
+MathSqrtExpression <- "SQRT"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSqrt, []interface{}{ex}) }
+MathSquareExpression <- "SQUARE"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSquare, []interface{}{ex}) }
+MathTanExpression <- "TAN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathTan, []interface{}{ex}) }
+MathTruncExpression <- "TRUNC"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathTrunc, []interface{}{ex}) }
+
+MathAtn2Expression <- "ATN2"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAtn2, []interface{}{set1, set2}) }
+MathIntAddExpression <- "IntAdd"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntAdd, []interface{}{set1, set2}) }
+MathIntBitAndExpression <- "IntBitAnd"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitAnd, []interface{}{set1, set2}) }
+MathIntBitLeftShiftExpression <- "IntBitLeftShift"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitLeftShift, []interface{}{set1, set2}) }
+MathIntBitOrExpression <- "IntBitOr"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitOr, []interface{}{set1, set2}) }
+MathIntBitRightShiftExpression <- "IntBitRightShift"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitRightShift, []interface{}{set1, set2}) }
+MathIntBitXorExpression <- "IntBitXor"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitXor, []interface{}{set1, set2}) }
+MathIntDivExpression <- "IntDiv"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntDiv, []interface{}{set1, set2}) }
+MathIntModExpression <- "IntMod"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntMod, []interface{}{set1, set2}) }
+MathIntMulExpression <- "IntMul"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntMul, []interface{}{set1, set2}) }
+MathIntSubExpression <- "IntSub"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntSub, []interface{}{set1, set2}) }
+MathPowerExpression <- "POWER"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathPower, []interface{}{set1, set2}) }
+
+MathLogExpression <- "LOG"i ws "(" ws ex1:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
+    return createFunctionCall(parsers.FunctionCallMathLog, append([]interface{}{ex1}, others.([]interface{})...))
+}
+MathNumberBinExpression <- "NumberBin"i ws "(" ws ex1:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
+    return createFunctionCall(parsers.FunctionCallMathNumberBin, append([]interface{}{ex1}, others.([]interface{})...))
+}
+MathPiExpression <- "PI"i ws "(" ws ")" { return createFunctionCall(parsers.FunctionCallMathPi, []interface{}{}) }
+MathRandExpression <- "RAND"i ws "(" ws ")" { return createFunctionCall(parsers.FunctionCallMathRand, []interface{}{}) }
+
 InFunction <- ex1:SelectProperty ws "IN"i ws "(" ws ex2:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
     return createFunctionCall(parsers.FunctionCallIn, append([]interface{}{ex1, ex2}, others.([]interface{})...))
 }

query_executors/memory_executor/aggregate_functions.go

@@ -11,7 +11,7 @@ func (c memoryExecutorContext) aggregate_Avg(arguments []interface{}, row RowTyp
 	sum := 0.0
 	count := 0
 
-	if array, isArray := row.([]RowType); isArray {
+	if array, isArray := row.([]RowWithJoins); isArray {
 		for _, item := range array {
 			value := c.getFieldValue(selectExpression, item)
 			if numericValue, ok := value.(float64); ok {
@@ -35,7 +35,7 @@ func (c memoryExecutorContext) aggregate_Count(arguments []interface{}, row RowT
 	selectExpression := arguments[0].(parsers.SelectItem)
 	count := 0
 
-	if array, isArray := row.([]RowType); isArray {
+	if array, isArray := row.([]RowWithJoins); isArray {
 		for _, item := range array {
 			value := c.getFieldValue(selectExpression, item)
 			if value != nil {
@@ -52,7 +52,7 @@ func (c memoryExecutorContext) aggregate_Max(arguments []interface{}, row RowTyp
 	max := 0.0
 	count := 0
 
-	if array, isArray := row.([]RowType); isArray {
+	if array, isArray := row.([]RowWithJoins); isArray {
 		for _, item := range array {
 			value := c.getFieldValue(selectExpression, item)
 			if numericValue, ok := value.(float64); ok {
@@ -81,7 +81,7 @@ func (c memoryExecutorContext) aggregate_Min(arguments []interface{}, row RowTyp
 	min := math.MaxFloat64
 	count := 0
 
-	if array, isArray := row.([]RowType); isArray {
+	if array, isArray := row.([]RowWithJoins); isArray {
 		for _, item := range array {
 			value := c.getFieldValue(selectExpression, item)
 			if numericValue, ok := value.(float64); ok {
@@ -110,7 +110,7 @@ func (c memoryExecutorContext) aggregate_Sum(arguments []interface{}, row RowTyp
 	sum := 0.0
 	count := 0
 
-	if array, isArray := row.([]RowType); isArray {
+	if array, isArray := row.([]RowWithJoins); isArray {
 		for _, item := range array {
 			value := c.getFieldValue(selectExpression, item)
 			if numericValue, ok := value.(float64); ok {

query_executors/memory_executor/join_test.go

@@ -0,0 +1,86 @@
+package memoryexecutor_test
+
+import (
+	"testing"
+
+	"github.com/pikami/cosmium/parsers"
+	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
+)
+
+func Test_Execute_Joins(t *testing.T) {
+	mockData := []memoryexecutor.RowType{
+		map[string]interface{}{
+			"id": 1,
+			"tags": []map[string]interface{}{
+				{"name": "a"},
+				{"name": "b"},
+			},
+		},
+		map[string]interface{}{
+			"id": 2,
+			"tags": []map[string]interface{}{
+				{"name": "b"},
+				{"name": "c"},
+			},
+		},
+	}
+
+	t.Run("Should execute JOIN on 'tags'", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{Path: []string{"c", "id"}},
+					{Path: []string{"cc", "name"}},
+				},
+				Table: parsers.Table{Value: "c"},
+				JoinItems: []parsers.JoinItem{
+					{
+						Table: parsers.Table{
+							Value: "cc",
+						},
+						SelectItem: parsers.SelectItem{
+							Path: []string{"c", "tags"},
+						},
+					},
+				},
+			},
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"id": 1, "name": "a"},
+				map[string]interface{}{"id": 1, "name": "b"},
+				map[string]interface{}{"id": 2, "name": "b"},
+				map[string]interface{}{"id": 2, "name": "c"},
+			},
+		)
+	})
+
+	t.Run("Should execute JOIN VALUE on 'tags'", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{Path: []string{"cc"}, IsTopLevel: true},
+				},
+				Table: parsers.Table{Value: "c"},
+				JoinItems: []parsers.JoinItem{
+					{
+						Table: parsers.Table{
+							Value: "cc",
+						},
+						SelectItem: parsers.SelectItem{
+							Path: []string{"c", "tags"},
+						},
+					},
+				},
+			},
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"name": "a"},
+				map[string]interface{}{"name": "b"},
+				map[string]interface{}{"name": "b"},
+				map[string]interface{}{"name": "c"},
+			},
+		)
+	})
+}

query_executors/memory_executor/math_functions.go

@@ -0,0 +1,615 @@
+package memoryexecutor
+
+import (
+	"math"
+	"math/rand"
+
+	"github.com/pikami/cosmium/internal/logger"
+	"github.com/pikami/cosmium/parsers"
+)
+
+func (c memoryExecutorContext) math_Abs(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	switch val := ex.(type) {
+	case float64:
+		return math.Abs(val)
+	case int:
+		if val < 0 {
+			return -val
+		}
+		return val
+	default:
+		logger.Debug("math_Abs - got parameters of wrong type")
+		return 0
+	}
+}
+
+func (c memoryExecutorContext) math_Acos(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Acos - got parameters of wrong type")
+		return nil
+	}
+
+	if val < -1 || val > 1 {
+		logger.Debug("math_Acos - value out of domain for acos")
+		return nil
+	}
+
+	return math.Acos(val) * 180 / math.Pi
+}
+
+func (c memoryExecutorContext) math_Asin(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Asin - got parameters of wrong type")
+		return nil
+	}
+
+	if val < -1 || val > 1 {
+		logger.Debug("math_Asin - value out of domain for acos")
+		return nil
+	}
+
+	return math.Asin(val) * 180 / math.Pi
+}
+
+func (c memoryExecutorContext) math_Atan(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Atan - got parameters of wrong type")
+		return nil
+	}
+
+	return math.Atan(val) * 180 / math.Pi
+}
+
+func (c memoryExecutorContext) math_Ceiling(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	switch val := ex.(type) {
+	case float64:
+		return math.Ceil(val)
+	case int:
+		return val
+	default:
+		logger.Debug("math_Ceiling - got parameters of wrong type")
+		return 0
+	}
+}
+
+func (c memoryExecutorContext) math_Cos(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Cos - got parameters of wrong type")
+		return nil
+	}
+
+	return math.Cos(val)
+}
+
+func (c memoryExecutorContext) math_Cot(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Cot - got parameters of wrong type")
+		return nil
+	}
+
+	if val == 0 {
+		logger.Debug("math_Cot - cotangent undefined for zero")
+		return nil
+	}
+
+	return 1 / math.Tan(val)
+}
+
+func (c memoryExecutorContext) math_Degrees(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Degrees - got parameters of wrong type")
+		return nil
+	}
+
+	return val * (180 / math.Pi)
+}
+
+func (c memoryExecutorContext) math_Exp(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Exp - got parameters of wrong type")
+		return nil
+	}
+
+	return math.Exp(val)
+}
+
+func (c memoryExecutorContext) math_Floor(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	switch val := ex.(type) {
+	case float64:
+		return math.Floor(val)
+	case int:
+		return val
+	default:
+		logger.Debug("math_Floor - got parameters of wrong type")
+		return 0
+	}
+}
+
+func (c memoryExecutorContext) math_IntBitNot(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	switch val := ex.(type) {
+	case int:
+		return ^val
+	default:
+		logger.Debug("math_IntBitNot - got parameters of wrong type")
+		return nil
+	}
+}
+
+func (c memoryExecutorContext) math_Log10(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Log10 - got parameters of wrong type")
+		return nil
+	}
+
+	if val <= 0 {
+		logger.Debug("math_Log10 - value must be greater than 0")
+		return nil
+	}
+
+	return math.Log10(val)
+}
+
+func (c memoryExecutorContext) math_Radians(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Radians - got parameters of wrong type")
+		return nil
+	}
+
+	return val * (math.Pi / 180.0)
+}
+
+func (c memoryExecutorContext) math_Round(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	switch val := ex.(type) {
+	case float64:
+		return math.Round(val)
+	case int:
+		return val
+	default:
+		logger.Debug("math_Round - got parameters of wrong type")
+		return nil
+	}
+}
+
+func (c memoryExecutorContext) math_Sign(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	switch val := ex.(type) {
+	case float64:
+		if val > 0 {
+			return 1
+		} else if val < 0 {
+			return -1
+		} else {
+			return 0
+		}
+	case int:
+		if val > 0 {
+			return 1
+		} else if val < 0 {
+			return -1
+		} else {
+			return 0
+		}
+	default:
+		logger.Debug("math_Sign - got parameters of wrong type")
+		return nil
+	}
+}
+
+func (c memoryExecutorContext) math_Sin(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Sin - got parameters of wrong type")
+		return nil
+	}
+
+	return math.Sin(val)
+}
+
+func (c memoryExecutorContext) math_Sqrt(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Sqrt - got parameters of wrong type")
+		return nil
+	}
+
+	return math.Sqrt(val)
+}
+
+func (c memoryExecutorContext) math_Square(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Square - got parameters of wrong type")
+		return nil
+	}
+
+	return math.Pow(val, 2)
+}
+
+func (c memoryExecutorContext) math_Tan(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	val, valIsNumber := numToFloat64(ex)
+	if !valIsNumber {
+		logger.Debug("math_Tan - got parameters of wrong type")
+		return nil
+	}
+
+	return math.Tan(val)
+}
+
+func (c memoryExecutorContext) math_Trunc(arguments []interface{}, row RowType) interface{} {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	switch val := ex.(type) {
+	case float64:
+		return math.Trunc(val)
+	case int:
+		return float64(val)
+	default:
+		logger.Debug("math_Trunc - got parameters of wrong type")
+		return nil
+	}
+}
+
+func (c memoryExecutorContext) math_Atn2(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	y, yIsNumber := numToFloat64(ex1)
+	x, xIsNumber := numToFloat64(ex2)
+
+	if !yIsNumber || !xIsNumber {
+		logger.Debug("math_Atn2 - got parameters of wrong type")
+		return nil
+	}
+
+	return math.Atan2(y, x)
+}
+
+func (c memoryExecutorContext) math_IntAdd(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	ex1Number, ex1IsNumber := numToInt(ex1)
+	ex2Number, ex2IsNumber := numToInt(ex2)
+
+	if !ex1IsNumber || !ex2IsNumber {
+		logger.Debug("math_IntAdd - got parameters of wrong type")
+		return nil
+	}
+
+	return ex1Number + ex2Number
+}
+
+func (c memoryExecutorContext) math_IntBitAnd(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	ex1Int, ex1IsInt := numToInt(ex1)
+	ex2Int, ex2IsInt := numToInt(ex2)
+
+	if !ex1IsInt || !ex2IsInt {
+		logger.Debug("math_IntBitAnd - got parameters of wrong type")
+		return nil
+	}
+
+	return ex1Int & ex2Int
+}
+
+func (c memoryExecutorContext) math_IntBitLeftShift(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	num1, num1IsInt := numToInt(ex1)
+	num2, num2IsInt := numToInt(ex2)
+
+	if !num1IsInt || !num2IsInt {
+		logger.Debug("math_IntBitLeftShift - got parameters of wrong type")
+		return nil
+	}
+
+	return num1 << uint(num2)
+}
+
+func (c memoryExecutorContext) math_IntBitOr(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	num1, num1IsInt := ex1.(int)
+	num2, num2IsInt := ex2.(int)
+
+	if !num1IsInt || !num2IsInt {
+		logger.Debug("math_IntBitOr - got parameters of wrong type")
+		return nil
+	}
+
+	return num1 | num2
+}
+
+func (c memoryExecutorContext) math_IntBitRightShift(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	num1, num1IsInt := numToInt(ex1)
+	num2, num2IsInt := numToInt(ex2)
+
+	if !num1IsInt || !num2IsInt {
+		logger.Debug("math_IntBitRightShift - got parameters of wrong type")
+		return nil
+	}
+
+	return num1 >> uint(num2)
+}
+
+func (c memoryExecutorContext) math_IntBitXor(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	num1, num1IsInt := ex1.(int)
+	num2, num2IsInt := ex2.(int)
+
+	if !num1IsInt || !num2IsInt {
+		logger.Debug("math_IntBitXor - got parameters of wrong type")
+		return nil
+	}
+
+	return num1 ^ num2
+}
+
+func (c memoryExecutorContext) math_IntDiv(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	num1, num1IsInt := ex1.(int)
+	num2, num2IsInt := ex2.(int)
+
+	if !num1IsInt || !num2IsInt || num2 == 0 {
+		logger.Debug("math_IntDiv - got parameters of wrong type or divide by zero")
+		return nil
+	}
+
+	return num1 / num2
+}
+
+func (c memoryExecutorContext) math_IntMul(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	num1, num1IsInt := ex1.(int)
+	num2, num2IsInt := ex2.(int)
+
+	if !num1IsInt || !num2IsInt {
+		logger.Debug("math_IntMul - got parameters of wrong type")
+		return nil
+	}
+
+	return num1 * num2
+}
+
+func (c memoryExecutorContext) math_IntSub(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	num1, num1IsInt := ex1.(int)
+	num2, num2IsInt := ex2.(int)
+
+	if !num1IsInt || !num2IsInt {
+		logger.Debug("math_IntSub - got parameters of wrong type")
+		return nil
+	}
+
+	return num1 - num2
+}
+
+func (c memoryExecutorContext) math_IntMod(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	num1, num1IsInt := ex1.(int)
+	num2, num2IsInt := ex2.(int)
+
+	if !num1IsInt || !num2IsInt || num2 == 0 {
+		logger.Debug("math_IntMod - got parameters of wrong type or divide by zero")
+		return nil
+	}
+
+	return num1 % num2
+}
+
+func (c memoryExecutorContext) math_Power(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	exItem2 := arguments[1].(parsers.SelectItem)
+	ex1 := c.getFieldValue(exItem1, row)
+	ex2 := c.getFieldValue(exItem2, row)
+
+	base, baseIsNumber := numToFloat64(ex1)
+	exponent, exponentIsNumber := numToFloat64(ex2)
+
+	if !baseIsNumber || !exponentIsNumber {
+		logger.Debug("math_Power - got parameters of wrong type")
+		return nil
+	}
+
+	return math.Pow(base, exponent)
+}
+
+func (c memoryExecutorContext) math_Log(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem1, row)
+
+	var base float64 = math.E
+	if len(arguments) > 1 {
+		exItem2 := arguments[1].(parsers.SelectItem)
+		baseValueObject := c.getFieldValue(exItem2, row)
+		baseValue, baseValueIsNumber := numToFloat64(baseValueObject)
+
+		if !baseValueIsNumber {
+			logger.Debug("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")
+			return nil
+		}
+	}
+
+	num, numIsNumber := numToFloat64(ex)
+	if !numIsNumber || num <= 0 {
+		logger.Debug("math_Log - parameter must be a positive numeric value")
+		return nil
+	}
+
+	return math.Log(num) / math.Log(base)
+}
+
+func (c memoryExecutorContext) math_NumberBin(arguments []interface{}, row RowType) interface{} {
+	exItem1 := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem1, row)
+
+	binSize := 1.0
+
+	if len(arguments) > 1 {
+		exItem2 := arguments[1].(parsers.SelectItem)
+		binSizeValueObject := c.getFieldValue(exItem2, row)
+		binSizeValue, binSizeValueIsNumber := numToFloat64(binSizeValueObject)
+
+		if !binSizeValueIsNumber {
+			logger.Debug("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")
+			return nil
+		}
+	}
+
+	num, numIsNumber := numToFloat64(ex)
+	if !numIsNumber {
+		logger.Debug("math_NumberBin - parameter must be a numeric value")
+		return nil
+	}
+
+	return math.Floor(num/binSize) * binSize
+}
+
+func (c memoryExecutorContext) math_Pi() interface{} {
+	return math.Pi
+}
+
+func (c memoryExecutorContext) math_Rand() interface{} {
+	return rand.Float64()
+}
+
+func numToInt(ex interface{}) (int, bool) {
+	switch val := ex.(type) {
+	case float64:
+		return int(val), true
+	case int:
+		return val, true
+	default:
+		return 0, false
+	}
+}
+
+func numToFloat64(num interface{}) (float64, bool) {
+	switch val := num.(type) {
+	case float64:
+		return val, true
+	case int:
+		return float64(val), true
+	default:
+		return 0, false
+	}
+}

query_executors/memory_executor/math_functions_test.go

@@ -0,0 +1,269 @@
+package memoryexecutor_test
+
+import (
+	"math"
+	"testing"
+
+	"github.com/pikami/cosmium/parsers"
+	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
+)
+
+func Test_Execute_MathFunctions(t *testing.T) {
+	mockData := []memoryexecutor.RowType{
+		map[string]interface{}{"id": 1, "value": 0.0},
+		map[string]interface{}{"id": 2, "value": 1.0},
+		map[string]interface{}{"id": 3, "value": -1.0},
+		map[string]interface{}{"id": 4, "value": 0.5},
+		map[string]interface{}{"id": 5, "value": -0.5},
+		map[string]interface{}{"id": 6, "value": 0.707},
+		map[string]interface{}{"id": 7, "value": -0.707},
+		map[string]interface{}{"id": 8, "value": 0.866},
+		map[string]interface{}{"id": 9, "value": -0.866},
+	}
+
+	mockDataInts := []memoryexecutor.RowType{
+		map[string]interface{}{"id": 1, "value": -1},
+		map[string]interface{}{"id": 2, "value": 0},
+		map[string]interface{}{"id": 3, "value": 1},
+		map[string]interface{}{"id": 4, "value": 5},
+	}
+
+	t.Run("Should execute function ABS(value)", func(t *testing.T) {
+		testMathFunctionExecute(
+			t,
+			parsers.FunctionCallMathAbs,
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"value": 0.0, "result": 0.0},
+				map[string]interface{}{"value": 1.0, "result": 1.0},
+				map[string]interface{}{"value": -1.0, "result": 1.0},
+				map[string]interface{}{"value": 0.5, "result": 0.5},
+				map[string]interface{}{"value": -0.5, "result": 0.5},
+				map[string]interface{}{"value": 0.707, "result": 0.707},
+				map[string]interface{}{"value": -0.707, "result": 0.707},
+				map[string]interface{}{"value": 0.866, "result": 0.866},
+				map[string]interface{}{"value": -0.866, "result": 0.866},
+			},
+		)
+	})
+
+	t.Run("Should execute function ACOS(cosine)", func(t *testing.T) {
+		testMathFunctionExecute(
+			t,
+			parsers.FunctionCallMathAcos,
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"value": 0.0, "result": math.Acos(0.0) * 180 / math.Pi},
+				map[string]interface{}{"value": 1.0, "result": math.Acos(1.0) * 180 / math.Pi},
+				map[string]interface{}{"value": -1.0, "result": math.Acos(-1.0) * 180 / math.Pi},
+				map[string]interface{}{"value": 0.5, "result": math.Acos(0.5) * 180 / math.Pi},
+				map[string]interface{}{"value": -0.5, "result": math.Acos(-0.5) * 180 / math.Pi},
+				map[string]interface{}{"value": 0.707, "result": math.Acos(0.707) * 180 / math.Pi},
+				map[string]interface{}{"value": -0.707, "result": math.Acos(-0.707) * 180 / math.Pi},
+				map[string]interface{}{"value": 0.866, "result": math.Acos(0.866) * 180 / math.Pi},
+				map[string]interface{}{"value": -0.866, "result": math.Acos(-0.866) * 180 / math.Pi},
+			},
+		)
+	})
+
+	t.Run("Should execute function ASIN(value)", func(t *testing.T) {
+		testMathFunctionExecute(
+			t,
+			parsers.FunctionCallMathAsin,
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"value": 0.0, "result": math.Asin(0.0) * 180 / math.Pi},
+				map[string]interface{}{"value": 1.0, "result": math.Asin(1.0) * 180 / math.Pi},
+				map[string]interface{}{"value": -1.0, "result": math.Asin(-1.0) * 180 / math.Pi},
+				map[string]interface{}{"value": 0.5, "result": math.Asin(0.5) * 180 / math.Pi},
+				map[string]interface{}{"value": -0.5, "result": math.Asin(-0.5) * 180 / math.Pi},
+				map[string]interface{}{"value": 0.707, "result": math.Asin(0.707) * 180 / math.Pi},
+				map[string]interface{}{"value": -0.707, "result": math.Asin(-0.707) * 180 / math.Pi},
+				map[string]interface{}{"value": 0.866, "result": math.Asin(0.866) * 180 / math.Pi},
+				map[string]interface{}{"value": -0.866, "result": math.Asin(-0.866) * 180 / math.Pi},
+			},
+		)
+	})
+
+	t.Run("Should execute function ATAN(tangent)", func(t *testing.T) {
+		testMathFunctionExecute(
+			t,
+			parsers.FunctionCallMathAtan,
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"value": 0.0, "result": math.Atan(0.0) * 180 / math.Pi},
+				map[string]interface{}{"value": 1.0, "result": math.Atan(1.0) * 180 / math.Pi},
+				map[string]interface{}{"value": -1.0, "result": math.Atan(-1.0) * 180 / math.Pi},
+				map[string]interface{}{"value": 0.5, "result": math.Atan(0.5) * 180 / math.Pi},
+				map[string]interface{}{"value": -0.5, "result": math.Atan(-0.5) * 180 / math.Pi},
+				map[string]interface{}{"value": 0.707, "result": math.Atan(0.707) * 180 / math.Pi},
+				map[string]interface{}{"value": -0.707, "result": math.Atan(-0.707) * 180 / math.Pi},
+				map[string]interface{}{"value": 0.866, "result": math.Atan(0.866) * 180 / math.Pi},
+				map[string]interface{}{"value": -0.866, "result": math.Atan(-0.866) * 180 / math.Pi},
+			},
+		)
+	})
+
+	t.Run("Should execute function COS(value)", func(t *testing.T) {
+		testMathFunctionExecute(
+			t,
+			parsers.FunctionCallMathCos,
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"value": 0.0, "result": math.Cos(0.0)},
+				map[string]interface{}{"value": 1.0, "result": math.Cos(1.0)},
+				map[string]interface{}{"value": -1.0, "result": math.Cos(-1.0)},
+				map[string]interface{}{"value": 0.5, "result": math.Cos(0.5)},
+				map[string]interface{}{"value": -0.5, "result": math.Cos(-0.5)},
+				map[string]interface{}{"value": 0.707, "result": math.Cos(0.707)},
+				map[string]interface{}{"value": -0.707, "result": math.Cos(-0.707)},
+				map[string]interface{}{"value": 0.866, "result": math.Cos(0.866)},
+				map[string]interface{}{"value": -0.866, "result": math.Cos(-0.866)},
+			},
+		)
+	})
+
+	t.Run("Should execute function COT(value)", func(t *testing.T) {
+		testMathFunctionExecute(
+			t,
+			parsers.FunctionCallMathCot,
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"value": 0.0, "result": nil},
+				map[string]interface{}{"value": 1.0, "result": 1 / math.Tan(1.0)},
+				map[string]interface{}{"value": -1.0, "result": 1 / math.Tan(-1.0)},
+				map[string]interface{}{"value": 0.5, "result": 1 / math.Tan(0.5)},
+				map[string]interface{}{"value": -0.5, "result": 1 / math.Tan(-0.5)},
+				map[string]interface{}{"value": 0.707, "result": 1 / math.Tan(0.707)},
+				map[string]interface{}{"value": -0.707, "result": 1 / math.Tan(-0.707)},
+				map[string]interface{}{"value": 0.866, "result": 1 / math.Tan(0.866)},
+				map[string]interface{}{"value": -0.866, "result": 1 / math.Tan(-0.866)},
+			},
+		)
+	})
+
+	t.Run("Should execute function Degrees(value)", func(t *testing.T) {
+		testMathFunctionExecute(
+			t,
+			parsers.FunctionCallMathDegrees,
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"value": 0.0, "result": 0.0 * (180 / math.Pi)},
+				map[string]interface{}{"value": 1.0, "result": 1.0 * (180 / math.Pi)},
+				map[string]interface{}{"value": -1.0, "result": -1.0 * (180 / math.Pi)},
+				map[string]interface{}{"value": 0.5, "result": 0.5 * (180 / math.Pi)},
+				map[string]interface{}{"value": -0.5, "result": -0.5 * (180 / math.Pi)},
+				map[string]interface{}{"value": 0.707, "result": 0.707 * (180 / math.Pi)},
+				map[string]interface{}{"value": -0.707, "result": -0.707 * (180 / math.Pi)},
+				map[string]interface{}{"value": 0.866, "result": 0.866 * (180 / math.Pi)},
+				map[string]interface{}{"value": -0.866, "result": -0.866 * (180 / math.Pi)},
+			},
+		)
+	})
+
+	t.Run("Should execute function EXP(value)", func(t *testing.T) {
+		testMathFunctionExecute(
+			t,
+			parsers.FunctionCallMathExp,
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"value": 0.0, "result": math.Exp(0.0)},
+				map[string]interface{}{"value": 1.0, "result": math.Exp(1.0)},
+				map[string]interface{}{"value": -1.0, "result": math.Exp(-1.0)},
+				map[string]interface{}{"value": 0.5, "result": math.Exp(0.5)},
+				map[string]interface{}{"value": -0.5, "result": math.Exp(-0.5)},
+				map[string]interface{}{"value": 0.707, "result": math.Exp(0.707)},
+				map[string]interface{}{"value": -0.707, "result": math.Exp(-0.707)},
+				map[string]interface{}{"value": 0.866, "result": math.Exp(0.866)},
+				map[string]interface{}{"value": -0.866, "result": math.Exp(-0.866)},
+			},
+		)
+	})
+
+	t.Run("Should execute function FLOOR(value)", func(t *testing.T) {
+		testMathFunctionExecute(
+			t,
+			parsers.FunctionCallMathFloor,
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"value": 0.0, "result": math.Floor(0.0)},
+				map[string]interface{}{"value": 1.0, "result": math.Floor(1.0)},
+				map[string]interface{}{"value": -1.0, "result": math.Floor(-1.0)},
+				map[string]interface{}{"value": 0.5, "result": math.Floor(0.5)},
+				map[string]interface{}{"value": -0.5, "result": math.Floor(-0.5)},
+				map[string]interface{}{"value": 0.707, "result": math.Floor(0.707)},
+				map[string]interface{}{"value": -0.707, "result": math.Floor(-0.707)},
+				map[string]interface{}{"value": 0.866, "result": math.Floor(0.866)},
+				map[string]interface{}{"value": -0.866, "result": math.Floor(-0.866)},
+			},
+		)
+	})
+
+	t.Run("Should execute function IntBitNot(value)", func(t *testing.T) {
+		testMathFunctionExecute(
+			t,
+			parsers.FunctionCallMathIntBitNot,
+			mockDataInts,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"value": -1, "result": ^-1},
+				map[string]interface{}{"value": 0, "result": ^0},
+				map[string]interface{}{"value": 1, "result": ^1},
+				map[string]interface{}{"value": 5, "result": ^5},
+			},
+		)
+	})
+
+	t.Run("Should execute function LOG10(value)", func(t *testing.T) {
+		testMathFunctionExecute(
+			t,
+			parsers.FunctionCallMathLog10,
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"value": 0.0, "result": nil},
+				map[string]interface{}{"value": 1.0, "result": math.Log10(1.0)},
+				map[string]interface{}{"value": -1.0, "result": nil},
+				map[string]interface{}{"value": 0.5, "result": math.Log10(0.5)},
+				map[string]interface{}{"value": -0.5, "result": nil},
+				map[string]interface{}{"value": 0.707, "result": math.Log10(0.707)},
+				map[string]interface{}{"value": -0.707, "result": nil},
+				map[string]interface{}{"value": 0.866, "result": math.Log10(0.866)},
+				map[string]interface{}{"value": -0.866, "result": nil},
+			},
+		)
+	})
+}
+
+func testMathFunctionExecute(
+	t *testing.T,
+	functionCallType parsers.FunctionCallType,
+	data []memoryexecutor.RowType,
+	expectedData []memoryexecutor.RowType,
+) {
+	testQueryExecute(
+		t,
+		parsers.SelectStmt{
+			SelectItems: []parsers.SelectItem{
+				{
+					Path: []string{"c", "value"},
+					Type: parsers.SelectItemTypeField,
+				},
+				{
+					Alias: "result",
+					Type:  parsers.SelectItemTypeFunctionCall,
+					Value: parsers.FunctionCall{
+						Type: functionCallType,
+						Arguments: []interface{}{
+							parsers.SelectItem{
+								Path: []string{"c", "value"},
+								Type: parsers.SelectItemTypeField,
+							},
+						},
+					},
+				},
+			},
+			Table: parsers.Table{Value: "c"},
+		},
+		data,
+		expectedData,
+	)
+}

query_executors/memory_executor/memory_executor.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"reflect"
 	"sort"
+	"strconv"
 	"strings"
 
 	"github.com/pikami/cosmium/internal/logger"
@@ -12,6 +13,7 @@ import (
 )
 
 type RowType interface{}
+type RowWithJoins map[string]RowType
 type ExpressionType interface{}
 
 type memoryExecutorContext struct {
@@ -23,24 +25,52 @@ func Execute(query parsers.SelectStmt, data []RowType) []RowType {
 		parameters: query.Parameters,
 	}
 
-	result := make([]RowType, 0)
+	joinedRows := make([]RowWithJoins, 0)
-
-	// Apply Filter
 	for _, row := range data {
-		if ctx.evaluateFilters(query.Filters, row) {
+		// Perform joins
-			result = append(result, row)
+		dataTables := map[string][]RowType{}
+
+		for _, join := range query.JoinItems {
+			joinedData := ctx.getFieldValue(join.SelectItem, row)
+			if joinedDataArray, isArray := joinedData.([]map[string]interface{}); isArray {
+				var rows []RowType
+				for _, m := range joinedDataArray {
+					rows = append(rows, RowType(m))
+				}
+				dataTables[join.Table.Value] = rows
+			}
 		}
+
+		// Generate flat rows
+		flatRows := []RowWithJoins{
+			{query.Table.Value: row},
+		}
+		for joinedTableName, joinedTable := range dataTables {
+			flatRows = zipRows(flatRows, joinedTableName, joinedTable)
+		}
+
+		// Apply filters
+		filteredRows := []RowWithJoins{}
+		for _, rowWithJoins := range flatRows {
+			if ctx.evaluateFilters(query.Filters, rowWithJoins) {
+				filteredRows = append(filteredRows, rowWithJoins)
+			}
+		}
+
+		joinedRows = append(joinedRows, filteredRows...)
 	}
 
 	// Apply order
 	if query.OrderExpressions != nil && len(query.OrderExpressions) > 0 {
-		ctx.orderBy(query.OrderExpressions, result)
+		ctx.orderBy(query.OrderExpressions, joinedRows)
 	}
 
+	result := make([]RowType, 0)
+
 	// Apply group
 	isGroupSelect := query.GroupBy != nil && len(query.GroupBy) > 0
 	if isGroupSelect {
-		result = ctx.groupBy(query, result)
+		result = ctx.groupBy(query, joinedRows)
 	}
 
 	// Apply select
@@ -49,9 +79,9 @@ func Execute(query parsers.SelectStmt, data []RowType) []RowType {
 		if hasAggregateFunctions(query.SelectItems) {
 			// When can have aggregate functions without GROUP BY clause,
 			// we should aggregate all rows in that case
-			selectedData = append(selectedData, ctx.selectRow(query.SelectItems, result))
+			selectedData = append(selectedData, ctx.selectRow(query.SelectItems, joinedRows))
 		} else {
-			for _, row := range result {
+			for _, row := range joinedRows {
 				selectedData = append(selectedData, ctx.selectRow(query.SelectItems, row))
 			}
 		}
@@ -78,7 +108,7 @@ func Execute(query parsers.SelectStmt, data []RowType) []RowType {
 	return result
 }
 
-func (c memoryExecutorContext) selectRow(selectItems []parsers.SelectItem, row RowType) interface{} {
+func (c memoryExecutorContext) selectRow(selectItems []parsers.SelectItem, row interface{}) interface{} {
 	// When the first value is top level, select it instead
 	if len(selectItems) > 0 && selectItems[0].IsTopLevel {
 		return c.getFieldValue(selectItems[0], row)
@@ -102,7 +132,7 @@ func (c memoryExecutorContext) selectRow(selectItems []parsers.SelectItem, row R
 	return newRow
 }
 
-func (c memoryExecutorContext) evaluateFilters(expr ExpressionType, row RowType) bool {
+func (c memoryExecutorContext) evaluateFilters(expr ExpressionType, row RowWithJoins) bool {
 	if expr == nil {
 		return true
 	}
@@ -163,7 +193,7 @@ func (c memoryExecutorContext) evaluateFilters(expr ExpressionType, row RowType)
 	return false
 }
 
-func (c memoryExecutorContext) getFieldValue(field parsers.SelectItem, row RowType) interface{} {
+func (c memoryExecutorContext) getFieldValue(field parsers.SelectItem, row interface{}) interface{} {
 	if field.Type == parsers.SelectItemTypeArray {
 		arrayValue := make([]interface{}, 0)
 		for _, selectItem := range field.SelectItems {
@@ -199,7 +229,8 @@ func (c memoryExecutorContext) getFieldValue(field parsers.SelectItem, row RowTy
 	}
 
 	rowValue := row
-	if array, isArray := row.([]RowType); isArray {
+	// Used for aggregates
+	if array, isArray := row.([]RowWithJoins); isArray {
 		rowValue = array[0]
 	}
 
@@ -283,6 +314,79 @@ func (c memoryExecutorContext) getFieldValue(field parsers.SelectItem, row RowTy
 		case parsers.FunctionCallSetUnion:
 			return c.set_Union(typedValue.Arguments, rowValue)
 
+		case parsers.FunctionCallMathAbs:
+			return c.math_Abs(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathAcos:
+			return c.math_Acos(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathAsin:
+			return c.math_Asin(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathAtan:
+			return c.math_Atan(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathCeiling:
+			return c.math_Ceiling(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathCos:
+			return c.math_Cos(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathCot:
+			return c.math_Cot(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathDegrees:
+			return c.math_Degrees(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathExp:
+			return c.math_Exp(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathFloor:
+			return c.math_Floor(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathIntBitNot:
+			return c.math_IntBitNot(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathLog10:
+			return c.math_Log10(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathRadians:
+			return c.math_Radians(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathRound:
+			return c.math_Round(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathSign:
+			return c.math_Sign(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathSin:
+			return c.math_Sin(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathSqrt:
+			return c.math_Sqrt(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathSquare:
+			return c.math_Square(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathTan:
+			return c.math_Tan(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathTrunc:
+			return c.math_Trunc(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathAtn2:
+			return c.math_Atn2(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathIntAdd:
+			return c.math_IntAdd(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathIntBitAnd:
+			return c.math_IntBitAnd(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathIntBitLeftShift:
+			return c.math_IntBitLeftShift(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathIntBitOr:
+			return c.math_IntBitOr(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathIntBitRightShift:
+			return c.math_IntBitRightShift(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathIntBitXor:
+			return c.math_IntBitXor(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathIntDiv:
+			return c.math_IntDiv(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathIntMod:
+			return c.math_IntMod(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathIntMul:
+			return c.math_IntMul(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathIntSub:
+			return c.math_IntSub(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathPower:
+			return c.math_Power(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathLog:
+			return c.math_Log(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathNumberBin:
+			return c.math_NumberBin(typedValue.Arguments, rowValue)
+		case parsers.FunctionCallMathPi:
+			return c.math_Pi()
+		case parsers.FunctionCallMathRand:
+			return c.math_Rand()
+
 		case parsers.FunctionCallAggregateAvg:
 			return c.aggregate_Avg(typedValue.Arguments, row)
 		case parsers.FunctionCallAggregateCount:
@@ -300,12 +404,26 @@ func (c memoryExecutorContext) getFieldValue(field parsers.SelectItem, row RowTy
 	}
 
 	value := rowValue
+	if joinedRow, isRowWithJoins := value.(RowWithJoins); isRowWithJoins {
+		value = joinedRow[field.Path[0]]
+	}
 
 	if len(field.Path) > 1 {
 		for _, pathSegment := range field.Path[1:] {
-			if nestedValue, ok := value.(map[string]interface{}); ok {
+
+			switch nestedValue := value.(type) {
+			case map[string]interface{}:
 				value = nestedValue[pathSegment]
-			} else {
+			case RowWithJoins:
+				value = nestedValue[pathSegment]
+			case []int, []string, []interface{}:
+				slice := reflect.ValueOf(nestedValue)
+				if arrayIndex, err := strconv.Atoi(pathSegment); err == nil && slice.Len() > arrayIndex {
+					value = slice.Index(arrayIndex).Interface()
+				} else {
+					return nil
+				}
+			default:
 				return nil
 			}
 		}
@@ -315,7 +433,7 @@ func (c memoryExecutorContext) getFieldValue(field parsers.SelectItem, row RowTy
 
 func (c memoryExecutorContext) getExpressionParameterValue(
 	parameter interface{},
-	row RowType,
+	row RowWithJoins,
 ) interface{} {
 	switch typedParameter := parameter.(type) {
 	case parsers.SelectItem:
@@ -327,7 +445,7 @@ func (c memoryExecutorContext) getExpressionParameterValue(
 	return nil
 }
 
-func (c memoryExecutorContext) orderBy(orderBy []parsers.OrderExpression, data []RowType) {
+func (c memoryExecutorContext) orderBy(orderBy []parsers.OrderExpression, data []RowWithJoins) {
 	less := func(i, j int) bool {
 		for _, order := range orderBy {
 			val1 := c.getFieldValue(order.SelectItem, data[i])
@@ -347,8 +465,8 @@ func (c memoryExecutorContext) orderBy(orderBy []parsers.OrderExpression, data [
 	sort.SliceStable(data, less)
 }
 
-func (c memoryExecutorContext) groupBy(selectStmt parsers.SelectStmt, data []RowType) []RowType {
+func (c memoryExecutorContext) groupBy(selectStmt parsers.SelectStmt, data []RowWithJoins) []RowType {
-	groupedRows := make(map[string][]RowType)
+	groupedRows := make(map[string][]RowWithJoins)
 	groupedKeys := make([]string, 0)
 
 	// Group rows by group by columns
@@ -371,7 +489,7 @@ func (c memoryExecutorContext) groupBy(selectStmt parsers.SelectStmt, data []Row
 	return aggregatedRows
 }
 
-func (c memoryExecutorContext) generateGroupKey(groupByFields []parsers.SelectItem, row RowType) string {
+func (c memoryExecutorContext) generateGroupKey(groupByFields []parsers.SelectItem, row RowWithJoins) string {
 	var keyBuilder strings.Builder
 	for _, column := range groupByFields {
 		fieldValue := c.getFieldValue(column, row)
@@ -382,7 +500,7 @@ func (c memoryExecutorContext) generateGroupKey(groupByFields []parsers.SelectIt
 	return keyBuilder.String()
 }
 
-func (c memoryExecutorContext) aggregateGroup(selectStmt parsers.SelectStmt, groupRows []RowType) RowType {
+func (c memoryExecutorContext) aggregateGroup(selectStmt parsers.SelectStmt, groupRows []RowWithJoins) RowType {
 	aggregatedRow := c.selectRow(selectStmt.SelectItems, groupRows)
 
 	return aggregatedRow
@@ -470,3 +588,27 @@ func hasAggregateFunctions(selectItems []parsers.SelectItem) bool {
 
 	return false
 }
+
+func zipRows(current []RowWithJoins, joinedTableName string, rowsToZip []RowType) []RowWithJoins {
+	resultMap := make([]RowWithJoins, 0)
+
+	for _, currentRow := range current {
+		for _, rowToZip := range rowsToZip {
+			newRow := copyMap(currentRow)
+			newRow[joinedTableName] = rowToZip
+			resultMap = append(resultMap, newRow)
+		}
+	}
+
+	return resultMap
+}
+
+func copyMap(originalMap map[string]RowType) map[string]RowType {
+	targetMap := make(map[string]RowType)
+
+	for k, v := range originalMap {
+		targetMap[k] = v
+	}
+
+	return targetMap
+}