Code cleanup; Implement persistant storage; Use maps for storage

query_executors/memory_executor/array_functions.go

@@ -7,17 +7,17 @@ import (
 	"github.com/pikami/cosmium/parsers"
 )
 
-func array_Concat(arguments []interface{}, queryParameters map[string]interface{}, row RowType) []interface{} {
+func (c memoryExecutorContext) array_Concat(arguments []interface{}, row RowType) []interface{} {
 	var result []interface{}
 	for _, arg := range arguments {
-		array := parseArray(arg, queryParameters, row)
+		array := c.parseArray(arg, row)
 		result = append(result, array...)
 	}
 	return result
 }
 
-func array_Length(arguments []interface{}, queryParameters map[string]interface{}, row RowType) int {
-	array := parseArray(arguments[0], queryParameters, row)
+func (c memoryExecutorContext) array_Length(arguments []interface{}, row RowType) int {
+	array := c.parseArray(arguments[0], row)
 	if array == nil {
 		return 0
 	}
@@ -25,15 +25,15 @@ func array_Length(arguments []interface{}, queryParameters map[string]interface{
 	return len(array)
 }
 
-func array_Slice(arguments []interface{}, queryParameters map[string]interface{}, row RowType) []interface{} {
+func (c memoryExecutorContext) array_Slice(arguments []interface{}, row RowType) []interface{} {
 	var ok bool
 	var start int
 	var length int
-	array := parseArray(arguments[0], queryParameters, row)
-	startEx := getFieldValue(arguments[1].(parsers.SelectItem), queryParameters, row)
+	array := c.parseArray(arguments[0], row)
+	startEx := c.getFieldValue(arguments[1].(parsers.SelectItem), row)
 
 	if arguments[2] != nil {
-		lengthEx := getFieldValue(arguments[2].(parsers.SelectItem), queryParameters, row)
+		lengthEx := c.getFieldValue(arguments[2].(parsers.SelectItem), row)
 
 		if length, ok = lengthEx.(int); !ok {
 			fmt.Println("array_Slice - got length parameters of wrong type")
@@ -65,9 +65,9 @@ func array_Slice(arguments []interface{}, queryParameters map[string]interface{}
 	return array[start:end]
 }
 
-func set_Intersect(arguments []interface{}, queryParameters map[string]interface{}, row RowType) []interface{} {
-	set1 := parseArray(arguments[0], queryParameters, row)
-	set2 := parseArray(arguments[1], queryParameters, row)
+func (c memoryExecutorContext) set_Intersect(arguments []interface{}, row RowType) []interface{} {
+	set1 := c.parseArray(arguments[0], row)
+	set2 := c.parseArray(arguments[1], row)
 
 	intersection := make(map[interface{}]struct{})
 	if set1 == nil || set2 == nil {
@@ -88,9 +88,9 @@ func set_Intersect(arguments []interface{}, queryParameters map[string]interface
 	return result
 }
 
-func set_Union(arguments []interface{}, queryParameters map[string]interface{}, row RowType) []interface{} {
-	set1 := parseArray(arguments[0], queryParameters, row)
-	set2 := parseArray(arguments[1], queryParameters, row)
+func (c memoryExecutorContext) set_Union(arguments []interface{}, row RowType) []interface{} {
+	set1 := c.parseArray(arguments[0], row)
+	set2 := c.parseArray(arguments[1], row)
 
 	var result []interface{}
 	union := make(map[interface{}]struct{})
@@ -111,9 +111,9 @@ func set_Union(arguments []interface{}, queryParameters map[string]interface{},
 	return result
 }
 
-func parseArray(argument interface{}, queryParameters map[string]interface{}, row RowType) []interface{} {
+func (c memoryExecutorContext) parseArray(argument interface{}, row RowType) []interface{} {
 	exItem := argument.(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
+	ex := c.getFieldValue(exItem, row)
 
 	arrValue := reflect.ValueOf(ex)
 	if arrValue.Kind() != reflect.Slice {

query_executors/memory_executor/memory_executor.go

@@ -12,19 +12,27 @@ import (
 type RowType interface{}
 type ExpressionType interface{}
 
+type memoryExecutorContext struct {
+	parameters map[string]interface{}
+}
+
 func Execute(query parsers.SelectStmt, data []RowType) []RowType {
+	ctx := memoryExecutorContext{
+		parameters: query.Parameters,
+	}
+
 	result := make([]RowType, 0)
 
 	// Apply Filter
 	for _, row := range data {
-		if evaluateFilters(query.Filters, query.Parameters, row) {
+		if ctx.evaluateFilters(query.Filters, row) {
 			result = append(result, row)
 		}
 	}
 
 	// Apply order
 	if query.OrderExpressions != nil && len(query.OrderExpressions) > 0 {
-		orderBy(query.OrderExpressions, query.Parameters, result)
+		ctx.orderBy(query.OrderExpressions, result)
 	}
 
 	// Apply result limit
@@ -41,16 +49,16 @@ func Execute(query parsers.SelectStmt, data []RowType) []RowType {
 	// Apply select
 	selectedData := make([]RowType, 0)
 	for _, row := range result {
-		selectedData = append(selectedData, selectRow(query.SelectItems, query.Parameters, row))
+		selectedData = append(selectedData, ctx.selectRow(query.SelectItems, row))
 	}
 
 	return selectedData
 }
 
-func selectRow(selectItems []parsers.SelectItem, queryParameters map[string]interface{}, row RowType) interface{} {
+func (c memoryExecutorContext) selectRow(selectItems []parsers.SelectItem, row RowType) interface{} {
 	// When the first value is top level, select it instead
 	if len(selectItems) > 0 && selectItems[0].IsTopLevel {
-		return getFieldValue(selectItems[0], queryParameters, row)
+		return c.getFieldValue(selectItems[0], row)
 	}
 
 	// Construct a new row based on the selected columns
@@ -65,21 +73,21 @@ func selectRow(selectItems []parsers.SelectItem, queryParameters map[string]inte
 			}
 		}
 
-		newRow[destinationName] = getFieldValue(column, queryParameters, row)
+		newRow[destinationName] = c.getFieldValue(column, row)
 	}
 
 	return newRow
 }
 
-func evaluateFilters(expr ExpressionType, queryParameters map[string]interface{}, row RowType) bool {
+func (c memoryExecutorContext) evaluateFilters(expr ExpressionType, row RowType) bool {
 	if expr == nil {
 		return true
 	}
 
 	switch typedValue := expr.(type) {
 	case parsers.ComparisonExpression:
-		leftValue := getExpressionParameterValue(typedValue.Left, queryParameters, row)
-		rightValue := getExpressionParameterValue(typedValue.Right, queryParameters, row)
+		leftValue := c.getExpressionParameterValue(typedValue.Left, row)
+		rightValue := c.getExpressionParameterValue(typedValue.Right, row)
 
 		cmp := compareValues(leftValue, rightValue)
 		switch typedValue.Operation {
@@ -99,7 +107,7 @@ func evaluateFilters(expr ExpressionType, queryParameters map[string]interface{}
 	case parsers.LogicalExpression:
 		var result bool
 		for i, expression := range typedValue.Expressions {
-			expressionResult := evaluateFilters(expression, queryParameters, row)
+			expressionResult := c.evaluateFilters(expression, row)
 			if i == 0 {
 				result = expressionResult
 			}
@@ -124,7 +132,7 @@ func evaluateFilters(expr ExpressionType, queryParameters map[string]interface{}
 		}
 		return false
 	case parsers.SelectItem:
-		resolvedValue := getFieldValue(typedValue, queryParameters, row)
+		resolvedValue := c.getFieldValue(typedValue, row)
 		if value, ok := resolvedValue.(bool); ok {
 			return value
 		}
@@ -132,11 +140,11 @@ func evaluateFilters(expr ExpressionType, queryParameters map[string]interface{}
 	return false
 }
 
-func getFieldValue(field parsers.SelectItem, queryParameters map[string]interface{}, row RowType) interface{} {
+func (c memoryExecutorContext) getFieldValue(field parsers.SelectItem, row RowType) interface{} {
 	if field.Type == parsers.SelectItemTypeArray {
 		arrayValue := make([]interface{}, 0)
 		for _, selectItem := range field.SelectItems {
-			arrayValue = append(arrayValue, getFieldValue(selectItem, queryParameters, row))
+			arrayValue = append(arrayValue, c.getFieldValue(selectItem, row))
 		}
 		return arrayValue
 	}
@@ -144,7 +152,7 @@ func getFieldValue(field parsers.SelectItem, queryParameters map[string]interfac
 	if field.Type == parsers.SelectItemTypeObject {
 		objectValue := make(map[string]interface{})
 		for _, selectItem := range field.SelectItems {
-			objectValue[selectItem.Alias] = getFieldValue(selectItem, queryParameters, row)
+			objectValue[selectItem.Alias] = c.getFieldValue(selectItem, row)
 		}
 		return objectValue
 	}
@@ -158,9 +166,9 @@ func getFieldValue(field parsers.SelectItem, queryParameters map[string]interfac
 		}
 
 		if typedValue.Type == parsers.ConstantTypeParameterConstant &&
-			queryParameters != nil {
+			c.parameters != nil {
 			if key, ok := typedValue.Value.(string); ok {
-				return queryParameters[key]
+				return c.parameters[key]
 			}
 		}
 
@@ -177,78 +185,78 @@ func getFieldValue(field parsers.SelectItem, queryParameters map[string]interfac
 
 		switch typedValue.Type {
 		case parsers.FunctionCallStringEquals:
-			return strings_StringEquals(typedValue.Arguments, queryParameters, row)
+			return c.strings_StringEquals(typedValue.Arguments, row)
 		case parsers.FunctionCallContains:
-			return strings_Contains(typedValue.Arguments, queryParameters, row)
+			return c.strings_Contains(typedValue.Arguments, row)
 		case parsers.FunctionCallEndsWith:
-			return strings_EndsWith(typedValue.Arguments, queryParameters, row)
+			return c.strings_EndsWith(typedValue.Arguments, row)
 		case parsers.FunctionCallStartsWith:
-			return strings_StartsWith(typedValue.Arguments, queryParameters, row)
+			return c.strings_StartsWith(typedValue.Arguments, row)
 		case parsers.FunctionCallConcat:
-			return strings_Concat(typedValue.Arguments, queryParameters, row)
+			return c.strings_Concat(typedValue.Arguments, row)
 		case parsers.FunctionCallIndexOf:
-			return strings_IndexOf(typedValue.Arguments, queryParameters, row)
+			return c.strings_IndexOf(typedValue.Arguments, row)
 		case parsers.FunctionCallToString:
-			return strings_ToString(typedValue.Arguments, queryParameters, row)
+			return c.strings_ToString(typedValue.Arguments, row)
 		case parsers.FunctionCallUpper:
-			return strings_Upper(typedValue.Arguments, queryParameters, row)
+			return c.strings_Upper(typedValue.Arguments, row)
 		case parsers.FunctionCallLower:
-			return strings_Lower(typedValue.Arguments, queryParameters, row)
+			return c.strings_Lower(typedValue.Arguments, row)
 		case parsers.FunctionCallLeft:
-			return strings_Left(typedValue.Arguments, queryParameters, row)
+			return c.strings_Left(typedValue.Arguments, row)
 		case parsers.FunctionCallLength:
-			return strings_Length(typedValue.Arguments, queryParameters, row)
+			return c.strings_Length(typedValue.Arguments, row)
 		case parsers.FunctionCallLTrim:
-			return strings_LTrim(typedValue.Arguments, queryParameters, row)
+			return c.strings_LTrim(typedValue.Arguments, row)
 		case parsers.FunctionCallReplace:
-			return strings_Replace(typedValue.Arguments, queryParameters, row)
+			return c.strings_Replace(typedValue.Arguments, row)
 		case parsers.FunctionCallReplicate:
-			return strings_Replicate(typedValue.Arguments, queryParameters, row)
+			return c.strings_Replicate(typedValue.Arguments, row)
 		case parsers.FunctionCallReverse:
-			return strings_Reverse(typedValue.Arguments, queryParameters, row)
+			return c.strings_Reverse(typedValue.Arguments, row)
 		case parsers.FunctionCallRight:
-			return strings_Right(typedValue.Arguments, queryParameters, row)
+			return c.strings_Right(typedValue.Arguments, row)
 		case parsers.FunctionCallRTrim:
-			return strings_RTrim(typedValue.Arguments, queryParameters, row)
+			return c.strings_RTrim(typedValue.Arguments, row)
 		case parsers.FunctionCallSubstring:
-			return strings_Substring(typedValue.Arguments, queryParameters, row)
+			return c.strings_Substring(typedValue.Arguments, row)
 		case parsers.FunctionCallTrim:
-			return strings_Trim(typedValue.Arguments, queryParameters, row)
+			return c.strings_Trim(typedValue.Arguments, row)
 
 		case parsers.FunctionCallIsDefined:
-			return typeChecking_IsDefined(typedValue.Arguments, queryParameters, row)
+			return c.typeChecking_IsDefined(typedValue.Arguments, row)
 		case parsers.FunctionCallIsArray:
-			return typeChecking_IsArray(typedValue.Arguments, queryParameters, row)
+			return c.typeChecking_IsArray(typedValue.Arguments, row)
 		case parsers.FunctionCallIsBool:
-			return typeChecking_IsBool(typedValue.Arguments, queryParameters, row)
+			return c.typeChecking_IsBool(typedValue.Arguments, row)
 		case parsers.FunctionCallIsFiniteNumber:
-			return typeChecking_IsFiniteNumber(typedValue.Arguments, queryParameters, row)
+			return c.typeChecking_IsFiniteNumber(typedValue.Arguments, row)
 		case parsers.FunctionCallIsInteger:
-			return typeChecking_IsInteger(typedValue.Arguments, queryParameters, row)
+			return c.typeChecking_IsInteger(typedValue.Arguments, row)
 		case parsers.FunctionCallIsNull:
-			return typeChecking_IsNull(typedValue.Arguments, queryParameters, row)
+			return c.typeChecking_IsNull(typedValue.Arguments, row)
 		case parsers.FunctionCallIsNumber:
-			return typeChecking_IsNumber(typedValue.Arguments, queryParameters, row)
+			return c.typeChecking_IsNumber(typedValue.Arguments, row)
 		case parsers.FunctionCallIsObject:
-			return typeChecking_IsObject(typedValue.Arguments, queryParameters, row)
+			return c.typeChecking_IsObject(typedValue.Arguments, row)
 		case parsers.FunctionCallIsPrimitive:
-			return typeChecking_IsPrimitive(typedValue.Arguments, queryParameters, row)
+			return c.typeChecking_IsPrimitive(typedValue.Arguments, row)
 		case parsers.FunctionCallIsString:
-			return typeChecking_IsString(typedValue.Arguments, queryParameters, row)
+			return c.typeChecking_IsString(typedValue.Arguments, row)
 
 		case parsers.FunctionCallArrayConcat:
-			return array_Concat(typedValue.Arguments, queryParameters, row)
+			return c.array_Concat(typedValue.Arguments, row)
 		case parsers.FunctionCallArrayLength:
-			return array_Length(typedValue.Arguments, queryParameters, row)
+			return c.array_Length(typedValue.Arguments, row)
 		case parsers.FunctionCallArraySlice:
-			return array_Slice(typedValue.Arguments, queryParameters, row)
+			return c.array_Slice(typedValue.Arguments, row)
 		case parsers.FunctionCallSetIntersect:
-			return set_Intersect(typedValue.Arguments, queryParameters, row)
+			return c.set_Intersect(typedValue.Arguments, row)
 		case parsers.FunctionCallSetUnion:
-			return set_Union(typedValue.Arguments, queryParameters, row)
+			return c.set_Union(typedValue.Arguments, row)
 
 		case parsers.FunctionCallIn:
-			return misc_In(typedValue.Arguments, queryParameters, row)
+			return c.misc_In(typedValue.Arguments, row)
 		}
 	}
 
@@ -265,14 +273,13 @@ func getFieldValue(field parsers.SelectItem, queryParameters map[string]interfac
 	return value
 }
 
-func getExpressionParameterValue(
+func (c memoryExecutorContext) getExpressionParameterValue(
 	parameter interface{},
-	queryParameters map[string]interface{},
 	row RowType,
 ) interface{} {
 	switch typedParameter := parameter.(type) {
 	case parsers.SelectItem:
-		return getFieldValue(typedParameter, queryParameters, row)
+		return c.getFieldValue(typedParameter, row)
 	}
 
 	fmt.Println("getExpressionParameterValue - got incorrect parameter type")
@@ -280,11 +287,11 @@ func getExpressionParameterValue(
 	return nil
 }
 
-func orderBy(orderBy []parsers.OrderExpression, queryParameters map[string]interface{}, data []RowType) {
+func (c memoryExecutorContext) orderBy(orderBy []parsers.OrderExpression, data []RowType) {
 	less := func(i, j int) bool {
 		for _, order := range orderBy {
-			val1 := getFieldValue(order.SelectItem, queryParameters, data[i])
-			val2 := getFieldValue(order.SelectItem, queryParameters, data[j])
+			val1 := c.getFieldValue(order.SelectItem, data[i])
+			val2 := c.getFieldValue(order.SelectItem, data[j])
 
 			cmp := compareValues(val1, val2)
 			if cmp != 0 {

query_executors/memory_executor/memory_executor_type_checking_functions.go

@@ -1,96 +0,0 @@
-package memoryexecutor
-
-import (
-	"math"
-
-	"github.com/pikami/cosmium/parsers"
-)
-
-func typeChecking_IsDefined(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	exItem := arguments[0].(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
-
-	return ex != nil
-}
-
-func typeChecking_IsArray(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	exItem := arguments[0].(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
-
-	_, isArray := ex.([]interface{})
-	return isArray
-}
-
-func typeChecking_IsBool(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	exItem := arguments[0].(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
-
-	_, isBool := ex.(bool)
-	return isBool
-}
-
-func typeChecking_IsFiniteNumber(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	exItem := arguments[0].(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
-
-	switch num := ex.(type) {
-	case int:
-		return true
-	case float64:
-		return !math.IsInf(num, 0) && !math.IsNaN(num)
-	default:
-		return false
-	}
-}
-
-func typeChecking_IsInteger(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	exItem := arguments[0].(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
-
-	_, isInt := ex.(int)
-	return isInt
-}
-
-func typeChecking_IsNull(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	exItem := arguments[0].(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
-
-	return ex == nil
-}
-
-func typeChecking_IsNumber(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	exItem := arguments[0].(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
-
-	_, isFloat := ex.(float64)
-	_, isInt := ex.(int)
-	return isFloat || isInt
-}
-
-func typeChecking_IsObject(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	exItem := arguments[0].(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
-
-	_, isObject := ex.(map[string]interface{})
-	return isObject
-}
-
-func typeChecking_IsPrimitive(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	exItem := arguments[0].(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
-
-	switch ex.(type) {
-	case bool, string, float64, int, nil:
-		return true
-	default:
-		return false
-	}
-}
-
-func typeChecking_IsString(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	exItem := arguments[0].(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
-
-	_, isStr := ex.(string)
-	return isStr
-}

query_executors/memory_executor/misc_functions.go

@@ -4,11 +4,11 @@ import (
 	"github.com/pikami/cosmium/parsers"
 )
 
-func misc_In(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	value := getFieldValue(arguments[0].(parsers.SelectItem), queryParameters, row)
+func (c memoryExecutorContext) misc_In(arguments []interface{}, row RowType) bool {
+	value := c.getFieldValue(arguments[0].(parsers.SelectItem), row)
 
 	for i := 1; i < len(arguments); i++ {
-		compareValue := getFieldValue(arguments[i].(parsers.SelectItem), queryParameters, row)
+		compareValue := c.getFieldValue(arguments[i].(parsers.SelectItem), row)
 		if compareValues(value, compareValue) == 0 {
 			return true
 		}

query_executors/memory_executor/string_functions.go

@@ -7,10 +7,10 @@ import (
 	"github.com/pikami/cosmium/parsers"
 )
 
-func strings_StringEquals(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	str1 := parseString(arguments[0], queryParameters, row)
-	str2 := parseString(arguments[1], queryParameters, row)
-	ignoreCase := getBoolFlag(arguments, queryParameters, row)
+func (c memoryExecutorContext) strings_StringEquals(arguments []interface{}, row RowType) bool {
+	str1 := c.parseString(arguments[0], row)
+	str2 := c.parseString(arguments[1], row)
+	ignoreCase := c.getBoolFlag(arguments, row)
 
 	if ignoreCase {
 		return strings.EqualFold(str1, str2)
@@ -19,10 +19,10 @@ func strings_StringEquals(arguments []interface{}, queryParameters map[string]in
 	return str1 == str2
 }
 
-func strings_Contains(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	str1 := parseString(arguments[0], queryParameters, row)
-	str2 := parseString(arguments[1], queryParameters, row)
-	ignoreCase := getBoolFlag(arguments, queryParameters, row)
+func (c memoryExecutorContext) strings_Contains(arguments []interface{}, row RowType) bool {
+	str1 := c.parseString(arguments[0], row)
+	str2 := c.parseString(arguments[1], row)
+	ignoreCase := c.getBoolFlag(arguments, row)
 
 	if ignoreCase {
 		str1 = strings.ToLower(str1)
@@ -32,10 +32,10 @@ func strings_Contains(arguments []interface{}, queryParameters map[string]interf
 	return strings.Contains(str1, str2)
 }
 
-func strings_EndsWith(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	str1 := parseString(arguments[0], queryParameters, row)
-	str2 := parseString(arguments[1], queryParameters, row)
-	ignoreCase := getBoolFlag(arguments, queryParameters, row)
+func (c memoryExecutorContext) strings_EndsWith(arguments []interface{}, row RowType) bool {
+	str1 := c.parseString(arguments[0], row)
+	str2 := c.parseString(arguments[1], row)
+	ignoreCase := c.getBoolFlag(arguments, row)
 
 	if ignoreCase {
 		str1 = strings.ToLower(str1)
@@ -45,10 +45,10 @@ func strings_EndsWith(arguments []interface{}, queryParameters map[string]interf
 	return strings.HasSuffix(str1, str2)
 }
 
-func strings_StartsWith(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
-	str1 := parseString(arguments[0], queryParameters, row)
-	str2 := parseString(arguments[1], queryParameters, row)
-	ignoreCase := getBoolFlag(arguments, queryParameters, row)
+func (c memoryExecutorContext) strings_StartsWith(arguments []interface{}, row RowType) bool {
+	str1 := c.parseString(arguments[0], row)
+	str2 := c.parseString(arguments[1], row)
+	ignoreCase := c.getBoolFlag(arguments, row)
 
 	if ignoreCase {
 		str1 = strings.ToLower(str1)
@@ -58,12 +58,12 @@ func strings_StartsWith(arguments []interface{}, queryParameters map[string]inte
 	return strings.HasPrefix(str1, str2)
 }
 
-func strings_Concat(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
+func (c memoryExecutorContext) strings_Concat(arguments []interface{}, row RowType) string {
 	result := ""
 
 	for _, arg := range arguments {
 		if selectItem, ok := arg.(parsers.SelectItem); ok {
-			value := getFieldValue(selectItem, queryParameters, row)
+			value := c.getFieldValue(selectItem, row)
 			result += convertToString(value)
 		}
 	}
@@ -71,13 +71,13 @@ func strings_Concat(arguments []interface{}, queryParameters map[string]interfac
 	return result
 }
 
-func strings_IndexOf(arguments []interface{}, queryParameters map[string]interface{}, row RowType) int {
-	str1 := parseString(arguments[0], queryParameters, row)
-	str2 := parseString(arguments[1], queryParameters, row)
+func (c memoryExecutorContext) strings_IndexOf(arguments []interface{}, row RowType) int {
+	str1 := c.parseString(arguments[0], row)
+	str2 := c.parseString(arguments[1], row)
 
 	start := 0
 	if len(arguments) > 2 && arguments[2] != nil {
-		if startPos, ok := getFieldValue(arguments[2].(parsers.SelectItem), queryParameters, row).(int); ok {
+		if startPos, ok := c.getFieldValue(arguments[2].(parsers.SelectItem), row).(int); ok {
 			start = startPos
 		}
 	}
@@ -96,26 +96,26 @@ func strings_IndexOf(arguments []interface{}, queryParameters map[string]interfa
 	}
 }
 
-func strings_ToString(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
-	value := getFieldValue(arguments[0].(parsers.SelectItem), queryParameters, row)
+func (c memoryExecutorContext) strings_ToString(arguments []interface{}, row RowType) string {
+	value := c.getFieldValue(arguments[0].(parsers.SelectItem), row)
 	return convertToString(value)
 }
 
-func strings_Upper(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
-	value := getFieldValue(arguments[0].(parsers.SelectItem), queryParameters, row)
+func (c memoryExecutorContext) strings_Upper(arguments []interface{}, row RowType) string {
+	value := c.getFieldValue(arguments[0].(parsers.SelectItem), row)
 	return strings.ToUpper(convertToString(value))
 }
 
-func strings_Lower(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
-	value := getFieldValue(arguments[0].(parsers.SelectItem), queryParameters, row)
+func (c memoryExecutorContext) strings_Lower(arguments []interface{}, row RowType) string {
+	value := c.getFieldValue(arguments[0].(parsers.SelectItem), row)
 	return strings.ToLower(convertToString(value))
 }
 
-func strings_Left(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
+func (c memoryExecutorContext) strings_Left(arguments []interface{}, row RowType) string {
 	var ok bool
 	var length int
-	str := parseString(arguments[0], queryParameters, row)
-	lengthEx := getFieldValue(arguments[1].(parsers.SelectItem), queryParameters, row)
+	str := c.parseString(arguments[0], row)
+	lengthEx := c.getFieldValue(arguments[1].(parsers.SelectItem), row)
 
 	if length, ok = lengthEx.(int); !ok {
 		fmt.Println("strings_Left - got parameters of wrong type")
@@ -133,28 +133,28 @@ func strings_Left(arguments []interface{}, queryParameters map[string]interface{
 	return str[:length]
 }
 
-func strings_Length(arguments []interface{}, queryParameters map[string]interface{}, row RowType) int {
-	str := parseString(arguments[0], queryParameters, row)
+func (c memoryExecutorContext) strings_Length(arguments []interface{}, row RowType) int {
+	str := c.parseString(arguments[0], row)
 	return len(str)
 }
 
-func strings_LTrim(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
-	str := parseString(arguments[0], queryParameters, row)
+func (c memoryExecutorContext) strings_LTrim(arguments []interface{}, row RowType) string {
+	str := c.parseString(arguments[0], row)
 	return strings.TrimLeft(str, " ")
 }
 
-func strings_Replace(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
-	str := parseString(arguments[0], queryParameters, row)
-	oldStr := parseString(arguments[1], queryParameters, row)
-	newStr := parseString(arguments[2], queryParameters, row)
+func (c memoryExecutorContext) strings_Replace(arguments []interface{}, row RowType) string {
+	str := c.parseString(arguments[0], row)
+	oldStr := c.parseString(arguments[1], row)
+	newStr := c.parseString(arguments[2], row)
 	return strings.Replace(str, oldStr, newStr, -1)
 }
 
-func strings_Replicate(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
+func (c memoryExecutorContext) strings_Replicate(arguments []interface{}, row RowType) string {
 	var ok bool
 	var times int
-	str := parseString(arguments[0], queryParameters, row)
-	timesEx := getFieldValue(arguments[1].(parsers.SelectItem), queryParameters, row)
+	str := c.parseString(arguments[0], row)
+	timesEx := c.getFieldValue(arguments[1].(parsers.SelectItem), row)
 
 	if times, ok = timesEx.(int); !ok {
 		fmt.Println("strings_Replicate - got parameters of wrong type")
@@ -172,8 +172,8 @@ func strings_Replicate(arguments []interface{}, queryParameters map[string]inter
 	return strings.Repeat(str, times)
 }
 
-func strings_Reverse(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
-	str := parseString(arguments[0], queryParameters, row)
+func (c memoryExecutorContext) strings_Reverse(arguments []interface{}, row RowType) string {
+	str := c.parseString(arguments[0], row)
 	runes := []rune(str)
 
 	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
@@ -183,11 +183,11 @@ func strings_Reverse(arguments []interface{}, queryParameters map[string]interfa
 	return string(runes)
 }
 
-func strings_Right(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
+func (c memoryExecutorContext) strings_Right(arguments []interface{}, row RowType) string {
 	var ok bool
 	var length int
-	str := parseString(arguments[0], queryParameters, row)
-	lengthEx := getFieldValue(arguments[1].(parsers.SelectItem), queryParameters, row)
+	str := c.parseString(arguments[0], row)
+	lengthEx := c.getFieldValue(arguments[1].(parsers.SelectItem), row)
 
 	if length, ok = lengthEx.(int); !ok {
 		fmt.Println("strings_Right - got parameters of wrong type")
@@ -205,18 +205,18 @@ func strings_Right(arguments []interface{}, queryParameters map[string]interface
 	return str[len(str)-length:]
 }
 
-func strings_RTrim(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
-	str := parseString(arguments[0], queryParameters, row)
+func (c memoryExecutorContext) strings_RTrim(arguments []interface{}, row RowType) string {
+	str := c.parseString(arguments[0], row)
 	return strings.TrimRight(str, " ")
 }
 
-func strings_Substring(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
+func (c memoryExecutorContext) strings_Substring(arguments []interface{}, row RowType) string {
 	var ok bool
 	var startPos int
 	var length int
-	str := parseString(arguments[0], queryParameters, row)
-	startPosEx := getFieldValue(arguments[1].(parsers.SelectItem), queryParameters, row)
-	lengthEx := getFieldValue(arguments[2].(parsers.SelectItem), queryParameters, row)
+	str := c.parseString(arguments[0], row)
+	startPosEx := c.getFieldValue(arguments[1].(parsers.SelectItem), row)
+	lengthEx := c.getFieldValue(arguments[2].(parsers.SelectItem), row)
 
 	if startPos, ok = startPosEx.(int); !ok {
 		fmt.Println("strings_Substring - got start parameters of wrong type")
@@ -239,16 +239,16 @@ func strings_Substring(arguments []interface{}, queryParameters map[string]inter
 	return str[startPos:endPos]
 }
 
-func strings_Trim(arguments []interface{}, queryParameters map[string]interface{}, row RowType) string {
-	str := parseString(arguments[0], queryParameters, row)
+func (c memoryExecutorContext) strings_Trim(arguments []interface{}, row RowType) string {
+	str := c.parseString(arguments[0], row)
 	return strings.TrimSpace(str)
 }
 
-func getBoolFlag(arguments []interface{}, queryParameters map[string]interface{}, row RowType) bool {
+func (c memoryExecutorContext) getBoolFlag(arguments []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 {
+		if value, ok := c.getFieldValue(ignoreCaseItem, row).(bool); ok {
 			ignoreCase = value
 		}
 	}
@@ -256,9 +256,9 @@ func getBoolFlag(arguments []interface{}, queryParameters map[string]interface{}
 	return ignoreCase
 }
 
-func parseString(argument interface{}, queryParameters map[string]interface{}, row RowType) string {
+func (c memoryExecutorContext) parseString(argument interface{}, row RowType) string {
 	exItem := argument.(parsers.SelectItem)
-	ex := getFieldValue(exItem, queryParameters, row)
+	ex := c.getFieldValue(exItem, row)
 	if str1, ok := ex.(string); ok {
 		return str1
 	}

query_executors/memory_executor/type_checking_functions.go

@@ -0,0 +1,96 @@
+package memoryexecutor
+
+import (
+	"math"
+
+	"github.com/pikami/cosmium/parsers"
+)
+
+func (c memoryExecutorContext) typeChecking_IsDefined(arguments []interface{}, row RowType) bool {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	return ex != nil
+}
+
+func (c memoryExecutorContext) typeChecking_IsArray(arguments []interface{}, row RowType) bool {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	_, isArray := ex.([]interface{})
+	return isArray
+}
+
+func (c memoryExecutorContext) typeChecking_IsBool(arguments []interface{}, row RowType) bool {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	_, isBool := ex.(bool)
+	return isBool
+}
+
+func (c memoryExecutorContext) typeChecking_IsFiniteNumber(arguments []interface{}, row RowType) bool {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	switch num := ex.(type) {
+	case int:
+		return true
+	case float64:
+		return !math.IsInf(num, 0) && !math.IsNaN(num)
+	default:
+		return false
+	}
+}
+
+func (c memoryExecutorContext) typeChecking_IsInteger(arguments []interface{}, row RowType) bool {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	_, isInt := ex.(int)
+	return isInt
+}
+
+func (c memoryExecutorContext) typeChecking_IsNull(arguments []interface{}, row RowType) bool {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	return ex == nil
+}
+
+func (c memoryExecutorContext) typeChecking_IsNumber(arguments []interface{}, row RowType) bool {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	_, isFloat := ex.(float64)
+	_, isInt := ex.(int)
+	return isFloat || isInt
+}
+
+func (c memoryExecutorContext) typeChecking_IsObject(arguments []interface{}, row RowType) bool {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	_, isObject := ex.(map[string]interface{})
+	return isObject
+}
+
+func (c memoryExecutorContext) typeChecking_IsPrimitive(arguments []interface{}, row RowType) bool {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	switch ex.(type) {
+	case bool, string, float64, int, nil:
+		return true
+	default:
+		return false
+	}
+}
+
+func (c memoryExecutorContext) typeChecking_IsString(arguments []interface{}, row RowType) bool {
+	exItem := arguments[0].(parsers.SelectItem)
+	ex := c.getFieldValue(exItem, row)
+
+	_, isStr := ex.(string)
+	return isStr
+}