Minor query parser fixes

Makefile

@@ -19,6 +19,9 @@ build-linux-amd64:
 	@echo "Building Linux binary..."
 	@GOOS=linux GOARCH=amd64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-linux-amd64 .
 
+generate-parser-nosql:
+	pigeon -o ./parsers/nosql/nosql.go ./parsers/nosql/nosql.peg
+
 test:
 	@echo "Running unit tests..."
 	@$(GOTEST) -v ./...
@@ -28,4 +31,4 @@ clean:
 	@$(GOCLEAN)
 	@rm -rf $(DIST_DIR)
 
-.PHONY: all test build-all build-macos build-linux clean
+.PHONY: all test build-all build-macos build-linux clean generate-parser-nosql

parsers/nosql/nosql.peg

@@ -13,6 +13,8 @@ func makeSelectStmt(columns, table, whereClause interface{}, count interface{})
 		selectStmt.Filters = filters
 	} else if filters, ok := whereClause.(parsers.LogicalExpression); ok {
 		selectStmt.Filters = filters
+	} else if filters, ok := whereClause.(parsers.Constant); ok {
+		selectStmt.Filters = filters
 	}
 
 	if n, ok := count.(int); ok {
@@ -142,7 +144,7 @@ SelectObject <- "{" ws field:SelectObjectField ws other_fields:(ws "," ws coll:S
     return makeSelectObject(field, other_fields)
 }
 
-SelectObjectField <- name:Identifier ws ":" ws selectItem:SelectItem {
+SelectObjectField <- name:(Identifier / "\"" key:Identifier "\"" { return key, nil }) ws ":" ws selectItem:SelectItem {
     item := selectItem.(parsers.SelectItem)
 	item.Alias = name.(string)
 	return item, nil
@@ -178,18 +180,18 @@ Condition <- expression:OrExpression {
     return expression, nil
 }
 
-OrExpression <- ex1:AndExpression ex2:(ws "OR" ws ex:AndExpression { return ex, nil })* {
+OrExpression <- ex1:AndExpression ex2:(ws Or ws ex:AndExpression { return ex, nil })* {
     return combineExpressions(ex1, ex2, parsers.LogicalExpressionTypeOr)
 }
 
-AndExpression <- ex1:ComparisonExpression ex2:(ws "AND" ws ex:ComparisonExpression { return ex, nil })* {
+AndExpression <- ex1:ComparisonExpression ex2:(ws And ws ex:ComparisonExpression { return ex, nil })* {
     return combineExpressions(ex1, ex2, parsers.LogicalExpressionTypeAnd)
 }
 
 ComparisonExpression <- "(" ws ex:OrExpression ws ")" { return ex, nil }
     / left:(Literal / SelectItem) ws op:ComparisonOperator ws right:(Literal / SelectItem) {
     return parsers.ComparisonExpression{Left:left,Right:right,Operation:string(op.([]uint8))}, nil
-}
+} / ex:BooleanLiteral { return ex, nil }
 
 Select <- ("select" / "SELECT")
 
@@ -201,15 +203,22 @@ From <- ("from" / "FROM")
 
 Where <- ("where" / "WHERE")
 
+And <- ("and" / "AND")
+
+Or <- ("or" / "OR")
+
 ComparisonOperator <- "=" / "!=" / "<" / "<=" / ">" / ">=" {
     return string(c.text), nil
 }
 
-Literal <- FloatLiteral / IntegerLiteral / StringLiteral / BooleanLiteral / ParameterConstant
+Literal <- FloatLiteral / IntegerLiteral / StringLiteral / BooleanLiteral / ParameterConstant / NullConstant
 
 ParameterConstant <- "@" Identifier {
     return parsers.Constant{Type: parsers.ConstantTypeParameterConstant, Value: string(c.text)}, nil
 }
+NullConstant <- "null" {
+    return parsers.Constant{Value: nil}, nil
+}
 
 IntegerLiteral <- number:Integer {
     return parsers.Constant{Type: parsers.ConstantTypeInteger, Value: number.(int)}, nil

query_executors/memory_executor/memory_executor.go

@@ -1,6 +1,8 @@
 package memoryexecutor
 
 import (
+	"fmt"
+
 	"github.com/pikami/cosmium/parsers"
 )
 
@@ -40,10 +42,14 @@ func selectRow(selectItems []parsers.SelectItem, row RowType) interface{} {
 
 	// Construct a new row based on the selected columns
 	newRow := make(map[string]interface{})
-	for _, column := range selectItems {
+	for index, column := range selectItems {
 		destinationName := column.Alias
 		if destinationName == "" {
-			destinationName = column.Path[len(column.Path)-1]
+			if len(column.Path) < 1 {
+				destinationName = fmt.Sprintf("$%d", index+1)
+			} else {
+				destinationName = column.Path[len(column.Path)-1]
+			}
 		}
 
 		newRow[destinationName] = getFieldValue(column, row)
@@ -66,6 +72,8 @@ func evaluateFilters(expr ExpressionType, Parameters map[string]interface{}, row
 		switch typedValue.Operation {
 		case "=":
 			return leftValue == rightValue
+		case "!=":
+			return leftValue != rightValue
 			// Handle other comparison operators as needed
 		}
 	case parsers.LogicalExpression:
@@ -90,6 +98,12 @@ func evaluateFilters(expr ExpressionType, Parameters map[string]interface{}, row
 			}
 		}
 		return result
+	case parsers.Constant:
+		if value, ok := typedValue.Value.(bool); ok {
+			return value
+		}
+		// TODO: Check if we should do something if it is not a boolean constant
+		return false
 	}
 	return false
 }