## Varius tests related to overlaps operator

## 1. Using 'overlaps' operator with literals
## 1.1 with literal array
## 1.2 with literal object
## 2. Using 'overlaps' operator with idetifiers
## 2.1 with document member array
## 2.1 with document member object
## 3. Using 'overlaps' operator with operators
## 4. Using 'overlaps' operator with function calls
## 5. Validating number of 'overlaps' arguments


## Preamble
--source include/xplugin_preamble.inc
--source include/xplugin_create_user.inc


## Test starts here
--let $xtest_file= $MYSQL_TMP_DIR/crud_overlaps_expr.xpl
--write_file $xtest_file
-->quiet


-->macro Error_on_overlaps  %PARAM0%  %PARAM1%  %ERROR%
Mysqlx.Crud.Find {
  collection { name: "xtable" schema: "xtest" }
  data_model: TABLE
  projection {
    alias: "overlaps"
    source {
      type: OPERATOR operator {
        name: "overlaps"
        param { %PARAM0% }
        param { %PARAM1% }
      }
    }
  }
}
-->expecterror %ERROR%
-->recvresult
-->endmacro

-->macro Assert_overlaps  %OPERATOR%  %PARAM0%  %PARAM1%  %EXPECT%
Mysqlx.Crud.Find {
  collection { name: "xtable" schema: "xtest" }
  data_model: TABLE
  projection {
    alias: "%OPERATOR%"
    source {
      type: OPERATOR operator {
        name: "%OPERATOR%"
        param { %PARAM0% }
        param { %PARAM1% }
      }
    }
  }
}
-->recvtovar %OPERATOR_RESULT% %OPERATOR%
-->echo Verify [Operator "%OPERATOR%" returns value %EXPECT%]
-->assert_eq %EXPECT%	%OPERATOR_RESULT%
-->endmacro


-->macro Overlaps_positive  %POSITIVE%  %WHERE%
-->callmacro Assert_overlaps	overlaps	%POSITIVE%	%WHERE%	1
-->callmacro Assert_overlaps	not_overlaps	%POSITIVE%	%WHERE%	0
-->endmacro

-->macro Overlaps_negative  %NEGATIVE%  %WHERE%
-->callmacro Assert_overlaps	overlaps	%NEGATIVE%	%WHERE%	0
-->callmacro Assert_overlaps	not_overlaps	%NEGATIVE%	%WHERE%	1
-->endmacro


-->varlet %LITERAL% type: LITERAL literal
-->varlet %V_SINT% type: V_SINT v_signed_int
-->varlet %V_BOOL% type: V_BOOL v_bool
-->varlet %V_STRING% type: V_STRING v_string
-->varlet %V_FLOAT% type: V_FLOAT v_float
-->varlet %V_OCTETS% type: V_OCTETS v_octets
-->varlet %ARRAY% type: ARRAY array
-->varlet %IDENT% type: IDENT identifier
-->varlet %MEMBER% type: MEMBER value
-->varlet %OBJECT% type: OBJECT object
-->varlet %OPERATOR% type: OPERATOR operator
-->varlet %FUNC_CALL% type: FUNC_CALL function_call
-->varlet %DOCUMENT_PATH% name: 'doc' document_path


-->varlet %LITERAL_10% %LITERAL% {%V_SINT%: 10}
-->varlet %LITERAL_20% %LITERAL% {%V_SINT%: 20}
-->varlet %LITERAL_30% %LITERAL% {%V_SINT%: 30}
-->varlet %LITERAL_40% %LITERAL% {%V_SINT%: 40}

-->varlet %LITERAL_TRUE% %LITERAL% {%V_BOOL%: true}
-->varlet %LITERAL_FALSE% %LITERAL% {%V_BOOL%: false}
-->varlet %LITERAL_NULL% %LITERAL% {type: V_NULL}

-->varlet %LITERAL_RED% %LITERAL% {%V_STRING% {value:'red'}}
-->varlet %LITERAL_GREEN% %LITERAL% {%V_STRING% {value:'green'}}
-->varlet %LITERAL_BLUE% %LITERAL% {%V_STRING% {value:'blue'}}
-->varlet %LITERAL_WHITE% %LITERAL% {%V_STRING% {value:'white'}}

-->varlet %LITERAL_APPLE% %LITERAL% {%V_OCTETS% {value:'apple' content_type:0}}
-->varlet %LITERAL_PEAR% %LITERAL% {%V_OCTETS% {value:'pear' content_type:0}}
-->varlet %LITERAL_PLUM% %LITERAL% {%V_OCTETS% {value:'plum' content_type:0}}
-->varlet %LITERAL_BANANA% %LITERAL% {%V_OCTETS% {value:'banana' content_type:0}}


