Implement CONTAINS function

query_executors/memory_executor/memory_executor.go

@@ -178,10 +178,12 @@ func getFieldValue(field parsers.SelectItem, queryParameters map[string]interfac
 		switch typedValue.Type {
 		case parsers.FunctionCallStringEquals:
 			return strings_StringEquals(typedValue.Arguments, queryParameters, row)
-		case parsers.FunctionCallIsDefined:
-			return typeChecking_IsDefined(typedValue.Arguments, queryParameters, row)
+		case parsers.FunctionCallContains:
+			return strings_Contains(typedValue.Arguments, queryParameters, row)
 		case parsers.FunctionCallConcat:
 			return strings_Concat(typedValue.Arguments, queryParameters, row)
+		case parsers.FunctionCallIsDefined:
+			return typeChecking_IsDefined(typedValue.Arguments, queryParameters, row)
 		}
 	}
 

query_executors/memory_executor/memory_executor_string_functions_test.go

@@ -151,4 +151,52 @@ func Test_Execute_StringFunctions(t *testing.T) {
 			},
 		)
 	})
+
+	t.Run("Should execute function CONTAINS()", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Path: []string{"c", "id"},
+						Type: parsers.SelectItemTypeField,
+					},
+					{
+						Alias: "contains",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallContains,
+							Arguments: []interface{}{
+								parsers.SelectItem{
+									Path: []string{"c", "id"},
+									Type: parsers.SelectItemTypeField,
+								},
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeString,
+										Value: "2",
+									},
+								},
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeBoolean,
+										Value: true,
+									},
+								},
+							},
+						},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
+			},
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"id": "123", "contains": true},
+				map[string]interface{}{"id": "456", "contains": false},
+				map[string]interface{}{"id": "789", "contains": false},
+			},
+		)
+	})
 }

query_executors/memory_executor/string_functions.go

@@ -40,6 +40,40 @@ func strings_StringEquals(arguments []interface{}, queryParameters map[string]in
 	return str1 == str2
 }
 
+func strings_Contains(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
+	ignoreCase := false
+	if len(arguments) > 2 && arguments[2] != nil {
+		ignoreCaseItem := arguments[2].(parsers.SelectItem)
+		if value, ok := getFieldValue(ignoreCaseItem, queryParameters, row).(bool); ok {
+			ignoreCase = value
+		}
+	}
+
+	ex1Item := arguments[0].(parsers.SelectItem)
+	ex2Item := arguments[1].(parsers.SelectItem)
+
+	ex1 := getFieldValue(ex1Item, queryParameters, row)
+	ex2 := getFieldValue(ex2Item, queryParameters, row)
+
+	var ok bool
+	var str1 string
+	var str2 string
+
+	if str1, ok = ex1.(string); !ok {
+		fmt.Println("StringEquals got parameters of wrong type")
+	}
+	if str2, ok = ex2.(string); !ok {
+		fmt.Println("StringEquals got parameters of wrong type")
+	}
+
+	if ignoreCase {
+		str1 = strings.ToLower(str1)
+		str2 = strings.ToLower(str2)
+	}
+
+	return strings.Contains(str1, str2)
+}
+
 func strings_Concat(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
 	result := ""