/* Copyright (c) 2016, 2022, MariaDB Corporation. This program is free software ; you can redistribute it and / or modify it under the terms of the GNU General Public License as published by the Free Software Foundation ; version 2 of the License . This program is distributed in the hope that it will be useful , but WITHOUT ANY WARRANTY ; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU General Public License for more details . You should have received a copy of the GNU General Public License along with this program ; if not , write to the Free Software #include "mariadb.h" #include "sql_class.h" #include "sql_parse.h" // For check_stack_overrun #include <m_string.h>#include "json_schema.h" #include "json_schema_helper.h" #include "pcre2.h" #ifndef DBUG_OFFint dbug_json_check_min_stack_requirement();#endif static HASH all_keywords_hash;static Json_schema_keyword *create_json_schema_keyword(THD *thd)return new (thd->mem_root) Json_schema_keyword();static Json_schema_keyword *create_json_schema_type(THD *thd)return new (thd->mem_root) Json_schema_type();static Json_schema_keyword *create_json_schema_enum(THD *thd)return new (thd->mem_root) Json_schema_enum();static Json_schema_keyword *create_json_schema_const(THD *thd)return new (thd->mem_root) Json_schema_const();static Json_schema_keyword *create_json_schema_maximum(THD *thd)return new (thd->mem_root) Json_schema_maximum();static Json_schema_keyword *create_json_schema_minimum(THD *thd)return new (thd->mem_root) Json_schema_minimum();static Json_schema_keyword *create_json_schema_ex_max(THD *thd)return new (thd->mem_root) Json_schema_ex_maximum();static Json_schema_keyword *create_json_schema_ex_min(THD *thd)return new (thd->mem_root) Json_schema_ex_minimum();static Json_schema_keyword *create_json_schema_multiple_of(THD *thd)return new (thd->mem_root) Json_schema_multiple_of();static Json_schema_keyword *create_json_schema_max_len(THD *thd)return new (thd->mem_root) Json_schema_max_len();static Json_schema_keyword *create_json_schema_min_len(THD *thd)return new (thd->mem_root) Json_schema_min_len();static Json_schema_keyword *create_json_schema_pattern(THD *thd)return new (thd->mem_root) Json_schema_pattern();static Json_schema_keyword *create_json_schema_items(THD *thd)return new (thd->mem_root) Json_schema_items();static Json_schema_keyword *create_json_schema_max_items(THD *thd)return new (thd->mem_root) Json_schema_max_items();static Json_schema_keyword *create_json_schema_min_items(THD *thd)return new (thd->mem_root) Json_schema_min_items();static Json_schema_keyword *create_json_schema_prefix_items(THD *thd)return new (thd->mem_root) Json_schema_prefix_items();static Json_schema_keyword *create_json_schema_contains(THD *thd)return new (thd->mem_root) Json_schema_contains();static Json_schema_keyword *create_json_schema_max_contains(THD *thd)return new (thd->mem_root) Json_schema_max_contains();static Json_schema_keyword *create_json_schema_min_contains(THD *thd)return new (thd->mem_root) Json_schema_min_contains();static Json_schema_keyword *create_json_schema_unique_items(THD *thd)return new (thd->mem_root) Json_schema_unique_items();static Json_schema_keyword *create_json_schema_additional_items(THD *thd)return new (thd->mem_root) Json_schema_additional_items();static Json_schema_keyword *create_json_schema_unevaluated_items(THD *thd)return new (thd->mem_root) Json_schema_unevaluated_items();static Json_schema_keyword *create_json_schema_properties(THD *thd)return new (thd->mem_root) Json_schema_properties();static Json_schema_keyword *create_json_schema_pattern_properties(THD *thd)return new (thd->mem_root) Json_schema_pattern_properties();static Json_schema_keyword *create_json_schema_additional_properties(THD *thd)return new (thd->mem_root) Json_schema_additional_properties();static Json_schema_keyword *create_json_schema_unevaluated_properties(THD *thd)return new (thd->mem_root) Json_schema_unevaluated_properties();static Json_schema_keyword *create_json_schema_property_names(THD *thd)return new (thd->mem_root) Json_schema_property_names();static Json_schema_keyword *create_json_schema_max_prop(THD *thd)return new (thd->mem_root) Json_schema_max_prop();static Json_schema_keyword *create_json_schema_min_prop(THD *thd)return new (thd->mem_root) Json_schema_min_prop();static Json_schema_keyword *create_json_schema_required(THD *thd)return new (thd->mem_root) Json_schema_required();static Json_schema_keyword *create_json_schema_dependent_required(THD *thd)return new (thd->mem_root) Json_schema_dependent_required();static Json_schema_keyword *create_json_schema_dependent_schemas(THD *thd)return new (thd->mem_root) Json_schema_dependent_schemas();static Json_schema_keyword *create_json_schema_not(THD *thd)return new (thd->mem_root) Json_schema_not();static Json_schema_keyword *create_json_schema_all_of(THD *thd)return new (thd->mem_root) Json_schema_all_of();static Json_schema_keyword *create_json_schema_any_of(THD *thd)return new (thd->mem_root) Json_schema_any_of();static Json_schema_keyword *create_json_schema_one_of(THD *thd)return new (thd->mem_root) Json_schema_one_of();static Json_schema_keyword *create_json_schema_if(THD *thd)return new (thd->mem_root) Json_schema_if();static Json_schema_keyword *create_json_schema_then(THD *thd)return new (thd->mem_root) Json_schema_then();static Json_schema_keyword *create_json_schema_else(THD *thd)return new (thd->mem_root) Json_schema_else();static Json_schema_keyword *create_json_schema_annotation(THD *thd)return new (thd->mem_root) Json_schema_annotation();static Json_schema_keyword *create_json_schema_format(THD *thd)return new (thd->mem_root) Json_schema_format();static Json_schema_keyword *create_json_schema_media_string(THD *thd)return new (thd->mem_root) Json_schema_media_string();static Json_schema_keyword *create_json_schema_reference(THD *thd)return new (thd->mem_root) Json_schema_reference();static st_json_schema_keyword_map json_schema_func_array[]="type" ) }, create_json_schema_type, JSON_SCHEMA_COMMON_KEYWORD},"const" ) }, create_json_schema_const, JSON_SCHEMA_COMMON_KEYWORD},"enum" ) }, create_json_schema_enum, JSON_SCHEMA_COMMON_KEYWORD},"maximum" ) }, create_json_schema_maximum, JSON_SCHEMA_NUMBER_KEYWORD},"minimum" ) }, create_json_schema_minimum, JSON_SCHEMA_NUMBER_KEYWORD},"exclusiveMaximum" ) }, create_json_schema_ex_max, JSON_SCHEMA_NUMBER_KEYWORD},"exclusiveMinimum" ) }, create_json_schema_ex_min, JSON_SCHEMA_NUMBER_KEYWORD},"multipleOf" ) }, create_json_schema_multiple_of, JSON_SCHEMA_NUMBER_KEYWORD},"maxLength" ) }, create_json_schema_max_len, JSON_SCHEMA_STRING_KEYWORD},"minLength" ) }, create_json_schema_min_len, JSON_SCHEMA_STRING_KEYWORD},"pattern" ) }, create_json_schema_pattern, JSON_SCHEMA_STRING_KEYWORD},"items" ) }, create_json_schema_items, JSON_SCHEMA_ARRAY_KEYWORD},"maxItems" ) }, create_json_schema_max_items, JSON_SCHEMA_ARRAY_KEYWORD},"minItems" ) }, create_json_schema_min_items, JSON_SCHEMA_ARRAY_KEYWORD},"additionalItems" ) }, create_json_schema_additional_items, JSON_SCHEMA_ARRAY_KEYWORD},"unevaluatedItems" ) }, create_json_schema_unevaluated_items, JSON_SCHEMA_ARRAY_KEYWORD},"prefixItems" ) }, create_json_schema_prefix_items, JSON_SCHEMA_ARRAY_KEYWORD},"uniqueItems" ) }, create_json_schema_unique_items, JSON_SCHEMA_ARRAY_KEYWORD},"contains" ) }, create_json_schema_contains, JSON_SCHEMA_ARRAY_KEYWORD},"maxContains" ) }, create_json_schema_max_contains, JSON_SCHEMA_ARRAY_KEYWORD},"minContains" ) }, create_json_schema_min_contains, JSON_SCHEMA_ARRAY_KEYWORD},"properties" ) }, create_json_schema_properties, JSON_SCHEMA_OBJECT_KEYWORD},"patternProperties" ) }, create_json_schema_pattern_properties, JSON_SCHEMA_OBJECT_KEYWORD},"propertyNames" ) }, create_json_schema_property_names, JSON_SCHEMA_OBJECT_KEYWORD},"maxProperties" ) }, create_json_schema_max_prop, JSON_SCHEMA_OBJECT_KEYWORD},"minProperties" ) }, create_json_schema_min_prop, JSON_SCHEMA_OBJECT_KEYWORD},"dependentRequired" ) }, create_json_schema_dependent_required, JSON_SCHEMA_OBJECT_KEYWORD},"dependentSchemas" ) }, create_json_schema_dependent_schemas, JSON_SCHEMA_OBJECT_KEYWORD},"required" ) }, create_json_schema_required, JSON_SCHEMA_OBJECT_KEYWORD},"additionalProperties" ) }, create_json_schema_additional_properties, JSON_SCHEMA_OBJECT_KEYWORD},"unevaluatedProperties" ) }, create_json_schema_unevaluated_properties, JSON_SCHEMA_OBJECT_KEYWORD},"not" ) }, create_json_schema_not, JSON_SCHEMA_LOGIC_KEYWORD},"allOf" ) }, create_json_schema_all_of, JSON_SCHEMA_LOGIC_KEYWORD},"anyOf" ) }, create_json_schema_any_of, JSON_SCHEMA_LOGIC_KEYWORD},"oneOf" ) }, create_json_schema_one_of, JSON_SCHEMA_LOGIC_KEYWORD},"if" ) }, create_json_schema_if, JSON_SCHEMA_CONDITION_KEYWORD},"then" ) }, create_json_schema_then, JSON_SCHEMA_CONDITION_KEYWORD},"else" ) }, create_json_schema_else, JSON_SCHEMA_CONDITION_KEYWORD},"title" ) }, create_json_schema_annotation, JSON_SCHEMA_ANNOTATION_KEYWORD},"description" ) }, create_json_schema_annotation, JSON_SCHEMA_ANNOTATION_KEYWORD},"comment" ) }, create_json_schema_annotation, JSON_SCHEMA_ANNOTATION_KEYWORD},"$schema" ) }, create_json_schema_annotation, JSON_SCHEMA_ANNOTATION_KEYWORD},"deprecated" ) }, create_json_schema_annotation, JSON_SCHEMA_ANNOTATION_KEYWORD},"readOnly" ) }, create_json_schema_annotation, JSON_SCHEMA_ANNOTATION_KEYWORD},"writeOnly" ) }, create_json_schema_annotation, JSON_SCHEMA_ANNOTATION_KEYWORD},"example" ) }, create_json_schema_annotation, JSON_SCHEMA_ANNOTATION_KEYWORD},"default" ) }, create_json_schema_annotation, JSON_SCHEMA_ANNOTATION_KEYWORD},"$vocabulary" ) }, create_json_schema_annotation, JSON_SCHEMA_ANNOTATION_KEYWORD},"date-time" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"date" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"time" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"duration" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"email" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"idn-email" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"hostname" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"idn-hostname" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"ipv4" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"ipv6" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"uri" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"uri-reference" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"iri" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"iri-reference" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"uuid" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"json-pointer" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"relative-json-pointer" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"regex" ) }, create_json_schema_format, JSON_SCHEMA_FORMAT_KEYWORD},"contentMediaType" ) }, create_json_schema_media_string, JSON_SCHEMA_MEDIA_KEYWORD},"conentEncoding" ) }, create_json_schema_media_string, JSON_SCHEMA_MEDIA_KEYWORD},"contentSchema" ) }, create_json_schema_media_string, JSON_SCHEMA_MEDIA_KEYWORD},"$ref" ) }, create_json_schema_reference, JSON_SCHEMA_REFERENCE_KEYWORD},"$id" ) }, create_json_schema_reference, JSON_SCHEMA_REFERENCE_KEYWORD},"$anchor" ) }, create_json_schema_reference, JSON_SCHEMA_REFERENCE_KEYWORD},"$defs" ) }, create_json_schema_reference, JSON_SCHEMA_REFERENCE_KEYWORD},"$dynamicRef" ) }, create_json_schema_reference, JSON_SCHEMA_REFERENCE_KEYWORD},"$dynamicAnchor" ) }, create_json_schema_reference, JSON_SCHEMA_REFERENCE_KEYWORD},static st_json_schema_keyword_map empty_func_map="" ) }, create_json_schema_keyword, JSON_SCHEMA_EMPTY_KEYWORD};/* When some schemas dont validate , we want to check the annotation for an alternate schema . Example , when we have " properties " and " patternProperties " , if " properties " does not validate for a certain keyname , then we want to check if it validates for " patternProperties " . In this case " patterProperties " will be alternate schema for " properties " . bool Json_schema_keyword::const json_engine_t *je,const uchar* k_start,const uchar* k_end)if (alternate_schema)if (alternate_schema->allowed)if (alternate_schema->validate_as_alternate(je, k_start, k_end,return true ;else return true ;return false ;bool Json_schema_annotation::handle_keyword(THD *thd,const char * key_start,const char * key_end,bool is_invalid_value_type= false , res= false ;if (this ->keyword_map == &(json_schema_func_array[38 ]) ||this ->keyword_map == &(json_schema_func_array[39 ]) ||this ->keyword_map == &(json_schema_func_array[40 ]) ||this ->keyword_map == &(json_schema_func_array[41 ]))if (je->value_type != JSON_VALUE_STRING)true ;else if (this ->keyword_map == &(json_schema_func_array[42 ]) ||this ->keyword_map == &(json_schema_func_array[43 ]) ||this ->keyword_map == &(json_schema_func_array[44 ]))if (je->value_type != JSON_VALUE_TRUE &&true ;else if (this ->keyword_map == &(json_schema_func_array[45 ]))if (je->value_type != JSON_VALUE_ARRAY)true ;if (json_skip_level(je))return true ;else if (this ->keyword_map == &(json_schema_func_array[46 ]))return false ;if (is_invalid_value_type)true ;0 );const char *)key_start, (int )(key_end-key_start));0 ), keyword.ptr());return res;bool Json_schema_format::handle_keyword(THD *thd,const char * key_start,const char * key_end,if (je->value_type != JSON_VALUE_STRING)0 ), "format" );return false ;bool Json_schema_type::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)return !((1 << je->value_type) & type);bool Json_schema_type::handle_keyword(THD *thd,const char * key_start,const char * key_end,if (je->value_type == JSON_VALUE_ARRAY)int level= je->stack_p;while (json_scan_next(je)==0 && je->stack_p >= level)if (json_read_value(je))return true ;return je->s.error ? true : false ;else if (je->value_type == JSON_VALUE_STRING)return json_assign_type(&type, je);else 0 ), "type" );return true ;bool Json_schema_const::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)const char *start= (char *)curr_je.value;const char *end= (char *)curr_je.value+curr_je.value_len;"" , 0 , curr_je.s.cs);int err= 0 ;if (type != curr_je.value_type)return true ;if (curr_je.value_type <= JSON_VALUE_NUMBER)if (!json_value_scalar(&temp_je))if (json_skip_level(&temp_je))return true ;char *)temp_je.s.c_str;char *)temp_je.value, end-start, temp_je.s.cs);const uchar *) val.ptr(),const uchar *) val.end());if (temp_je.value_type != JSON_VALUE_STRING)if (json_read_value(&temp_je_2))return true ;if (err)return true ;else if (a_res.length() == strlen(const_json_value) &&const char *)const_json_value, a_res.ptr(),return false ;return true ;return false ;bool Json_schema_const::handle_keyword(THD *thd,const char * key_start,const char * key_end,const char *start= (char *)je->value, *end= (char *)je->value+je->value_len;"" , 0 , je->s.cs);int err;sizeof (int ), NULL,0 ));sizeof (int ), NULL,0 ));sizeof (struct json_norm_value*), NULL,0 ));sizeof (int ), NULL,0 ));if (!json_value_scalar(je))if (json_skip_level(je))return true ;char *)je->s.c_str;char *)je->value, end-start, je->s.cs);const uchar *) val.ptr(),const uchar *) val.end());if (je->value_type != JSON_VALUE_STRING)if (json_read_value(&temp_je))return true ;if (err)return true ;else this ->const_json_value= (char *)alloc_root(thd->mem_root,1 );if (!const_json_value)return 1 ;'\0' ;const char *)a_res.ptr(), a_res.length());return false ;bool Json_schema_enum::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)char *)"" ,0 , je->s.cs);"" , 0 , je->s.cs);int err= 1 ;if (temp_je.value_type > JSON_VALUE_NUMBER)if (!(enum_scalar & (1 << temp_je.value_type)))return true ;else return false ;if (err)return true ;const char *)a_res.ptr(), a_res.length(), je->s.cs);if (my_hash_search(&this ->enum_values, (const uchar*)(norm_str.ptr()),const char *)(norm_str.ptr()))))return false ;else return true ;bool Json_schema_enum::handle_keyword(THD *thd, MEM_ROOT *current_mem_root,const char * key_start,const char * key_end,int count= 0 ;sizeof (int ), NULL,0 ));sizeof (struct json_norm_value*), NULL,0 ));if (my_hash_init(PSI_INSTRUMENT_ME,this ->enum_values,1024 , 0 , 0 , get_key_name,0 ))return true ;if (je->value_type == JSON_VALUE_ARRAY)int curr_level= je->stack_p;while (json_scan_next(je) == 0 && curr_level <= je->stack_p)if (json_read_value(je))return true ;if (je->value_type > JSON_VALUE_NUMBER)if (!(enum_scalar & (1 << je->value_type)))1 << je->value_type;else 0 ), "enum" );return true ;else char *norm_str;int err= 1 ;"" , 0 , je->s.cs);if (err)return true ;char *)alloc_root(thd->mem_root,1 );if (!norm_str)return true ;else '\0' ;const char *)a_res.ptr(), a_res.length());if (!my_hash_search(&this ->enum_values, (uchar*)norm_str,if (my_hash_insert(&this ->enum_values, (uchar*)norm_str))return true ;else 0 ), "enum" );return true ;if (!count)0 ), "enum" );return true ;return false ;else 0 ), "enum" );return true ;bool Json_schema_maximum::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)return false ;double val= je->s.cs->strntod((char *) je->value,return (val <= value) ? false : true ;bool Json_schema_maximum::handle_keyword(THD *thd, MEM_ROOT *current_mem_root,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "maximum" );return true ;double val= je->s.cs->strntod((char *) je->value,return false ;bool Json_schema_minimum::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)return false ;double val= je->s.cs->strntod((char *) je->value,return val >= value ? false : true ;bool Json_schema_minimum::handle_keyword(THD *thd, MEM_ROOT *current_mem_root,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "minimum" );return true ;double val= je->s.cs->strntod((char *) je->value,return false ;bool Json_schema_ex_minimum::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)return false ;double val= je->s.cs->strntod((char *) je->value,return (val > value) ? false : true ;bool Json_schema_ex_minimum::handle_keyword(THD *thd,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "exclusiveMinimum" );return true ;double val= je->s.cs->strntod((char *) je->value,return false ;bool Json_schema_ex_maximum::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)return false ;double val= je->s.cs->strntod((char *) je->value,return (val < value) ? false : true ;bool Json_schema_ex_maximum::handle_keyword(THD *thd,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "exclusiveMaximum" );return true ;double val= je->s.cs->strntod((char *) je->value,return false ;bool Json_schema_multiple_of::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)return false ;if (je->num_flags & JSON_NUM_FRAC_PART)return true ;char *) je->value,10 , &end, &err);return val % multiple_of;bool Json_schema_multiple_of::handle_keyword(THD *thd,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER || (je->num_flags & JSON_NUM_FRAC_PART))0 ), "multipleOf" );return true ;char *) je->value,10 , &end, &err);if (val <= 0 )0 ), "multipleOf" );return false ;bool Json_schema_max_len::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)if (je->value_type != JSON_VALUE_STRING)return false ;return (uint)(je->value_len) <= value ? false : true ;bool Json_schema_max_len::handle_keyword(THD *thd,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "maxLength" );return true ;double val= je->s.cs->strntod((char *) je->value,if (val < 0 )0 ), "maxLength" );return true ;int )val;return false ;bool Json_schema_min_len::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)if (je->value_type != JSON_VALUE_STRING)return false ;return (uint)(je->value_len) >= value ? false : true ;bool Json_schema_min_len::handle_keyword(THD *thd, MEM_ROOT *current_mem_root,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "minLength" );return true ;double val= je->s.cs->strntod((char *) je->value,if (val < 0 )0 ), "minLength" );return true ;int )val;return false ;bool Json_schema_pattern::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)bool pattern_matches= false ;/* We want to match a single pattern against multiple string when ( see below ) : 1 ) with " pattern " when there are different json strings to be validated against one pattern . 2 ) with " propertyNames " , where there is one pattern but multiple property names to be validated against one pattern if (!k_start && !k_end)/* 1) */ if (je->value_type != JSON_VALUE_STRING)return false ;const char *)je->value,else /* 2) */ const char *)k_start,if (re.recompile(pattern))return true ;if (re.exec(str, 0 , 0 ))return true ;return pattern_matches ? false : true ;bool Json_schema_pattern::handle_keyword(THD *thd, MEM_ROOT *current_mem_root,const char * key_start,const char * key_end,if (je->value_type != JSON_VALUE_STRING)0 ), "pattern" );return true ;const char *)je->value,new (thd->mem_root) Item_string(thd, "" , (uint) 0 , je->s.cs);0 );return false ;bool Json_schema_max_items::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)0 ;if (curr_je.value_type != JSON_VALUE_ARRAY)return false ;int level= curr_je.stack_p;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)if (json_read_value(&curr_je))return true ;if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;return count > value ? true : false ;bool Json_schema_max_items::handle_keyword(THD *thd,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "maxItems" );return true ;double val= je->s.cs->strntod((char *) je->value,if (val < 0 )0 ), "maxItems" );return true ;int )val;return false ;bool Json_schema_min_items::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)0 ;if (curr_je.value_type != JSON_VALUE_ARRAY)return false ;int level= curr_je.stack_p;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)if (json_read_value(&curr_je))return true ;if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;return count < value ? true : false ;bool Json_schema_min_items::handle_keyword(THD *thd,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "minItems" );return true ;double val= je->s.cs->strntod((char *) je->value,if (val < 0 )0 ), "maxLength" );return true ;int )val;return false ;bool Json_schema_max_contains::handle_keyword(THD *thd,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "maxContains" );return true ;double val= je->s.cs->strntod((char *) je->value,if (val < 0 )0 ), "maxContains" );return true ;return false ;bool Json_schema_min_contains::handle_keyword(THD *thd,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "minContains" );return true ;double val= je->s.cs->strntod((char *) je->value,if (val < 0 )0 ), "minContains" );return true ;return false ;bool Json_schema_contains::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)0 ;int level= je->stack_p;bool validated= true ;if (curr_je.value_type != JSON_VALUE_ARRAY)return false ;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)if (json_read_value(&curr_je))return true ;true ;if (validate_schema_items(&curr_je, current_mem_root, &contains))false ;if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;if (validated)if ((max_contains ? contains_count <= max_contains->value :0 ) &&0 ))return false ;return true ;bool Json_schema_contains::handle_keyword(THD *thd,const char * key_start,const char * key_end,if (je->value_type != JSON_VALUE_OBJECT)0 ), "contains" );return true ;return create_object_and_handle_keyword(thd, current_mem_root, je,bool Json_schema_items::handle_keyword(THD *thd, MEM_ROOT *current_mem_root,const char * key_start,const char * key_end,if (je->value_type == JSON_VALUE_FALSE)false );return false ;if (je->value_type == JSON_VALUE_OBJECT)return create_object_and_handle_keyword(thd, current_mem_root, je,else if (je->value_type != JSON_VALUE_TRUE)0 ), "items" );return true ;return false ;bool Json_schema_items::validate_as_alternate(const json_engine_t *je,const uchar *k_start,const uchar* k_end,/* The indexes in prefix array were less than that in the json array . So validate remaining using the json schema return validate_schema_items(je, current_mem_root, &items_schema);bool Json_schema_items::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)/* There was no " prefixItesm " , so we validate all values in the array using one schema . int level= je->stack_p, count=0 ;bool is_false= false ;if (je->value_type != JSON_VALUE_ARRAY)return false ;if (!allowed)true ;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)if (json_read_value(&curr_je))return true ;if (validate_schema_items(&curr_je, current_mem_root, &items_schema))return true ;if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;return is_false ? (!count ? false : true ) : false ;bool Json_schema_prefix_items::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)int level= je->stack_p;if (curr_je.value_type != JSON_VALUE_ARRAY)return false ;while (curr_je.s.c_str < curr_je.s.str_end && json_scan_next(&curr_je)==0 &&if (json_read_value(&curr_je))return true ;if (!(curr_prefix=it1++))if (fall_back_on_alternate_schema(&curr_je, current_mem_root))return true ;else if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;else if (validate_schema_items(&curr_je, current_mem_root,return true ;if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;return false ;bool Json_schema_prefix_items::handle_keyword(THD *thd,const char * key_start,const char * key_end,int level= je->stack_p;if (je->value_type != JSON_VALUE_ARRAY)0 ), "prefixItems" );return true ;sizeof (int ), NULL,0 ));while (json_scan_next(je)==0 && je->stack_p >= level)char *begin, *end;int len;if (json_read_value(je))return true ;if (je->value_type != JSON_VALUE_OBJECT)0 ), "items" );return true ;char *)je->value;if (json_skip_level(je))return true ;char *)je->s.c_str;int )(end-begin);const uchar *) begin,const uchar *)begin+len);new (thd->mem_root) List<Json_schema_keyword>;if (!keyword_list)return true ;if (create_object_and_handle_keyword(thd, current_mem_root,return true ;return false ;bool Json_schema_unique_items::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)char > norm_str_list;int res= true , level= curr_je.stack_p, scalar_val= 0 ;if (curr_je.value_type != JSON_VALUE_ARRAY)return false ;if (my_hash_init(PSI_INSTRUMENT_ME, &unique_items, curr_je.s.cs,1024 , 0 , 0 , get_key_name, NULL, 0 ))return true ;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)int err= 1 ;char *norm_str;"" , 0 , curr_je.s.cs);if (json_read_value(&curr_je))goto end;if (err)goto end;char *)malloc(a_res.length()+1 );if (!norm_str)goto end;'\0' ;const char *)a_res.ptr(), a_res.length());if (curr_je.value_type > JSON_VALUE_NUMBER)if (scalar_val & 1 << curr_je.value_type)goto end;1 << curr_je.value_type;else if (!my_hash_search(&unique_items, (uchar*)norm_str,const char *)norm_str))))if (my_hash_insert(&unique_items, (uchar*)norm_str))goto end;else goto end;"" , 0 , curr_je.s.cs);false ;if (!norm_str_list.is_empty())char > it(norm_str_list);char *curr_norm_str;while ((curr_norm_str= it++))return res;bool Json_schema_unique_items::handle_keyword(THD *thd,const char * key_start,const char * key_end,sizeof (int ), NULL,0 ));sizeof (struct json_norm_value*), NULL,0 ));if (je->value_type == JSON_VALUE_TRUE)true ;else if (je->value_type == JSON_VALUE_FALSE)false ;else 0 ), "uniqueItems" );return true ;return false ;bool Json_schema_max_prop::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)0 ;int curr_level= je->stack_p;if (curr_je.value_type != JSON_VALUE_OBJECT)return false ;while (json_scan_next(&curr_je)== 0 && je->stack_p >= curr_level)switch (curr_je.state)case JST_KEY:if (json_read_value(&curr_je))return true ;if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;return properties_count > value ? true : false ;bool Json_schema_max_prop::handle_keyword(THD *thd,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "maxProperties" );return true ;double val= je->s.cs->strntod((char *) je->value,if (val < 0 )0 ), "maxProperties" );return true ;int )val;return false ;bool Json_schema_min_prop::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)0 ;int curr_level= je->stack_p;if (curr_je.value_type != JSON_VALUE_OBJECT)return false ;while (json_scan_next(&curr_je)== 0 && je->stack_p >= curr_level)switch (curr_je.state)case JST_KEY:if (json_read_value(&curr_je))return true ;if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;return properties_count < value ? true : false ;bool Json_schema_min_prop::handle_keyword(THD *thd,const char * key_start,const char * key_end,int err= 0 ;char *end;if (je->value_type != JSON_VALUE_NUMBER)0 ), "minProperties" );return true ;double val= je->s.cs->strntod((char *) je->value,if (val < 0 )0 ), "minProperties" );return true ;int )val;return false ;bool Json_schema_required::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)char > malloc_mem_list;int res= true , curr_level= curr_je.stack_p;if (curr_je.value_type != JSON_VALUE_OBJECT)return false ;if (my_hash_init(PSI_INSTRUMENT_ME, &required,1024 , 0 , 0 , get_key_name,0 ))return true ;while (json_scan_next(&curr_je)== 0 && curr_je.stack_p >= curr_level)switch (curr_je.state)case JST_KEY:const uchar *key_end, *key_start;int key_len;char *str;do while (json_read_keyname_chr(&curr_je) == 0 );int )(key_end-key_start);char *)malloc((size_t)(key_len)+1 );const char *)key_start, key_len);'\0' ;if (my_hash_insert(&required, (const uchar*)str))goto error;while ((curr_str= it++))if (!my_hash_search(&required, (const uchar*)curr_str->ptr(),goto error;false ;if (!malloc_mem_list.is_empty())char > it(malloc_mem_list);char *curr_ptr;while ((curr_ptr= it++))return res;bool Json_schema_required::handle_keyword(THD *thd,const char * key_start,const char * key_end,int level= je->stack_p;if (je->value_type != JSON_VALUE_ARRAY)0 ), "required" );return true ;while (json_scan_next(je)==0 && level <= je->stack_p)if (json_read_value(je))return true ;if (je->value_type != JSON_VALUE_STRING)0 ), "required" );return true ;else new (thd->mem_root)String((char *)je->value,this ->required_properties.push_back(str, thd->mem_root);return je->s.error ? true : false ;bool Json_schema_dependent_required::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)bool res= true ;int curr_level= curr_je.stack_p;char > malloc_mem_list;if (curr_je.value_type != JSON_VALUE_OBJECT)return false ;if (my_hash_init(PSI_INSTRUMENT_ME, &properties,1024 , 0 , 0 , get_key_name,0 ))return true ;while (json_scan_next(&curr_je)== 0 && curr_je.stack_p >= curr_level)switch (curr_je.state)case JST_KEY:const uchar *key_end, *key_start;int key_len;char *str;do while (json_read_keyname_chr(&curr_je) == 0 );int )(key_end-key_start);char *)malloc((size_t)(key_len)+1 );const char *)key_start, key_len);int )(key_end-key_start)]='\0' ;if (my_hash_insert(&properties, (const uchar*)str))goto error;while ((curr_keyword= it++))if (my_hash_search(&properties,const uchar*)curr_keyword->property->ptr(),while ((curr_depended_keyword= it2++))if (!my_hash_search(&properties,const uchar*)curr_depended_keyword->ptr(),goto error;false ;if (!malloc_mem_list.is_empty())char > it(malloc_mem_list);char *curr_ptr;while ((curr_ptr= it++))return res;bool Json_schema_dependent_required::handle_keyword(THD *thd,const char * key_start,const char * key_end,if (je->value_type == JSON_VALUE_OBJECT)int level1= je->stack_p;while (json_scan_next(je)==0 && level1 <= je->stack_p)switch (je->state)case JST_KEY:const uchar *k_end, *k_start;int k_len;do while (json_read_keyname_chr(je) == 0 );int )(k_end-k_start);if (json_read_value(je))return true ;if (je->value_type == JSON_VALUE_ARRAY)sizeof (st_dependent_keywords));if (curr_dependent_keywords)new (thd->mem_root)String((char *)k_start,int level2= je->stack_p;while (json_scan_next(je)==0 && level2 <= je->stack_p)if (json_read_value(je) || je->value_type != JSON_VALUE_STRING)0 ),"dependentRequired" );return true ;else new (thd->mem_root)String((char *)je->value,else return true ;else 0 ),"dependentRequired" );return true ;else 0 ), "dependentRequired" );return true ;return je->s.error ? true : false ;bool Json_schema_property_names::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)int level= curr_je.stack_p;if (je->value_type != JSON_VALUE_OBJECT)return false ;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)switch (curr_je.state)case JST_KEY:const uchar *k_end, *k_start;do while (json_read_keyname_chr(&curr_je) == 0 );if (json_read_value(&curr_je))return true ;if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;while ((curr_schema= it1++))if (curr_schema->validate(&curr_je, current_mem_root, k_start, k_end))return true ;return false ;bool Json_schema_property_names::handle_keyword(THD *thd,const char * key_start,const char * key_end,if (je->value_type != JSON_VALUE_OBJECT)0 ), "propertyNames" );return true ;if (create_object_and_handle_keyword(thd, current_mem_root, je,return true ;return false ;/* additional_items , additional_properties , unevaluated_items , unevaluated_properties are all going to be schemas ( basically of object type ) . So they all can be handled just like any other schema . bool const char * key_start,const char * key_end,if (je->value_type == JSON_VALUE_FALSE)false );return false ;else if (je->value_type == JSON_VALUE_OBJECT)return create_object_and_handle_keyword(thd, current_mem_root, je,if (je->value_type != JSON_VALUE_TRUE)0 ), keyword_map->func_name.str);return true ;return false ;/* Validating properties as an alternate schema happens only when we have logic keywords . Example we have allOf , and one key is not validated against allOf but it is present in " properties " and validates against it . Then the validation result should be true . So we would want that key to be validated against " properties " , with " properties " begin alternate schema . bool Json_schema_properties::validate_as_alternate(const json_engine_t *je,const uchar* k_start,const uchar* k_end,if ((curr_property=const uchar*)k_start,if (validate_schema_items(&curr_je, current_mem_root,return true ;if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;else if (alternate_schema && alternate_schema->validate_as_alternate(je, k_start,return true ;return false ;bool const json_engine_t *je,const uchar* k_start,const uchar* k_end,if (!allowed)return true ;return validate_schema_items(je, current_mem_root, &schema_list);/* Makes sense on its own , without existence of additionalProperties , properties , patternProperties . bool Json_schema_unevaluated_properties::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)int level= curr_je.stack_p, count= 0 ;bool has_false= false ;if (je->value_type != JSON_VALUE_OBJECT)return false ;if (!allowed)true ;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)if (json_read_value(&curr_je))return true ;if (validate_schema_items(&curr_je, current_mem_root, &schema_list))return true ;return has_false ? (!count ? false : true ) : false ;/* Unlike additionalItems , additionalProperties makes sense on its own without existence of properties and patternProperties , bool Json_schema_additional_properties::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)int level= curr_je.stack_p;if (je->value_type != JSON_VALUE_OBJECT)return false ;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)switch (curr_je.state)case JST_KEY:if (json_read_value(&curr_je))return true ;if (validate_schema_items(&curr_je, current_mem_root, &schema_list))return true ;return false ;/* When items / prefix Items is present and if a key is not validated against it , then additionalItems is validated as an " alternate validation " . It will be present / linked as alternate keyword and will not be present in the schema list for that level . This function called when " items " / " prefixItems " is absent , i . e when additionalItems appears in the schema list for that level . So additional Properties on its own will not make sense . bool Json_schema_additional_items::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)return false ;bool Json_schema_unevaluated_items::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)/* Makes sense on its own without adjacent keywords . int level= je->stack_p, count=0 ;bool is_false= false ;if (je->value_type != JSON_VALUE_ARRAY)return false ;if (!allowed)true ;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)if (json_read_value(&curr_je))return true ;if (validate_schema_items(&curr_je, current_mem_root, &schema_list))return true ;return is_false ? (!count ? false : true ) : false ;bool Json_schema_properties::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)if (curr_je.value_type != JSON_VALUE_OBJECT)return false ;int level= curr_je.stack_p;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)switch (curr_je.state)case JST_KEY:const uchar *k_end, *k_start= curr_je.s.c_str;do while (json_read_keyname_chr(&curr_je) == 0 );if (json_read_value(&curr_je))return true ;if ((curr_property=const uchar*)k_start,if (validate_schema_items(&curr_je, current_mem_root,return true ;else if (fall_back_on_alternate_schema(&curr_je, current_mem_root,return true ;if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;return false ;bool Json_schema_properties::handle_keyword(THD *thd,const char * key_start,const char * key_end,if (je->value_type != JSON_VALUE_OBJECT)0 ), "properties" );return true ;if (my_hash_init(PSI_INSTRUMENT_ME,this ->properties,1024 , 0 , 0 ,0 ))return true ;true ;int level= je->stack_p;while (json_scan_next(je)==0 && level <= je->stack_p)switch (je->state)case JST_KEY:const uchar *k_end, *k_start= je->s.c_str;do while (json_read_keyname_chr(je) == 0 );if (json_read_value(je))return true ;sizeof (st_property));if (curr_property)char *)alloc_root(thd->mem_root,1 );new (thd->mem_root) List<Json_schema_keyword>;if (curr_property->key_name)int )(k_end-k_start)]= '\0' ;char *)curr_property->key_name, (const char *)k_start,if (create_object_and_handle_keyword(thd, current_mem_root, je,return true ;if (my_hash_insert(&properties, (const uchar*)curr_property))return true ;return je->s.error ? true : false ;bool Json_schema_pattern_properties::const json_engine_t *curr_je,const uchar *k_start,const uchar* k_end,bool match_found= false ;const char *)k_start,while ((curr_pattern_property= it1++))if (curr_pattern_property->re.recompile(curr_pattern_property->pattern))return true ;if (curr_pattern_property->re.exec(str, 0 , 0 ))return true ;if (curr_pattern_property->re.match())true ;if (validate_schema_items(curr_je, current_mem_root,return true ;break ;if (!match_found)if (fall_back_on_alternate_schema(curr_je, current_mem_root))return true ;return false ;bool Json_schema_pattern_properties::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)int level= je->stack_p;bool match_found= false ;if (je->value_type != JSON_VALUE_OBJECT)return false ;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)switch (curr_je.state)case JST_KEY:const uchar *k_end, *k_start= curr_je.s.c_str;do while (json_read_keyname_chr(&curr_je) == 0 );const char *)k_start,if (json_read_value(&curr_je))return true ;while ((curr_pattern_property= it1++))if (curr_pattern_property->re.recompile(curr_pattern_property->pattern))return true ;if (curr_pattern_property->re.exec(str, 0 , 0 ))return true ;if (curr_pattern_property->re.match())true ;if (validate_schema_items(&curr_je, current_mem_root,return true ;if (!match_found)if (fall_back_on_alternate_schema(&curr_je,return true ;return false ;bool Json_schema_pattern_properties::handle_keyword(THD *thd,const char * key_start,const char * key_end,if (je->value_type != JSON_VALUE_OBJECT)0 ), "patternProperties" );return true ;new (thd->mem_root) Item_string(thd, "" , (uint) 0 , je->s.cs);int level= je->stack_p;while (json_scan_next(je)==0 && level <= je->stack_p)switch (je->state)case JST_KEY:const uchar *k_end, *k_start= je->s.c_str;do while (json_read_keyname_chr(je) == 0 );if (json_read_value(je))return true ;new (thd->mem_root) pattern_to_property();if (curr_pattern_to_property)const char *)k_start,0 );new (thd->mem_root) List<Json_schema_keyword>;if (curr_pattern_to_property->curr_schema)if (create_object_and_handle_keyword(thd, current_mem_root, je,return true ;return false ;bool Json_schema_logic::handle_keyword(THD *thd,const char * key_start,const char * key_end,int level= je->stack_p;sizeof (int ), NULL,0 ));if (je->value_type != JSON_VALUE_ARRAY)0 ), keyword_map->func_name.str);return true ;while (json_scan_next(je)==0 && je->stack_p >= level)char *begin, *end;int len;if (json_read_value(je))return true ;char *)je->value;if (json_skip_level(je))return true ;char *)je->s.c_str;int )(end-begin);const uchar *) begin,const uchar *)begin+len);new (thd->mem_root) List<Json_schema_keyword>;if (!keyword_list)return true ;if (create_object_and_handle_keyword(thd, current_mem_root,return true ;return false ;bool Json_schema_logic::check_validation(const json_engine_t *je,const uchar *k_start,const uchar *k_end)0 ;bool validated= true ;if (je->value_type == JSON_VALUE_ARRAY)else if (je->value_type == JSON_VALUE_OBJECT)while ((curr_schema= it1++))true ;while ((curr_keyword=it2++))if (!curr_keyword->alternate_schema)if (curr_keyword->validate(je, current_mem_root))false ;break ;if (validated)if (logic_flag & HAS_NOT)return true ;if (validate_count(&count_validations, &schema_items.elements))return true ;return false ;bool Json_schema_logic::validate(const json_engine_t *je,const uchar *k_start,const uchar* k_end)return check_validation(je, current_mem_root, k_start, k_end);bool Json_schema_not::handle_keyword(THD *thd, MEM_ROOT *current_mem_root,const char * key_start,const char * key_end,bool res= false ;if (je->value_type != JSON_VALUE_OBJECT)0 ), keyword_map->func_name.str);return true ;return res;bool Json_schema_keyword::validate_schema_items(const json_engine_t *je,while ((curr_schema= it1++))if (curr_schema->validate(&curr_je, current_mem_root))return true ;return false ;bool Json_schema_conditional::validate(const json_engine_t *je,const uchar *k_start,const uchar *k_end)if (if_cond)if (!if_cond->validate_schema_items(je, current_mem_root,if (then_cond)if (then_cond->validate_schema_items(je, current_mem_root,return true ;else if (else_cond)if (else_cond->validate_schema_items(je, current_mem_root,return true ;return false ;bool Json_schema_conditional::handle_keyword(THD *thd,const char * key_start,const char * key_end,if (je->value_type != JSON_VALUE_OBJECT)0 ), keyword_map->func_name.str);return true ;return create_object_and_handle_keyword(thd, current_mem_root, je,bool Json_schema_dependent_schemas::handle_keyword(THD *thd,const char * key_start,const char * key_end,if (je->value_type != JSON_VALUE_OBJECT)0 ), "properties" );return true ;if (my_hash_init(PSI_INSTRUMENT_ME,this ->properties,1024 , 0 , 0 ,0 ))return true ;true ;int level= je->stack_p;while (json_scan_next(je)==0 && level <= je->stack_p)switch (je->state)case JST_KEY:const uchar *k_end, *k_start= je->s.c_str;do while (json_read_keyname_chr(je) == 0 );if (json_read_value(je))return true ;sizeof (st_property));if (curr_property)char *)alloc_root(thd->mem_root,1 );new (thd->mem_root) List<Json_schema_keyword>;if (curr_property->key_name)int )(k_end-k_start)]= '\0' ;char *)curr_property->key_name, (const char *)k_start,if (create_object_and_handle_keyword(thd, current_mem_root, je,return true ;if (my_hash_insert(&properties, (const uchar*)curr_property))return true ;return false ;bool Json_schema_dependent_schemas::validate(const json_engine_t *je,const uchar *k_start,const uchar *k_end)if (curr_je.value_type != JSON_VALUE_OBJECT)return false ;int level= curr_je.stack_p;while (json_scan_next(&curr_je)==0 && level <= curr_je.stack_p)switch (curr_je.state)case JST_KEY:const uchar *k_end, *k_start= curr_je.s.c_str;do while (json_read_keyname_chr(&curr_je) == 0 );if (json_read_value(&curr_je))return true ;if ((curr_property=const uchar*)k_start,if (validate_schema_items(je, current_mem_root, curr_property->curr_schema))return true ;if (!json_value_scalar(&curr_je))if (json_skip_level(&curr_je))return true ;return false ;bool Json_schema_media_string::handle_keyword(THD *thd,const char * key_start,const char * key_end,if (je->value_type != JSON_VALUE_STRING)char *)key_start, key_end-key_start, je->s.cs);0 ), curr_keyword.ptr());return true ;return false ;bool Json_schema_reference::handle_keyword(THD *thd,const char * key_start,const char * key_end,0 );const char *)key_start, (int )(key_end-key_start));0 ), keyword.ptr());return true ;const uchar* key_start,const uchar* key_end)if (!curr_keyword_map)return curr_keyword;static int sort_by_priority(Json_schema_keyword* el1, Json_schema_keyword* el2,void *arg)return el1->priority > el2->priority;void fix_keyword_list(List <Json_schema_keyword> *keyword_list)if (keyword_list && !keyword_list->is_empty())int count= 1 ;while ((curr_schema=it2++))return ;/* Some schemas are interdependent : they are evaluated only if their adjacent schemas fail to evaluate . So the need to be linked in a way that if one fails to evaluate a value , we can try an alternate schema . Hence push such keywords in a temporary list , adjust the interdependence and then add them to main schema list . bool while ((temp_keyword= temp_it++))if ((curr_element= (st_json_schema_keyword_map*) my_hash_search(&all_keywords_hash,if (temp_keyword->priority > 0 )if (curr_element->flag == JSON_SCHEMA_ARRAY_KEYWORD)else if (curr_element->flag == JSON_SCHEMA_OBJECT_KEYWORD)else if (curr_element->flag == JSON_SCHEMA_LOGIC_KEYWORD)else if (temp_keyword->keyword_map == &(json_schema_func_array[35 ]))else if (temp_keyword->keyword_map == &(json_schema_func_array[36 ]))else if (temp_keyword->keyword_map == &(json_schema_func_array[37 ]))else if (temp_keyword->keyword_map == &(json_schema_func_array[18 ]))else if (temp_keyword->keyword_map == &(json_schema_func_array[20 ]))else if (temp_keyword->keyword_map == &(json_schema_func_array[19 ]))else if (if_cond)new (current_thd->mem_root) Json_schema_conditional();if (cond_schema)if (contains)/* We want to check for alternate schema When a key is not validated by logic keywords , we would want to also check schema like properties , items etc to make sure the key is not validated by any schema in order to return correct result . So " link " other schemas as alternate when logic properties is present and only push logic keywords to the schema list . if (!logic_prop.is_empty())while ((curr_schema= it++))0 ),0 ));else if (array_prop.elem(0 ))0 ), thd->mem_root);if (object_prop.elem(0 ))0 ), thd->mem_root);return false ;/* Scan all keywords on the current level and put them in a temporary list . Once scanning is done , adjust the dependency if needed , and add the keywords in keyword_list bool create_object_and_handle_keyword(THD *thd, MEM_ROOT *current_mem_root,int level= je->stack_p;"json_check_min_stack_requirement" ,return true ;);if (check_stack_overrun(thd, STACK_MIN_SIZE , NULL))return true ;while (json_scan_next(je)== 0 && je->stack_p >= level)switch (je->state)case JST_KEY:const uchar *key_end, *key_start;do while (json_read_keyname_chr(je) == 0 );if (json_read_value(je))return true ;if (all_keywords)if (curr_keyword->handle_keyword(thd, current_mem_root, je,const char *)key_start,const char *)key_end, all_keywords))return true ;break ;if (add_schema_interdependence(thd, &temporary_list, keyword_list))return true ;return je->s.error ? true : false ;const uchar *get_key_name_for_property(const void *key_name, size_t *length,auto curr_property= static_cast <const st_property *>(key_name);return reinterpret_cast <const uchar *>(curr_property->key_name);const uchar *get_key_name_for_func(const void *key_name, size_t *length,auto curr_keyword=static_cast <const st_json_schema_keyword_map *>(key_name);return reinterpret_cast <const uchar *>(curr_keyword->func_name.str);bool setup_json_schema_keyword_hash()if (my_hash_init(PSI_INSTRUMENT_ME,1024 , 0 , 0 ,0 ))return true ;int size= sizeof (json_schema_func_array)/sizeof (json_schema_func_array[0 ]);for (int i= 0 ; i < size; i++)if (my_hash_insert(&all_keywords_hash, (uchar*)(&json_schema_func_array[i])))return true ;return false ;void cleanup_json_schema_keyword_hash()return ;
Messung V0.5 in Prozent C=100 H=92 G=95
¤ Dauer der Verarbeitung: 0.38 Sekunden
(vorverarbeitet am 2026-10-08)
¤ *© Formatika GbR, Deutschland
