Added support for query parameters

query_executors/memory_executor/memory_executor.go

@@ -13,7 +13,7 @@ func Execute(query parsers.SelectStmt, data []RowType) []RowType {
 	// Iterate over each row in the data
 	for _, row := range data {
 		// Check if the row satisfies the filter conditions
-		if evaluateFilters(query.Filters, row) {
+		if evaluateFilters(query.Filters, query.Parameters, row) {
 			result = append(result, selectRow(query.SelectItems, row))
 		}
 	}
@@ -53,15 +53,15 @@ func selectRow(selectItems []parsers.SelectItem, row RowType) interface{} {
 }
 
 // Helper function to evaluate filter conditions recursively
-func evaluateFilters(expr ExpressionType, row RowType) bool {
+func evaluateFilters(expr ExpressionType, Parameters map[string]interface{}, row RowType) bool {
 	if expr == nil {
 		return true
 	}
 
 	switch typedValue := expr.(type) {
 	case parsers.ComparisonExpression:
-		leftValue := getExpressionParameterValue(typedValue.Left, row)
-		rightValue := getExpressionParameterValue(typedValue.Right, row)
+		leftValue := getExpressionParameterValue(typedValue.Left, Parameters, row)
+		rightValue := getExpressionParameterValue(typedValue.Right, Parameters, row)
 
 		switch typedValue.Operation {
 		case "=":
@@ -71,7 +71,7 @@ func evaluateFilters(expr ExpressionType, row RowType) bool {
 	case parsers.LogicalExpression:
 		var result bool
 		for i, expression := range typedValue.Expressions {
-			expressionResult := evaluateFilters(expression, row)
+			expressionResult := evaluateFilters(expression, Parameters, row)
 			if i == 0 {
 				result = expressionResult
 			}
@@ -124,11 +124,22 @@ func getFieldValue(field parsers.SelectItem, row RowType) interface{} {
 	return value
 }
 
-func getExpressionParameterValue(parameter interface{}, row RowType) interface{} {
+func getExpressionParameterValue(
+	parameter interface{},
+	Parameters map[string]interface{},
+	row RowType,
+) interface{} {
 	switch typedParameter := parameter.(type) {
 	case parsers.SelectItem:
 		return getFieldValue(typedParameter, row)
 	case parsers.Constant:
+		if typedParameter.Type == parsers.ConstantTypeParameterConstant &&
+			Parameters != nil {
+			if key, ok := typedParameter.Value.(string); ok {
+				return Parameters[key]
+			}
+		}
+
 		return typedParameter.Value
 	}
 	// TODO: Handle error

query_executors/memory_executor/memory_executor_test.go

@@ -175,6 +175,30 @@ func Test_Execute(t *testing.T) {
 		)
 	})
 
+	t.Run("Should execute SELECT with WHERE condition with defined parameter constant", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{Path: []string{"c", "id"}},
+				},
+				Table: parsers.Table{Value: "c"},
+				Filters: parsers.ComparisonExpression{
+					Operation: "=",
+					Left:      parsers.SelectItem{Path: []string{"c", "id"}},
+					Right:     parsers.Constant{Type: parsers.ConstantTypeParameterConstant, Value: "@param_id"},
+				},
+				Parameters: map[string]interface{}{
+					"@param_id": "456",
+				},
+			},
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"id": "456"},
+			},
+		)
+	})
+
 	t.Run("Should execute SELECT with multiple WHERE conditions", func(t *testing.T) {
 		testQueryExecute(
 			t,