-->varlet %LITERAL_ARRAY_10_20_30% %ARRAY% {value {%LITERAL_10%} value {%LITERAL_20%} value {%LITERAL_30%}}
-->varlet %LITERAL_ARRAY_10% %ARRAY% {value {%LITERAL_10%}}
-->varlet %LITERAL_ARRAY_40% %ARRAY% {value {%LITERAL_40%}}
-->varlet %LITERAL_ARRAY_20% %ARRAY% {value {%LITERAL_20%}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.1 with literal array (numeric)
-->callmacro Overlaps_positive	%LITERAL_ARRAY_10%	%LITERAL_ARRAY_10_20_30%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_40%	%LITERAL_ARRAY_10_20_30%


-->varlet %LITERAL_ARRAY_RED_GREEN_BLUE% %ARRAY% {value {%LITERAL_RED%} value {%LITERAL_GREEN%} value {%LITERAL_BLUE%}}
-->varlet %LITERAL_ARRAY_RED% %ARRAY% {value {%LITERAL_RED%}}
-->varlet %LITERAL_ARRAY_WHITE% %ARRAY% {value {%LITERAL_WHITE%}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.1 with literal array (string)
-->callmacro Overlaps_positive	%LITERAL_ARRAY_RED%	%LITERAL_ARRAY_RED_GREEN_BLUE%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_WHITE%	%LITERAL_ARRAY_RED_GREEN_BLUE%

-->varlet %LITERAL_ARRAY_TRUE_TRUE% %ARRAY% {value {%LITERAL_TRUE%} value {%LITERAL_TRUE%}}
-->varlet %LITERAL_ARRAY_FALSE_FALSE% %ARRAY% {value {%LITERAL_FALSE%} value {%LITERAL_FALSE%}}
-->varlet %LITERAL_ARRAY_TRUE% %ARRAY% {value {%LITERAL_TRUE%}}
-->varlet %LITERAL_ARRAY_FALSE% %ARRAY% {value {%LITERAL_FALSE%}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.1 with literal array (bool)
-->callmacro Overlaps_positive	%LITERAL_ARRAY_TRUE%	%LITERAL_ARRAY_TRUE_TRUE%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_FALSE%	%LITERAL_ARRAY_TRUE_TRUE%

-->callmacro Overlaps_positive	%LITERAL_ARRAY_FALSE%	%LITERAL_ARRAY_FALSE_FALSE%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_TRUE%	%LITERAL_ARRAY_FALSE_FALSE%


-->varlet %LITERAL_ARRAY_APPLE_PEAR_PLUM% %ARRAY% {value {%LITERAL_APPLE%} value {%LITERAL_PEAR%} value {%LITERAL_PLUM%}}
-->varlet %LITERAL_ARRAY_APPLE% %ARRAY% {value {%LITERAL_APPLE%}}
-->varlet %LITERAL_ARRAY_BANANA% %ARRAY% {value {%LITERAL_BANANA%}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.1 with literal array (plain octets string)
-->callmacro Overlaps_positive	%LITERAL_ARRAY_APPLE%	%LITERAL_ARRAY_APPLE_PEAR_PLUM%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_BANANA%	%LITERAL_ARRAY_APPLE_PEAR_PLUM%


-->varlet %JSON_OCTETS_ARRAY_10_20_30% %LITERAL% {%V_OCTETS% {value:'[10, 20, 30]' content_type:2}}
-->varlet %JSON_OCTETS_ARRAY_10% %LITERAL% {%V_OCTETS% {value:'[10]' content_type:2}}
-->varlet %JSON_OCTETS_ARRAY_40% %LITERAL% {%V_OCTETS% {value:'[40]' content_type:2}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.1 with literal array (numeric octets)
-->callmacro Overlaps_positive	%JSON_OCTETS_ARRAY_10%	%JSON_OCTETS_ARRAY_10_20_30%
-->callmacro Overlaps_negative	%JSON_OCTETS_ARRAY_40%	%JSON_OCTETS_ARRAY_10_20_30%


-->varlet %JSON_OCTETS_ARRAY_RED_GREEN_BLUE% %LITERAL% {%V_OCTETS% {value:'["red", "green", "blue"]' content_type:2}}
-->varlet %JSON_OCTETS_ARRAY_RED% %LITERAL% {%V_OCTETS% {value:'["red"]' content_type:2}}
-->varlet %JSON_OCTETS_ARRAY_WHITE% %LITERAL% {%V_OCTETS% {value:'["white"]' content_type:2}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.1 with literal array (string octets)
-->callmacro Overlaps_positive	%JSON_OCTETS_ARRAY_RED%	%JSON_OCTETS_ARRAY_RED_GREEN_BLUE%
-->callmacro Overlaps_negative	%JSON_OCTETS_ARRAY_WHITE%	%JSON_OCTETS_ARRAY_RED_GREEN_BLUE%


-->varlet %JSON_OCTETS_ARRAY_TRUE_TRUE% %LITERAL% {%V_OCTETS% {value:'[true, true]' content_type:2}}
-->varlet %JSON_OCTETS_ARRAY_TRUE% %LITERAL% {%V_OCTETS% {value:'[true]' content_type:2}}
-->varlet %JSON_OCTETS_ARRAY_FALSE_FALSE% %LITERAL% {%V_OCTETS% {value:'[false, false]' content_type:2}}
-->varlet %JSON_OCTETS_ARRAY_FALSE% %LITERAL% {%V_OCTETS% {value:'[false]' content_type:2}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.1 with literal array (bool octets)
-->callmacro Overlaps_positive	%JSON_OCTETS_ARRAY_TRUE%	%JSON_OCTETS_ARRAY_TRUE_TRUE%
-->callmacro Overlaps_negative	%JSON_OCTETS_ARRAY_FALSE%	%JSON_OCTETS_ARRAY_TRUE_TRUE%
-->callmacro Overlaps_positive	%JSON_OCTETS_ARRAY_FALSE%	%JSON_OCTETS_ARRAY_FALSE_FALSE%
-->callmacro Overlaps_negative	%JSON_OCTETS_ARRAY_TRUE%	%JSON_OCTETS_ARRAY_FALSE_FALSE%


-->varlet %MEMBER_ARRAY_10% %IDENT% {%DOCUMENT_PATH% {%MEMBER%: 'array_10'}}
-->varlet %MEMBER_ARRAY_40% %IDENT% {%DOCUMENT_PATH% {%MEMBER%: 'array_40'}}
-->varlet %MEMBER_ARRAY_10_20_30% %IDENT% {%DOCUMENT_PATH% {%MEMBER%: 'array_10_20_30'}}

-->echo ## 2. Using 'overlaps' operator with idetifiers
-->echo ## 2.1 with document member array (numeric)
-->callmacro Overlaps_positive	%LITERAL_ARRAY_10%	%MEMBER_ARRAY_10_20_30%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_40%	%MEMBER_ARRAY_10_20_30%
-->callmacro Overlaps_positive	%MEMBER_ARRAY_10%	%LITERAL_ARRAY_10_20_30%
-->callmacro Overlaps_negative	%MEMBER_ARRAY_40%	%LITERAL_ARRAY_10_20_30%


-->varlet %MEMBER_ARRAY_TRUE_TRUE% %IDENT% {%DOCUMENT_PATH% {%MEMBER%: 'array_true_true'}}
-->varlet %MEMBER_ARRAY_FALSE% %IDENT% {%DOCUMENT_PATH% {%MEMBER%: 'array_false'}}

-->echo ## 2. Using 'overlaps' operator with idetifiers
-->echo ## 2.1 with document member array (bool)
-->callmacro Overlaps_positive	%LITERAL_ARRAY_TRUE%	%MEMBER_ARRAY_TRUE_TRUE%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_FALSE%	%MEMBER_ARRAY_TRUE_TRUE%
-->callmacro Overlaps_positive	%MEMBER_ARRAY_FALSE%	%LITERAL_ARRAY_FALSE_FALSE%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_TRUE%	%LITERAL_ARRAY_FALSE_FALSE%


-->varlet %MEMBER_ARRAY_RED% %IDENT% {%DOCUMENT_PATH% {%MEMBER%: 'array_red'}}
-->varlet %MEMBER_ARRAY_BANANA% %IDENT% {%DOCUMENT_PATH% {%MEMBER%: 'array_banana'}}
-->varlet %MEMBER_ARRAY_RED_GREEN_PEAR% %IDENT% {%DOCUMENT_PATH% {%MEMBER%: 'array_red_green_pear'}}

-->echo ## 2. Using 'overlaps' operator with idetifiers
-->echo ## 2.1 with document member array (string)
-->callmacro Overlaps_positive	%LITERAL_ARRAY_RED%	%MEMBER_ARRAY_RED_GREEN_PEAR%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_WHITE%	%MEMBER_ARRAY_RED_GREEN_PEAR%
-->callmacro Overlaps_positive	%MEMBER_ARRAY_RED%	%MEMBER_ARRAY_RED_GREEN_PEAR%
-->callmacro Overlaps_negative	%MEMBER_ARRAY_BANANA%	%MEMBER_ARRAY_RED_GREEN_PEAR%
-->callmacro Overlaps_positive	%MEMBER_ARRAY_RED%	%LITERAL_ARRAY_RED_GREEN_BLUE%
-->callmacro Overlaps_negative	%MEMBER_ARRAY_BANANA%	%LITERAL_ARRAY_RED_GREEN_BLUE%



# objects

-->varlet %LITERAL_OBJECT_10% %OBJECT% {fld {key:'ten' value {%LITERAL_10%}}}
-->varlet %LITERAL_OBJECT_40% %OBJECT% {fld {key:'forty' value {%LITERAL_40%}}}
-->varlet %LITERAL_OBJECT_10_20_30% %OBJECT% {fld {key:'ten' value {%LITERAL_10%}} fld {key:'twenty' value {%LITERAL_20%}} fld {key:'thirty' value {%LITERAL_30%}}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.2 with literal object (numeric)
-->callmacro Overlaps_positive	%LITERAL_OBJECT_10%	%LITERAL_OBJECT_10_20_30%
-->callmacro Overlaps_negative	%LITERAL_OBJECT_40%	%LITERAL_OBJECT_10_20_30%


-->varlet %LITERAL_OBJECT_RED% %OBJECT% {fld {key:'red' value {%LITERAL_RED%}}}
-->varlet %LITERAL_OBJECT_WHITE% %OBJECT% {fld {key:'white' value {%LITERAL_WHITE%}}}
-->varlet %LITERAL_OBJECT_RED_GREEN_BLUE% %OBJECT% {fld {key:'red' value {%LITERAL_RED%}} fld {key:'green' value {%LITERAL_GREEN%}} fld {key:'blue' value {%LITERAL_BLUE%}}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.2 with literal object (string)
-->callmacro Overlaps_positive	%LITERAL_OBJECT_RED%	%LITERAL_OBJECT_RED_GREEN_BLUE%
-->callmacro Overlaps_negative	%LITERAL_OBJECT_WHITE%	%LITERAL_OBJECT_RED_GREEN_BLUE%


-->varlet %JSON_OCTETS_OBJECT_10% %LITERAL% {%V_OCTETS% {value:'{"ten":10}' content_type:2}}
-->varlet %JSON_OCTETS_OBJECT_40% %LITERAL% {%V_OCTETS% {value:'{"forty":40}' content_type:2}}
-->varlet %JSON_OCTETS_OBJECT_10_20_30% %LITERAL% {%V_OCTETS% {value:'{"ten":10, "twenty":20, "thirty":30}' content_type:2}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.2 with literal object (numeric octets)
-->callmacro Overlaps_positive	%JSON_OCTETS_OBJECT_10%	%JSON_OCTETS_OBJECT_10_20_30%
-->callmacro Overlaps_negative	%JSON_OCTETS_OBJECT_40%	%JSON_OCTETS_OBJECT_10_20_30%


-->varlet %JSON_OCTETS_OBJECT_RED% %LITERAL% {%V_OCTETS% {value:'{"red":"red"}' content_type:2}}
-->varlet %JSON_OCTETS_OBJECT_WHITE% %LITERAL% {%V_OCTETS% {value:'{"white":"white"}' content_type:2}}
-->varlet %JSON_OCTETS_OBJECT_RED_GREEN_BLUE% %LITERAL% {%V_OCTETS% {value:'{"red":"red", "green":"green", "blue":"blue"}' content_type:2}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.2 with literal object (string octets)
-->callmacro Overlaps_positive	%JSON_OCTETS_OBJECT_RED%	%JSON_OCTETS_OBJECT_RED_GREEN_BLUE%
-->callmacro Overlaps_negative	%JSON_OCTETS_OBJECT_WHITE%	%JSON_OCTETS_OBJECT_RED_GREEN_BLUE%


-->varlet %DOCUMENT_ROOT% %IDENT% {%DOCUMENT_PATH% {type: MEMBER}}

-->echo ## 2. Using 'overlaps' operator with idetifiers
-->echo ## 2.1 with document member array (document root)
-->callmacro Overlaps_positive	%LITERAL_OBJECT_RED%	%DOCUMENT_ROOT%
-->callmacro Overlaps_negative	%LITERAL_OBJECT_WHITE%	%DOCUMENT_ROOT%

-->echo ## 2. Using 'overlaps' operator with idetifiers
-->echo ## 2.2 with document member object (document root)
-->callmacro Overlaps_positive	%JSON_OCTETS_OBJECT_RED%	%DOCUMENT_ROOT%
-->callmacro Overlaps_negative	%JSON_OCTETS_OBJECT_WHITE%	%DOCUMENT_ROOT%


-->varlet %MEMBER_OBJECT_NUMERIC_10% %IDENT% {%DOCUMENT_PATH% {%MEMBER%: 'numeric_10'}}
-->varlet %MEMBER_OBJECT_NUMERIC_40% %IDENT% {%DOCUMENT_PATH% {%MEMBER%: 'numeric_40'}}

-->echo ## 2. Using 'overlaps' operator with idetifiers
-->echo ## 2.2 with document member object
-->callmacro Overlaps_positive	%MEMBER_OBJECT_NUMERIC_10%	%LITERAL_OBJECT_10_20_30%
-->callmacro Overlaps_negative	%MEMBER_OBJECT_NUMERIC_40%	%LITERAL_OBJECT_10_20_30%



# operators

-->varlet %ADD_OPERATOR%  %OPERATOR% {name: '+' param{ %LITERAL_10%} param{ %LITERAL_20%} }
-->varlet %CAST_TO_JSON_OPERATOR% %OPERATOR% {name: 'cast' param{%LITERAL% {%V_STRING% {value:'["red"]'}}} param{%LITERAL% {%V_OCTETS% {value:'JSON'}}}}

-->echo ## 3. Using 'overlaps' operator with operators (not supported operator)
-->callmacro Error_on_overlaps	%ADD_OPERATOR%	%LITERAL_ARRAY_10_20_30%	ER_X_EXPR_BAD_VALUE

-->echo ## 3. Using 'overlaps' operator with operators (cast to json)
-->callmacro Assert_overlaps	overlaps	%CAST_TO_JSON_OPERATOR%	%LITERAL_ARRAY_RED_GREEN_BLUE%	1


# null

-->varlet %LITERAL_ARRAY_NULL% %ARRAY% {value {%LITERAL_NULL%}}
-->varlet %LITERAL_ARRAY_10_NULL_30% %ARRAY% {value {%LITERAL_10%} value {%LITERAL_NULL%} value {%LITERAL_30%}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.1 with literal array (null)
-->callmacro Assert_overlaps	overlaps	%LITERAL_ARRAY_10%	%LITERAL_ARRAY_10_NULL_30%	1
-->callmacro Assert_overlaps	overlaps	%LITERAL_ARRAY_NULL%	%LITERAL_ARRAY_10_NULL_30%	1
-->callmacro Assert_overlaps	not_overlaps	%LITERAL_ARRAY_NULL%	%LITERAL_ARRAY_10_20_30%	1
-->callmacro Assert_overlaps	not_overlaps	%LITERAL_ARRAY_40%	%LITERAL_ARRAY_10_NULL_30%	1


-->varlet %LITERAL_OBJECT_NULL% %OBJECT% {fld {key:'zero' value {%LITERAL_NULL%}}}
-->varlet %LITERAL_OBJECT_10_NULL_30% %OBJECT% {fld {key:'zero' value {%LITERAL_NULL%}} fld {key:'ten' value {%LITERAL_10%}} fld {key:'thirty' value {%LITERAL_30%}}}

-->echo ## 1. Using 'overlaps' operator with literals
-->echo ## 1.2 with literal object (null)
-->callmacro Assert_overlaps	overlaps	%LITERAL_OBJECT_10%	%LITERAL_OBJECT_10_NULL_30%	1
-->callmacro Assert_overlaps	overlaps	%LITERAL_OBJECT_NULL%	%LITERAL_OBJECT_10_NULL_30%	1
-->callmacro Assert_overlaps	not_overlaps	%LITERAL_OBJECT_NULL%	%LITERAL_OBJECT_10_20_30%	1
-->callmacro Assert_overlaps	not_overlaps	%LITERAL_OBJECT_40%	%LITERAL_OBJECT_10_NULL_30%	1


# function

-->varlet %FUNCTION_CONCAT% %FUNC_CALL% {name{name: 'concat'} param{%LITERAL% {%V_STRING% {value:'["'}}} param{%LITERAL_RED%} param{%LITERAL% {%V_STRING% {value:'"]'}}}}

-->echo ## 4. Using 'overlaps' operator with function calls (not supported function)
-->callmacro Error_on_overlaps	%LITERAL_ARRAY_RED%	%FUNCTION_CONCAT%	ER_X_EXPR_BAD_VALUE

-->echo ## 4. Using 'overlaps' operator with function calls (supported functions)
-->title -JSON_ARRAY - Create JSON array
-->varlet %FUNCTION_JSON_ARRAY% %FUNC_CALL% {name{name: 'json_array'} param{%LITERAL_10%} param{%LITERAL_RED%} param{%LITERAL_TRUE%}}
-->callmacro Overlaps_positive	%LITERAL_ARRAY_RED%	%FUNCTION_JSON_ARRAY%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_WHITE%	%FUNCTION_JSON_ARRAY%

-->title -JSON_ARRAY_APPEND - Append data to JSON document
-->varlet %ROOT_POINT% %LITERAL% {%V_OCTETS% {value:'$'}}
-->varlet %FUNCTION_JSON_ARRAY_APPEND% %FUNC_CALL% {name{name: 'json_array_append'} param{%LITERAL_ARRAY_10_20_30%} param{%ROOT_POINT%} param{%LITERAL_RED%}}
-->callmacro Overlaps_positive	%LITERAL_ARRAY_RED%	%FUNCTION_JSON_ARRAY_APPEND%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_WHITE%	%FUNCTION_JSON_ARRAY_APPEND%

-->title -JSON_ARRAY_INSERT - Insert into JSON array
-->varlet %ARRAY_POINT% %LITERAL% {%V_OCTETS% {value:'$[1]'}}
-->varlet %FUNCTION_JSON_ARRAY_INSERT% %FUNC_CALL% {name{name: 'json_array_insert'} param{%LITERAL_ARRAY_10_20_30%} param{%ARRAY_POINT%} param{%LITERAL_RED%}}
-->callmacro Overlaps_positive	%LITERAL_ARRAY_RED%	%FUNCTION_JSON_ARRAY_INSERT%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_WHITE%	%FUNCTION_JSON_ARRAY_INSERT%

-->title -JSON_CONTAINS - Whether JSON document contains specific object at path
-->varlet %FUNCTION_JSON_CONTAINS% %FUNC_CALL% {name{name: 'json_contains'} param{%LITERAL_ARRAY_10_20_30%} param{%LITERAL_RED%}}
-->callmacro Error_on_overlaps	%LITERAL_ARRAY_RED%	%FUNCTION_JSON_CONTAINS%	ER_X_EXPR_BAD_VALUE

-->title -JSON_CONTAINS_PATH - Whether JSON document contains any data at path
-->varlet %FUNCTION_JSON_CONTAINS_PATH% %FUNC_CALL% {name{name: 'json_contains_path'} param{%LITERAL_ARRAY_10_20_30%} param{%ARRAY_POINT%}}
-->callmacro Error_on_overlaps	%LITERAL_ARRAY_RED%	%FUNCTION_JSON_CONTAINS_PATH%	ER_X_EXPR_BAD_VALUE

-->title -JSON_DEPTH - Maximum depth of JSON document
-->varlet %FUNCTION_JSON_DEPTH% %FUNC_CALL% {name{name: 'json_depth'} param{%LITERAL_ARRAY_10_20_30%}}
-->callmacro Error_on_overlaps	%LITERAL_ARRAY_RED%	%FUNCTION_JSON_DEPTH%	ER_X_EXPR_BAD_VALUE

-->title -JSON_EXTRACT - Return data from JSON document
-->varlet %FUNCTION_JSON_EXTRACT% %FUNC_CALL% {name{name: 'json_extract'} param{%MEMBER_ARRAY_10_20_30%} param{%ROOT_POINT%}}
-->callmacro Overlaps_positive	%LITERAL_ARRAY_10%	%FUNCTION_JSON_EXTRACT%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_40%	%FUNCTION_JSON_EXTRACT%

-->title -JSON_INSERT - Insert data into JSON document
-->varlet %FUNCTION_JSON_INSERT% %FUNC_CALL% {name{name: 'json_insert'} param{%LITERAL_ARRAY_RED%} param{%ARRAY_POINT%}, param{%LITERAL_10%}}
-->callmacro Overlaps_positive	%LITERAL_ARRAY_10%	%FUNCTION_JSON_INSERT%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_40%	%FUNCTION_JSON_INSERT%

-->title -JSON_KEYS - Array of keys from JSON document
-->varlet %FUNCTION_JSON_KEYS% %FUNC_CALL% {name{name: 'json_keys'} param{%DOCUMENT_ROOT%}}
-->callmacro Overlaps_positive	%LITERAL_ARRAY_10%	%FUNCTION_JSON_INSERT%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_40%	%FUNCTION_JSON_INSERT%

-->title -JSON_LENGTH - Number of elements in JSON document
-->varlet %FUNCTION_JSON_LENGTH% %FUNC_CALL% {name{name: 'json_length'} param{%DOCUMENT_ROOT%}}
-->callmacro Error_on_overlaps	%LITERAL_ARRAY_RED%	%FUNCTION_JSON_LENGTH%	ER_X_EXPR_BAD_VALUE

-->title -JSON_MERGE - Merge JSON documents
-->varlet %FUNCTION_JSON_MERGE% %FUNC_CALL% {name{name: 'json_merge'} param{%LITERAL_OBJECT_10%} param{%LITERAL_OBJECT_RED%}}
-->callmacro Overlaps_positive	%LITERAL_OBJECT_10%	%FUNCTION_JSON_MERGE%
-->callmacro Overlaps_negative	%LITERAL_OBJECT_40%	%FUNCTION_JSON_MERGE%

-->title -JSON_OBJECT - Create JSON object
-->varlet %KEY_10% %LITERAL% {%V_OCTETS% {value:'ten'}}
-->varlet %FUNCTION_JSON_OBJECT% %FUNC_CALL% {name{name: 'json_object'} param{%KEY_10%} param{%LITERAL_10%}}
-->callmacro Overlaps_positive	%LITERAL_OBJECT_10%	%FUNCTION_JSON_OBJECT%
-->callmacro Overlaps_negative	%LITERAL_OBJECT_40%	%FUNCTION_JSON_OBJECT%

#-->title -JSON_QUOTE - Quote JSON document
#-->varlet %FUNCTION_JSON_QUOTE% %FUNC_CALL% {name{name: 'json_quote'} param{%LITERAL_RED%}}
# no good test scenario

-->title -JSON_REMOVE - Remove data from JSON document
-->varlet %FUNCTION_JSON_REMOVE% %FUNC_CALL% {name{name: 'json_remove'} param{%LITERAL_ARRAY_10_20_30%} param{%ARRAY_POINT%}}
-->callmacro Overlaps_positive	%LITERAL_ARRAY_10%	%FUNCTION_JSON_REMOVE%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_20%	%FUNCTION_JSON_REMOVE%

-->title -JSON_REPLACE - Replace values in JSON document
-->varlet %FUNCTION_JSON_REPLACE% %FUNC_CALL% {name{name: 'json_replace'} param{%LITERAL_ARRAY_10_20_30%} param{%ARRAY_POINT%} param{%LITERAL_40%}}
-->callmacro Overlaps_positive	%LITERAL_ARRAY_40%	%FUNCTION_JSON_REPLACE%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_20%	%FUNCTION_JSON_REPLACE%

-->title -JSON_SEARCH - Path to value within JSON document
-->varlet %FUNCTION_JSON_SEARCH% %FUNC_CALL% {name{name: 'json_search'} param{%LITERAL_ARRAY_RED_GREEN_BLUE%} param{%LITERAL% {%V_OCTETS% {value:'one'}}} param{%LITERAL_GREEN%}}
-->callmacro Overlaps_positive	%ARRAY% {value {%ARRAY_POINT%}}	%FUNCTION_JSON_SEARCH%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_WHITE%	%FUNCTION_JSON_SEARCH%

-->title -JSON_SET - Insert data into JSON document
-->varlet %FUNCTION_JSON_SET% %FUNC_CALL% {name{name: 'json_set'} param{%LITERAL_ARRAY_RED_GREEN_BLUE%} param{%ARRAY_POINT%} param{%LITERAL_10%}}
-->callmacro Overlaps_positive	%LITERAL_ARRAY_10%	%FUNCTION_JSON_SET%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_20%	%FUNCTION_JSON_SET%

-->title -JSON_TYPE - Type of JSON value
-->varlet %FUNCTION_JSON_TYPE% %FUNC_CALL% {name{name: 'json_type'} param{%LITERAL_OBJECT_RED%}}
-->callmacro Error_on_overlaps	%LITERAL_ARRAY_RED%	%FUNCTION_JSON_TYPE%	ER_X_EXPR_BAD_VALUE

#-->title -JSON_UNQUOTE - Unquote JSON value
#-->varlet %FUNCTION_JSON_UNQUOTE% %FUNC_CALL% {name{name: 'json_unquote'} param{%MEMBER_SCALAR_RED%}}
# no good test scenario

-->title -JSON_VALID - Whether JSON value is valid
-->varlet %FUNCTION_JSON_VALID% %FUNC_CALL% {name{name: 'json_valid'} param{%LITERAL_OBJECT_RED%}}
-->callmacro Error_on_overlaps	%LITERAL_ARRAY_RED%	%FUNCTION_JSON_VALID%	ER_X_EXPR_BAD_VALUE

# parameters

-->macro Overlaps_params  %PARAMS%  %ERROR%
Mysqlx.Crud.Find {
  collection { name: "xtable" schema: "xtest" }
  data_model: TABLE
  projection {
    alias: "overlaps"
    source {
      type: OPERATOR operator {
        name: "overlaps"
        %PARAMS%
      }
    }
  }
}
-->expecterror %ERROR%
-->recvresult
-->endmacro

-->echo ## 5. Validating number of 'overlaps' arguments
-->callmacro Overlaps_params	 	ER_X_EXPR_BAD_NUM_ARGS
-->callmacro Overlaps_params	param{ %LITERAL_ARRAY_10%}	ER_X_EXPR_BAD_NUM_ARGS
-->callmacro Overlaps_params	param{ %LITERAL_ARRAY_10%} param{ %LITERAL_ARRAY_20%}	ER_SUCCESS
-->callmacro Overlaps_params	param{ %LITERAL_ARRAY_10%} param{ %LITERAL_ARRAY_20%} param{ %LITERAL_ARRAY_40%}	ER_X_EXPR_BAD_NUM_ARGS


-->echo # Some extra scenarios
-->varlet %LITERAL_EMPTY_STRING% %LITERAL% {%V_STRING% {value:''}}
-->varlet %LITERAL_STRING_10% %LITERAL% {%V_STRING% {value:'10'}}
-->varlet %LITERAL_DATE% %LITERAL% {%V_STRING% {value:'2018:10:10'}}
-->varlet %LITERAL_78_67% %LITERAL% {%V_FLOAT%: 78.67}
-->varlet %LITERAL_ARRAY_EMPTY% %ARRAY% {}
-->varlet %LITERAL_ARRAY_EMPTY_STRING% %ARRAY% {value {%LITERAL_EMPTY_STRING%}}
-->varlet %LITERAL_ARRAY_STRING_10% %ARRAY% {value {%LITERAL_STRING_10%}}
-->varlet %LITERAL_ARRAY_MIX% %ARRAY% {value {%LITERAL_RED%} value {%LITERAL_10%} value {%LITERAL_STRING_10%} value {%LITERAL_NULL%} value {%LITERAL_78_67%} value {%LITERAL_DATE%}}
-->varlet %LITERAL_OBJECT_EMPTY_ARRAY% %OBJECT% {fld {key:'empty' value {%LITERAL_ARRAY_EMPTY%}}}
-->varlet %LITERAL_OBJECT_EMPTY_STRING% %OBJECT% {fld {key:'empty' value {%LITERAL_EMPTY_STRING%}}}

-->callmacro Overlaps_negative	%LITERAL_ARRAY_EMPTY%	%LITERAL_ARRAY_RED_GREEN_BLUE%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_EMPTY_STRING%	%LITERAL_ARRAY_RED%
-->callmacro Overlaps_negative	%LITERAL_OBJECT_EMPTY_STRING%	%LITERAL_OBJECT_EMPTY_ARRAY%
-->callmacro Overlaps_positive	%LITERAL_ARRAY_MIX%	%LITERAL_ARRAY_STRING_10%
-->callmacro Overlaps_positive	%LITERAL_ARRAY_MIX%	%LITERAL_ARRAY_NULL%
-->callmacro Overlaps_negative	%LITERAL_ARRAY_MIX%	%LITERAL_ARRAY_WHITE%
-->callmacro Overlaps_positive	%LITERAL_ARRAY_MIX%	%LITERAL_78_67%


EOF

CREATE SCHEMA xtest;
CREATE TABLE xtest.xtable (doc JSON);
INSERT INTO xtest.xtable (doc) VALUES
  ('{"array_10":[10],
     "array_40":[40],
     "array_10_20_30":[10,20,30],
     "array_red":["red"],
     "array_banana":["banana"],
     "array_true_true":[true, true],
     "array_false":[false],
     "array_red_green_pear":["red","green","pear"],
     "numeric_10":{"ten":10},
     "numeric_40":{"forty":40},
     "red":"red"}');

--exec $MYSQLXTEST -ux_root --password='' --file=$xtest_file 2>&1

## Cleanup
DROP SCHEMA IF EXISTS xtest;
--remove_file $xtest_file
--source include/xplugin_drop_user.inc