1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Change C_STRING_WITH_LEN to STRING_WITH_LEN

Browse Source 
This preserves const str for constant strings

Other things
- A few variables where changed from LEX_STRING to LEX_CSTRING
- Incident_log_event::Incident_log_event and record_incident where
  changed to take LEX_CSTRING* as an argument instead of LEX_STRING
This commit is contained in:
Monty 2018-01-08 15:33:23 +02:00
parent 18e22cb69f
commit f55dc7f733
38 changed files with 763 additions and 778 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
sql/event_data_objects.cc
View File

@ -1266,8 +1266,8 @@ Event_job_data::construct_sp_sql(THD *thd, String *sp_sql)
sp_sql->length(0);
sp_sql->append(C_STRING_WITH_LEN("CREATE "));
sp_sql->append(C_STRING_WITH_LEN("PROCEDURE "));
sp_sql->append(STRING_WITH_LEN("CREATE "));
sp_sql->append(STRING_WITH_LEN("PROCEDURE "));
/*
Let's use the same name as the event name to perhaps produce a
better error message in case it is a part of some parse error.
@ -1282,7 +1282,7 @@ Event_job_data::construct_sp_sql(THD *thd, String *sp_sql)
let's execute the procedure with the invoker rights to save on
resets of security contexts.
*/
sp_sql->append(C_STRING_WITH_LEN("() SQL SECURITY INVOKER "));
sp_sql->append(STRING_WITH_LEN("() SQL SECURITY INVOKER "));
sp_sql->append(&body);
@ -1310,7 +1310,7 @@ Event_job_data::construct_drop_event_sql(THD *thd, String *sp_sql)
sp_sql->set(buffer.str, buffer.length, system_charset_info);
sp_sql->length(0);
sp_sql->append(C_STRING_WITH_LEN("DROP EVENT "));
sp_sql->append(STRING_WITH_LEN("DROP EVENT "));
append_identifier(thd, sp_sql, &dbname);
sp_sql->append('.');
append_identifier(thd, sp_sql, &name);

104
sql/event_db_repository.cc
View File

@ -41,38 +41,38 @@ static
const TABLE_FIELD_TYPE event_table_fields[ET_FIELD_COUNT] =
{
{
{ C_STRING_WITH_LEN("db") },
{ C_STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("db") },
{ STRING_WITH_LEN("char(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("name") },
{ C_STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("name") },
{ STRING_WITH_LEN("char(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("body") },
{ C_STRING_WITH_LEN("longblob") },
{ STRING_WITH_LEN("body") },
{ STRING_WITH_LEN("longblob") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("definer") },
{ C_STRING_WITH_LEN("char(") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("definer") },
{ STRING_WITH_LEN("char(") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("execute_at") },
{ C_STRING_WITH_LEN("datetime") },
{ STRING_WITH_LEN("execute_at") },
{ STRING_WITH_LEN("datetime") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("interval_value") },
{ C_STRING_WITH_LEN("int(11)") },
{ STRING_WITH_LEN("interval_value") },
{ STRING_WITH_LEN("int(11)") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("interval_field") },
{ C_STRING_WITH_LEN("enum('YEAR','QUARTER','MONTH','DAY',"
{ STRING_WITH_LEN("interval_field") },
{ STRING_WITH_LEN("enum('YEAR','QUARTER','MONTH','DAY',"
"'HOUR','MINUTE','WEEK','SECOND','MICROSECOND','YEAR_MONTH','DAY_HOUR',"
"'DAY_MINUTE','DAY_SECOND','HOUR_MINUTE','HOUR_SECOND','MINUTE_SECOND',"
"'DAY_MICROSECOND','HOUR_MICROSECOND','MINUTE_MICROSECOND',"
@ -80,43 +80,43 @@ const TABLE_FIELD_TYPE event_table_fields[ET_FIELD_COUNT] =
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("created") },
{ C_STRING_WITH_LEN("timestamp") },
{ STRING_WITH_LEN("created") },
{ STRING_WITH_LEN("timestamp") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("modified") },
{ C_STRING_WITH_LEN("timestamp") },
{ STRING_WITH_LEN("modified") },
{ STRING_WITH_LEN("timestamp") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("last_executed") },
{ C_STRING_WITH_LEN("datetime") },
{ STRING_WITH_LEN("last_executed") },
{ STRING_WITH_LEN("datetime") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("starts") },
{ C_STRING_WITH_LEN("datetime") },
{ STRING_WITH_LEN("starts") },
{ STRING_WITH_LEN("datetime") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("ends") },
{ C_STRING_WITH_LEN("datetime") },
{ STRING_WITH_LEN("ends") },
{ STRING_WITH_LEN("datetime") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("status") },
{ C_STRING_WITH_LEN("enum('ENABLED','DISABLED','SLAVESIDE_DISABLED')") },
{ STRING_WITH_LEN("status") },
{ STRING_WITH_LEN("enum('ENABLED','DISABLED','SLAVESIDE_DISABLED')") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("on_completion") },
{ C_STRING_WITH_LEN("enum('DROP','PRESERVE')") },
{ STRING_WITH_LEN("on_completion") },
{ STRING_WITH_LEN("enum('DROP','PRESERVE')") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("sql_mode") },
{ C_STRING_WITH_LEN("set('REAL_AS_FLOAT','PIPES_AS_CONCAT','ANSI_QUOTES',"
{ STRING_WITH_LEN("sql_mode") },
{ STRING_WITH_LEN("set('REAL_AS_FLOAT','PIPES_AS_CONCAT','ANSI_QUOTES',"
"'IGNORE_SPACE','IGNORE_BAD_TABLE_OPTIONS','ONLY_FULL_GROUP_BY',"
"'NO_UNSIGNED_SUBTRACTION',"
"'NO_DIR_IN_CREATE','POSTGRESQL','ORACLE','MSSQL','DB2','MAXDB',"
@ -128,38 +128,38 @@ const TABLE_FIELD_TYPE event_table_fields[ET_FIELD_COUNT] =
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("comment") },
{ C_STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("comment") },
{ STRING_WITH_LEN("char(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("originator") },
{ C_STRING_WITH_LEN("int(10)") },
{ STRING_WITH_LEN("originator") },
{ STRING_WITH_LEN("int(10)") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("time_zone") },
{ C_STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("latin1") }
{ STRING_WITH_LEN("time_zone") },
{ STRING_WITH_LEN("char(64)") },
{ STRING_WITH_LEN("latin1") }
},
{
{ C_STRING_WITH_LEN("character_set_client") },
{ C_STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("character_set_client") },
{ STRING_WITH_LEN("char(32)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("collation_connection") },
{ C_STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("collation_connection") },
{ STRING_WITH_LEN("char(32)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("db_collation") },
{ C_STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("db_collation") },
{ STRING_WITH_LEN("char(32)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("body_utf8") },
{ C_STRING_WITH_LEN("longblob") },
{ STRING_WITH_LEN("body_utf8") },
{ STRING_WITH_LEN("longblob") },
{ NULL, 0 }
}
};

8
sql/event_scheduler.cc
View File

@ -49,11 +49,11 @@ Event_db_repository *Event_worker_thread::db_repository;
static
const LEX_STRING scheduler_states_names[] =
const LEX_CSTRING scheduler_states_names[] =
{
{ C_STRING_WITH_LEN("INITIALIZED") },
{ C_STRING_WITH_LEN("RUNNING") },
{ C_STRING_WITH_LEN("STOPPING") }
{ STRING_WITH_LEN("INITIALIZED") },
{ STRING_WITH_LEN("RUNNING") },
{ STRING_WITH_LEN("STOPPING") }
};
struct scheduler_param {

6
sql/item.cc
View File

@ -4565,13 +4565,13 @@ const String *Item_param::value_query_val_str(THD *thd, String *str) const
/* Create date string inplace */
switch (value.time.time_type) {
case MYSQL_TIMESTAMP_DATE:
str->append(C_STRING_WITH_LEN("DATE"));
str->append(STRING_WITH_LEN("DATE"));
break;
case MYSQL_TIMESTAMP_TIME:
str->append(C_STRING_WITH_LEN("TIME"));
str->append(STRING_WITH_LEN("TIME"));
break;
case MYSQL_TIMESTAMP_DATETIME:
str->append(C_STRING_WITH_LEN("TIMESTAMP"));
str->append(STRING_WITH_LEN("TIMESTAMP"));
break;
case MYSQL_TIMESTAMP_ERROR:
case MYSQL_TIMESTAMP_NONE:

670
sql/item_create.cc
View File

@ -6816,347 +6816,347 @@ Create_func_year_week::create_native(THD *thd, LEX_CSTRING *name,
static Native_func_registry func_array[] =
{
{ { C_STRING_WITH_LEN("ABS") }, BUILDER(Create_func_abs)},
{ { C_STRING_WITH_LEN("ACOS") }, BUILDER(Create_func_acos)},
{ { C_STRING_WITH_LEN("ADDTIME") }, BUILDER(Create_func_addtime)},
{ { C_STRING_WITH_LEN("AES_DECRYPT") }, BUILDER(Create_func_aes_decrypt)},
{ { C_STRING_WITH_LEN("AES_ENCRYPT") }, BUILDER(Create_func_aes_encrypt)},
{ { C_STRING_WITH_LEN("AREA") }, GEOM_BUILDER(Create_func_area)},
{ { C_STRING_WITH_LEN("ASBINARY") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { C_STRING_WITH_LEN("ASIN") }, BUILDER(Create_func_asin)},
{ { C_STRING_WITH_LEN("ASTEXT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { C_STRING_WITH_LEN("ASWKB") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { C_STRING_WITH_LEN("ASWKT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { C_STRING_WITH_LEN("ATAN") }, BUILDER(Create_func_atan)},
{ { C_STRING_WITH_LEN("ATAN2") }, BUILDER(Create_func_atan)},
{ { C_STRING_WITH_LEN("BENCHMARK") }, BUILDER(Create_func_benchmark)},
{ { C_STRING_WITH_LEN("BIN") }, BUILDER(Create_func_bin)},
{ { C_STRING_WITH_LEN("BINLOG_GTID_POS") }, BUILDER(Create_func_binlog_gtid_pos)},
{ { C_STRING_WITH_LEN("BIT_COUNT") }, BUILDER(Create_func_bit_count)},
{ { C_STRING_WITH_LEN("BIT_LENGTH") }, BUILDER(Create_func_bit_length)},
{ { C_STRING_WITH_LEN("BOUNDARY") }, GEOM_BUILDER(Create_func_boundary)},
{ { C_STRING_WITH_LEN("BUFFER") }, GEOM_BUILDER(Create_func_buffer)},
{ { C_STRING_WITH_LEN("CEIL") }, BUILDER(Create_func_ceiling)},
{ { C_STRING_WITH_LEN("CEILING") }, BUILDER(Create_func_ceiling)},
{ { C_STRING_WITH_LEN("CENTROID") }, GEOM_BUILDER(Create_func_centroid)},
{ { C_STRING_WITH_LEN("CHARACTER_LENGTH") }, BUILDER(Create_func_char_length)},
{ { C_STRING_WITH_LEN("CHAR_LENGTH") }, BUILDER(Create_func_char_length)},
{ { C_STRING_WITH_LEN("CHR") }, BUILDER(Create_func_chr)},
{ { C_STRING_WITH_LEN("COERCIBILITY") }, BUILDER(Create_func_coercibility)},
{ { C_STRING_WITH_LEN("COLUMN_CHECK") }, BUILDER(Create_func_dyncol_check)},
{ { C_STRING_WITH_LEN("COLUMN_EXISTS") }, BUILDER(Create_func_dyncol_exists)},
{ { C_STRING_WITH_LEN("COLUMN_LIST") }, BUILDER(Create_func_dyncol_list)},
{ { C_STRING_WITH_LEN("COLUMN_JSON") }, BUILDER(Create_func_dyncol_json)},
{ { C_STRING_WITH_LEN("COMPRESS") }, BUILDER(Create_func_compress)},
{ { C_STRING_WITH_LEN("CONCAT") }, BUILDER(Create_func_concat)},
{ { C_STRING_WITH_LEN("CONCAT_OPERATOR_ORACLE") }, BUILDER(Create_func_concat_operator_oracle)},
{ { C_STRING_WITH_LEN("CONCAT_WS") }, BUILDER(Create_func_concat_ws)},
{ { C_STRING_WITH_LEN("CONNECTION_ID") }, BUILDER(Create_func_connection_id)},
{ { C_STRING_WITH_LEN("CONV") }, BUILDER(Create_func_conv)},
{ { C_STRING_WITH_LEN("CONVERT_TZ") }, BUILDER(Create_func_convert_tz)},
{ { C_STRING_WITH_LEN("CONVEXHULL") }, GEOM_BUILDER(Create_func_convexhull)},
{ { C_STRING_WITH_LEN("COS") }, BUILDER(Create_func_cos)},
{ { C_STRING_WITH_LEN("COT") }, BUILDER(Create_func_cot)},
{ { C_STRING_WITH_LEN("CRC32") }, BUILDER(Create_func_crc32)},
{ { C_STRING_WITH_LEN("CROSSES") }, GEOM_BUILDER(Create_func_crosses)},
{ { C_STRING_WITH_LEN("DATEDIFF") }, BUILDER(Create_func_datediff)},
{ { C_STRING_WITH_LEN("DAYNAME") }, BUILDER(Create_func_dayname)},
{ { C_STRING_WITH_LEN("DAYOFMONTH") }, BUILDER(Create_func_dayofmonth)},
{ { C_STRING_WITH_LEN("DAYOFWEEK") }, BUILDER(Create_func_dayofweek)},
{ { C_STRING_WITH_LEN("DAYOFYEAR") }, BUILDER(Create_func_dayofyear)},
{ { C_STRING_WITH_LEN("DEGREES") }, BUILDER(Create_func_degrees)},
{ { C_STRING_WITH_LEN("DECODE_HISTOGRAM") }, BUILDER(Create_func_decode_histogram)},
{ { C_STRING_WITH_LEN("DECODE_ORACLE") }, BUILDER(Create_func_decode_oracle)},
{ { C_STRING_WITH_LEN("DES_DECRYPT") }, BUILDER(Create_func_des_decrypt)},
{ { C_STRING_WITH_LEN("DES_ENCRYPT") }, BUILDER(Create_func_des_encrypt)},
{ { C_STRING_WITH_LEN("DIMENSION") }, GEOM_BUILDER(Create_func_dimension)},
{ { C_STRING_WITH_LEN("DISJOINT") }, GEOM_BUILDER(Create_func_mbr_disjoint)},
{ { C_STRING_WITH_LEN("ELT") }, BUILDER(Create_func_elt)},
{ { C_STRING_WITH_LEN("ENCODE") }, BUILDER(Create_func_encode)},
{ { C_STRING_WITH_LEN("ENCRYPT") }, BUILDER(Create_func_encrypt)},
{ { C_STRING_WITH_LEN("ENDPOINT") }, GEOM_BUILDER(Create_func_endpoint)},
{ { C_STRING_WITH_LEN("ENVELOPE") }, GEOM_BUILDER(Create_func_envelope)},
{ { C_STRING_WITH_LEN("EQUALS") }, GEOM_BUILDER(Create_func_equals)},
{ { C_STRING_WITH_LEN("EXP") }, BUILDER(Create_func_exp)},
{ { C_STRING_WITH_LEN("EXPORT_SET") }, BUILDER(Create_func_export_set)},
{ { C_STRING_WITH_LEN("EXTERIORRING") }, GEOM_BUILDER(Create_func_exteriorring)},
{ { C_STRING_WITH_LEN("EXTRACTVALUE") }, BUILDER(Create_func_xml_extractvalue)},
{ { C_STRING_WITH_LEN("FIELD") }, BUILDER(Create_func_field)},
{ { C_STRING_WITH_LEN("FIND_IN_SET") }, BUILDER(Create_func_find_in_set)},
{ { C_STRING_WITH_LEN("FLOOR") }, BUILDER(Create_func_floor)},
{ { C_STRING_WITH_LEN("FORMAT") }, BUILDER(Create_func_format)},
{ { C_STRING_WITH_LEN("FOUND_ROWS") }, BUILDER(Create_func_found_rows)},
{ { C_STRING_WITH_LEN("FROM_BASE64") }, BUILDER(Create_func_from_base64)},
{ { C_STRING_WITH_LEN("FROM_DAYS") }, BUILDER(Create_func_from_days)},
{ { C_STRING_WITH_LEN("FROM_UNIXTIME") }, BUILDER(Create_func_from_unixtime)},
{ { C_STRING_WITH_LEN("GEOMCOLLFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("GEOMCOLLFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("GEOMETRYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("GEOMETRYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("GEOMETRYN") }, GEOM_BUILDER(Create_func_geometryn)},
{ { C_STRING_WITH_LEN("GEOMETRYTYPE") }, GEOM_BUILDER(Create_func_geometry_type)},
{ { C_STRING_WITH_LEN("GEOMFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("GEOMFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("GET_LOCK") }, BUILDER(Create_func_get_lock)},
{ { C_STRING_WITH_LEN("GLENGTH") }, GEOM_BUILDER(Create_func_glength)},
{ { C_STRING_WITH_LEN("GREATEST") }, BUILDER(Create_func_greatest)},
{ { C_STRING_WITH_LEN("HEX") }, BUILDER(Create_func_hex)},
{ { C_STRING_WITH_LEN("IFNULL") }, BUILDER(Create_func_ifnull)},
{ { C_STRING_WITH_LEN("INET_ATON") }, BUILDER(Create_func_inet_aton)},
{ { C_STRING_WITH_LEN("INET_NTOA") }, BUILDER(Create_func_inet_ntoa)},
{ { C_STRING_WITH_LEN("INET6_ATON") }, BUILDER(Create_func_inet6_aton)},
{ { C_STRING_WITH_LEN("INET6_NTOA") }, BUILDER(Create_func_inet6_ntoa)},
{ { C_STRING_WITH_LEN("IS_IPV4") }, BUILDER(Create_func_is_ipv4)},
{ { C_STRING_WITH_LEN("IS_IPV6") }, BUILDER(Create_func_is_ipv6)},
{ { C_STRING_WITH_LEN("IS_IPV4_COMPAT") }, BUILDER(Create_func_is_ipv4_compat)},
{ { C_STRING_WITH_LEN("IS_IPV4_MAPPED") }, BUILDER(Create_func_is_ipv4_mapped)},
{ { C_STRING_WITH_LEN("INSTR") }, BUILDER(Create_func_instr)},
{ { C_STRING_WITH_LEN("INTERIORRINGN") }, GEOM_BUILDER(Create_func_interiorringn)},
{ { C_STRING_WITH_LEN("INTERSECTS") }, GEOM_BUILDER(Create_func_mbr_intersects)},
{ { C_STRING_WITH_LEN("ISCLOSED") }, GEOM_BUILDER(Create_func_isclosed)},
{ { C_STRING_WITH_LEN("ISEMPTY") }, GEOM_BUILDER(Create_func_isempty)},
{ { C_STRING_WITH_LEN("ISNULL") }, BUILDER(Create_func_isnull)},
{ { C_STRING_WITH_LEN("ISRING") }, GEOM_BUILDER(Create_func_isring)},
{ { C_STRING_WITH_LEN("ISSIMPLE") }, GEOM_BUILDER(Create_func_issimple)},
{ { C_STRING_WITH_LEN("IS_FREE_LOCK") }, BUILDER(Create_func_is_free_lock)},
{ { C_STRING_WITH_LEN("IS_USED_LOCK") }, BUILDER(Create_func_is_used_lock)},
{ { C_STRING_WITH_LEN("JSON_ARRAY") }, BUILDER(Create_func_json_array)},
{ { C_STRING_WITH_LEN("JSON_ARRAY_APPEND") }, BUILDER(Create_func_json_array_append)},
{ { C_STRING_WITH_LEN("JSON_ARRAY_INSERT") }, BUILDER(Create_func_json_array_insert)},
{ { C_STRING_WITH_LEN("JSON_COMPACT") }, BUILDER(Create_func_json_compact)},
{ { C_STRING_WITH_LEN("JSON_CONTAINS") }, BUILDER(Create_func_json_contains)},
{ { C_STRING_WITH_LEN("JSON_CONTAINS_PATH") }, BUILDER(Create_func_json_contains_path)},
{ { C_STRING_WITH_LEN("JSON_DEPTH") }, BUILDER(Create_func_json_depth)},
{ { C_STRING_WITH_LEN("JSON_DETAILED") }, BUILDER(Create_func_json_detailed)},
{ { C_STRING_WITH_LEN("JSON_EXISTS") }, BUILDER(Create_func_json_exists)},
{ { C_STRING_WITH_LEN("JSON_EXTRACT") }, BUILDER(Create_func_json_extract)},
{ { C_STRING_WITH_LEN("JSON_INSERT") }, BUILDER(Create_func_json_insert)},
{ { C_STRING_WITH_LEN("JSON_KEYS") }, BUILDER(Create_func_json_keys)},
{ { C_STRING_WITH_LEN("JSON_LENGTH") }, BUILDER(Create_func_json_length)},
{ { C_STRING_WITH_LEN("JSON_LOOSE") }, BUILDER(Create_func_json_loose)},
{ { C_STRING_WITH_LEN("JSON_MERGE") }, BUILDER(Create_func_json_merge)},
{ { C_STRING_WITH_LEN("JSON_QUERY") }, BUILDER(Create_func_json_query)},
{ { C_STRING_WITH_LEN("JSON_QUOTE") }, BUILDER(Create_func_json_quote)},
{ { C_STRING_WITH_LEN("JSON_OBJECT") }, BUILDER(Create_func_json_object)},
{ { C_STRING_WITH_LEN("JSON_REMOVE") }, BUILDER(Create_func_json_remove)},
{ { C_STRING_WITH_LEN("JSON_REPLACE") }, BUILDER(Create_func_json_replace)},
{ { C_STRING_WITH_LEN("JSON_SET") }, BUILDER(Create_func_json_set)},
{ { C_STRING_WITH_LEN("JSON_SEARCH") }, BUILDER(Create_func_json_search)},
{ { C_STRING_WITH_LEN("JSON_TYPE") }, BUILDER(Create_func_json_type)},
{ { C_STRING_WITH_LEN("JSON_UNQUOTE") }, BUILDER(Create_func_json_unquote)},
{ { C_STRING_WITH_LEN("JSON_VALID") }, BUILDER(Create_func_json_valid)},
{ { C_STRING_WITH_LEN("JSON_VALUE") }, BUILDER(Create_func_json_value)},
{ { C_STRING_WITH_LEN("LAST_DAY") }, BUILDER(Create_func_last_day)},
{ { C_STRING_WITH_LEN("LAST_INSERT_ID") }, BUILDER(Create_func_last_insert_id)},
{ { C_STRING_WITH_LEN("LCASE") }, BUILDER(Create_func_lcase)},
{ { C_STRING_WITH_LEN("LEAST") }, BUILDER(Create_func_least)},
{ { C_STRING_WITH_LEN("LENGTH") }, BUILDER(Create_func_length)},
{ { C_STRING_WITH_LEN("LENGTHB") }, BUILDER(Create_func_octet_length)},
{ { STRING_WITH_LEN("ABS") }, BUILDER(Create_func_abs)},
{ { STRING_WITH_LEN("ACOS") }, BUILDER(Create_func_acos)},
{ { STRING_WITH_LEN("ADDTIME") }, BUILDER(Create_func_addtime)},
{ { STRING_WITH_LEN("AES_DECRYPT") }, BUILDER(Create_func_aes_decrypt)},
{ { STRING_WITH_LEN("AES_ENCRYPT") }, BUILDER(Create_func_aes_encrypt)},
{ { STRING_WITH_LEN("AREA") }, GEOM_BUILDER(Create_func_area)},
{ { STRING_WITH_LEN("ASBINARY") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { STRING_WITH_LEN("ASIN") }, BUILDER(Create_func_asin)},
{ { STRING_WITH_LEN("ASTEXT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { STRING_WITH_LEN("ASWKB") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { STRING_WITH_LEN("ASWKT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { STRING_WITH_LEN("ATAN") }, BUILDER(Create_func_atan)},
{ { STRING_WITH_LEN("ATAN2") }, BUILDER(Create_func_atan)},
{ { STRING_WITH_LEN("BENCHMARK") }, BUILDER(Create_func_benchmark)},
{ { STRING_WITH_LEN("BIN") }, BUILDER(Create_func_bin)},
{ { STRING_WITH_LEN("BINLOG_GTID_POS") }, BUILDER(Create_func_binlog_gtid_pos)},
{ { STRING_WITH_LEN("BIT_COUNT") }, BUILDER(Create_func_bit_count)},
{ { STRING_WITH_LEN("BIT_LENGTH") }, BUILDER(Create_func_bit_length)},
{ { STRING_WITH_LEN("BOUNDARY") }, GEOM_BUILDER(Create_func_boundary)},
{ { STRING_WITH_LEN("BUFFER") }, GEOM_BUILDER(Create_func_buffer)},
{ { STRING_WITH_LEN("CEIL") }, BUILDER(Create_func_ceiling)},
{ { STRING_WITH_LEN("CEILING") }, BUILDER(Create_func_ceiling)},
{ { STRING_WITH_LEN("CENTROID") }, GEOM_BUILDER(Create_func_centroid)},
{ { STRING_WITH_LEN("CHARACTER_LENGTH") }, BUILDER(Create_func_char_length)},
{ { STRING_WITH_LEN("CHAR_LENGTH") }, BUILDER(Create_func_char_length)},
{ { STRING_WITH_LEN("CHR") }, BUILDER(Create_func_chr)},
{ { STRING_WITH_LEN("COERCIBILITY") }, BUILDER(Create_func_coercibility)},
{ { STRING_WITH_LEN("COLUMN_CHECK") }, BUILDER(Create_func_dyncol_check)},
{ { STRING_WITH_LEN("COLUMN_EXISTS") }, BUILDER(Create_func_dyncol_exists)},
{ { STRING_WITH_LEN("COLUMN_LIST") }, BUILDER(Create_func_dyncol_list)},
{ { STRING_WITH_LEN("COLUMN_JSON") }, BUILDER(Create_func_dyncol_json)},
{ { STRING_WITH_LEN("COMPRESS") }, BUILDER(Create_func_compress)},
{ { STRING_WITH_LEN("CONCAT") }, BUILDER(Create_func_concat)},
{ { STRING_WITH_LEN("CONCAT_OPERATOR_ORACLE") }, BUILDER(Create_func_concat_operator_oracle)},
{ { STRING_WITH_LEN("CONCAT_WS") }, BUILDER(Create_func_concat_ws)},
{ { STRING_WITH_LEN("CONNECTION_ID") }, BUILDER(Create_func_connection_id)},
{ { STRING_WITH_LEN("CONV") }, BUILDER(Create_func_conv)},
{ { STRING_WITH_LEN("CONVERT_TZ") }, BUILDER(Create_func_convert_tz)},
{ { STRING_WITH_LEN("CONVEXHULL") }, GEOM_BUILDER(Create_func_convexhull)},
{ { STRING_WITH_LEN("COS") }, BUILDER(Create_func_cos)},
{ { STRING_WITH_LEN("COT") }, BUILDER(Create_func_cot)},
{ { STRING_WITH_LEN("CRC32") }, BUILDER(Create_func_crc32)},
{ { STRING_WITH_LEN("CROSSES") }, GEOM_BUILDER(Create_func_crosses)},
{ { STRING_WITH_LEN("DATEDIFF") }, BUILDER(Create_func_datediff)},
{ { STRING_WITH_LEN("DAYNAME") }, BUILDER(Create_func_dayname)},
{ { STRING_WITH_LEN("DAYOFMONTH") }, BUILDER(Create_func_dayofmonth)},
{ { STRING_WITH_LEN("DAYOFWEEK") }, BUILDER(Create_func_dayofweek)},
{ { STRING_WITH_LEN("DAYOFYEAR") }, BUILDER(Create_func_dayofyear)},
{ { STRING_WITH_LEN("DEGREES") }, BUILDER(Create_func_degrees)},
{ { STRING_WITH_LEN("DECODE_HISTOGRAM") }, BUILDER(Create_func_decode_histogram)},
{ { STRING_WITH_LEN("DECODE_ORACLE") }, BUILDER(Create_func_decode_oracle)},
{ { STRING_WITH_LEN("DES_DECRYPT") }, BUILDER(Create_func_des_decrypt)},
{ { STRING_WITH_LEN("DES_ENCRYPT") }, BUILDER(Create_func_des_encrypt)},
{ { STRING_WITH_LEN("DIMENSION") }, GEOM_BUILDER(Create_func_dimension)},
{ { STRING_WITH_LEN("DISJOINT") }, GEOM_BUILDER(Create_func_mbr_disjoint)},
{ { STRING_WITH_LEN("ELT") }, BUILDER(Create_func_elt)},
{ { STRING_WITH_LEN("ENCODE") }, BUILDER(Create_func_encode)},
{ { STRING_WITH_LEN("ENCRYPT") }, BUILDER(Create_func_encrypt)},
{ { STRING_WITH_LEN("ENDPOINT") }, GEOM_BUILDER(Create_func_endpoint)},
{ { STRING_WITH_LEN("ENVELOPE") }, GEOM_BUILDER(Create_func_envelope)},
{ { STRING_WITH_LEN("EQUALS") }, GEOM_BUILDER(Create_func_equals)},
{ { STRING_WITH_LEN("EXP") }, BUILDER(Create_func_exp)},
{ { STRING_WITH_LEN("EXPORT_SET") }, BUILDER(Create_func_export_set)},
{ { STRING_WITH_LEN("EXTERIORRING") }, GEOM_BUILDER(Create_func_exteriorring)},
{ { STRING_WITH_LEN("EXTRACTVALUE") }, BUILDER(Create_func_xml_extractvalue)},
{ { STRING_WITH_LEN("FIELD") }, BUILDER(Create_func_field)},
{ { STRING_WITH_LEN("FIND_IN_SET") }, BUILDER(Create_func_find_in_set)},
{ { STRING_WITH_LEN("FLOOR") }, BUILDER(Create_func_floor)},
{ { STRING_WITH_LEN("FORMAT") }, BUILDER(Create_func_format)},
{ { STRING_WITH_LEN("FOUND_ROWS") }, BUILDER(Create_func_found_rows)},
{ { STRING_WITH_LEN("FROM_BASE64") }, BUILDER(Create_func_from_base64)},
{ { STRING_WITH_LEN("FROM_DAYS") }, BUILDER(Create_func_from_days)},
{ { STRING_WITH_LEN("FROM_UNIXTIME") }, BUILDER(Create_func_from_unixtime)},
{ { STRING_WITH_LEN("GEOMCOLLFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("GEOMCOLLFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("GEOMETRYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("GEOMETRYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("GEOMETRYN") }, GEOM_BUILDER(Create_func_geometryn)},
{ { STRING_WITH_LEN("GEOMETRYTYPE") }, GEOM_BUILDER(Create_func_geometry_type)},
{ { STRING_WITH_LEN("GEOMFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("GEOMFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("GET_LOCK") }, BUILDER(Create_func_get_lock)},
{ { STRING_WITH_LEN("GLENGTH") }, GEOM_BUILDER(Create_func_glength)},
{ { STRING_WITH_LEN("GREATEST") }, BUILDER(Create_func_greatest)},
{ { STRING_WITH_LEN("HEX") }, BUILDER(Create_func_hex)},
{ { STRING_WITH_LEN("IFNULL") }, BUILDER(Create_func_ifnull)},
{ { STRING_WITH_LEN("INET_ATON") }, BUILDER(Create_func_inet_aton)},
{ { STRING_WITH_LEN("INET_NTOA") }, BUILDER(Create_func_inet_ntoa)},
{ { STRING_WITH_LEN("INET6_ATON") }, BUILDER(Create_func_inet6_aton)},
{ { STRING_WITH_LEN("INET6_NTOA") }, BUILDER(Create_func_inet6_ntoa)},
{ { STRING_WITH_LEN("IS_IPV4") }, BUILDER(Create_func_is_ipv4)},
{ { STRING_WITH_LEN("IS_IPV6") }, BUILDER(Create_func_is_ipv6)},
{ { STRING_WITH_LEN("IS_IPV4_COMPAT") }, BUILDER(Create_func_is_ipv4_compat)},
{ { STRING_WITH_LEN("IS_IPV4_MAPPED") }, BUILDER(Create_func_is_ipv4_mapped)},
{ { STRING_WITH_LEN("INSTR") }, BUILDER(Create_func_instr)},
{ { STRING_WITH_LEN("INTERIORRINGN") }, GEOM_BUILDER(Create_func_interiorringn)},
{ { STRING_WITH_LEN("INTERSECTS") }, GEOM_BUILDER(Create_func_mbr_intersects)},
{ { STRING_WITH_LEN("ISCLOSED") }, GEOM_BUILDER(Create_func_isclosed)},
{ { STRING_WITH_LEN("ISEMPTY") }, GEOM_BUILDER(Create_func_isempty)},
{ { STRING_WITH_LEN("ISNULL") }, BUILDER(Create_func_isnull)},
{ { STRING_WITH_LEN("ISRING") }, GEOM_BUILDER(Create_func_isring)},
{ { STRING_WITH_LEN("ISSIMPLE") }, GEOM_BUILDER(Create_func_issimple)},
{ { STRING_WITH_LEN("IS_FREE_LOCK") }, BUILDER(Create_func_is_free_lock)},
{ { STRING_WITH_LEN("IS_USED_LOCK") }, BUILDER(Create_func_is_used_lock)},
{ { STRING_WITH_LEN("JSON_ARRAY") }, BUILDER(Create_func_json_array)},
{ { STRING_WITH_LEN("JSON_ARRAY_APPEND") }, BUILDER(Create_func_json_array_append)},
{ { STRING_WITH_LEN("JSON_ARRAY_INSERT") }, BUILDER(Create_func_json_array_insert)},
{ { STRING_WITH_LEN("JSON_COMPACT") }, BUILDER(Create_func_json_compact)},
{ { STRING_WITH_LEN("JSON_CONTAINS") }, BUILDER(Create_func_json_contains)},
{ { STRING_WITH_LEN("JSON_CONTAINS_PATH") }, BUILDER(Create_func_json_contains_path)},
{ { STRING_WITH_LEN("JSON_DEPTH") }, BUILDER(Create_func_json_depth)},
{ { STRING_WITH_LEN("JSON_DETAILED") }, BUILDER(Create_func_json_detailed)},
{ { STRING_WITH_LEN("JSON_EXISTS") }, BUILDER(Create_func_json_exists)},
{ { STRING_WITH_LEN("JSON_EXTRACT") }, BUILDER(Create_func_json_extract)},
{ { STRING_WITH_LEN("JSON_INSERT") }, BUILDER(Create_func_json_insert)},
{ { STRING_WITH_LEN("JSON_KEYS") }, BUILDER(Create_func_json_keys)},
{ { STRING_WITH_LEN("JSON_LENGTH") }, BUILDER(Create_func_json_length)},
{ { STRING_WITH_LEN("JSON_LOOSE") }, BUILDER(Create_func_json_loose)},
{ { STRING_WITH_LEN("JSON_MERGE") }, BUILDER(Create_func_json_merge)},
{ { STRING_WITH_LEN("JSON_QUERY") }, BUILDER(Create_func_json_query)},
{ { STRING_WITH_LEN("JSON_QUOTE") }, BUILDER(Create_func_json_quote)},
{ { STRING_WITH_LEN("JSON_OBJECT") }, BUILDER(Create_func_json_object)},
{ { STRING_WITH_LEN("JSON_REMOVE") }, BUILDER(Create_func_json_remove)},
{ { STRING_WITH_LEN("JSON_REPLACE") }, BUILDER(Create_func_json_replace)},
{ { STRING_WITH_LEN("JSON_SET") }, BUILDER(Create_func_json_set)},
{ { STRING_WITH_LEN("JSON_SEARCH") }, BUILDER(Create_func_json_search)},
{ { STRING_WITH_LEN("JSON_TYPE") }, BUILDER(Create_func_json_type)},
{ { STRING_WITH_LEN("JSON_UNQUOTE") }, BUILDER(Create_func_json_unquote)},
{ { STRING_WITH_LEN("JSON_VALID") }, BUILDER(Create_func_json_valid)},
{ { STRING_WITH_LEN("JSON_VALUE") }, BUILDER(Create_func_json_value)},
{ { STRING_WITH_LEN("LAST_DAY") }, BUILDER(Create_func_last_day)},
{ { STRING_WITH_LEN("LAST_INSERT_ID") }, BUILDER(Create_func_last_insert_id)},
{ { STRING_WITH_LEN("LCASE") }, BUILDER(Create_func_lcase)},
{ { STRING_WITH_LEN("LEAST") }, BUILDER(Create_func_least)},
{ { STRING_WITH_LEN("LENGTH") }, BUILDER(Create_func_length)},
{ { STRING_WITH_LEN("LENGTHB") }, BUILDER(Create_func_octet_length)},
#ifndef DBUG_OFF
{ { C_STRING_WITH_LEN("LIKE_RANGE_MIN") }, BUILDER(Create_func_like_range_min)},
{ { C_STRING_WITH_LEN("LIKE_RANGE_MAX") }, BUILDER(Create_func_like_range_max)},
{ { STRING_WITH_LEN("LIKE_RANGE_MIN") }, BUILDER(Create_func_like_range_min)},
{ { STRING_WITH_LEN("LIKE_RANGE_MAX") }, BUILDER(Create_func_like_range_max)},
#endif
{ { C_STRING_WITH_LEN("LINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("LINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("LINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("LINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("LN") }, BUILDER(Create_func_ln)},
{ { C_STRING_WITH_LEN("LOAD_FILE") }, BUILDER(Create_func_load_file)},
{ { C_STRING_WITH_LEN("LOCATE") }, BUILDER(Create_func_locate)},
{ { C_STRING_WITH_LEN("LOG") }, BUILDER(Create_func_log)},
{ { C_STRING_WITH_LEN("LOG10") }, BUILDER(Create_func_log10)},
{ { C_STRING_WITH_LEN("LOG2") }, BUILDER(Create_func_log2)},
{ { C_STRING_WITH_LEN("LOWER") }, BUILDER(Create_func_lcase)},
{ { C_STRING_WITH_LEN("LPAD") }, BUILDER(Create_func_lpad)},
{ { C_STRING_WITH_LEN("LTRIM") }, BUILDER(Create_func_ltrim)},
{ { C_STRING_WITH_LEN("MAKEDATE") }, BUILDER(Create_func_makedate)},
{ { C_STRING_WITH_LEN("MAKETIME") }, BUILDER(Create_func_maketime)},
{ { C_STRING_WITH_LEN("MAKE_SET") }, BUILDER(Create_func_make_set)},
{ { C_STRING_WITH_LEN("MASTER_GTID_WAIT") }, BUILDER(Create_func_master_gtid_wait)},
{ { C_STRING_WITH_LEN("MASTER_POS_WAIT") }, BUILDER(Create_func_master_pos_wait)},
{ { C_STRING_WITH_LEN("MBRCONTAINS") }, GEOM_BUILDER(Create_func_mbr_contains)},
{ { C_STRING_WITH_LEN("MBRDISJOINT") }, GEOM_BUILDER(Create_func_mbr_disjoint)},
{ { C_STRING_WITH_LEN("MBREQUAL") }, GEOM_BUILDER(Create_func_mbr_equals)},
{ { C_STRING_WITH_LEN("MBREQUALS") }, GEOM_BUILDER(Create_func_mbr_equals)},
{ { C_STRING_WITH_LEN("MBRINTERSECTS") }, GEOM_BUILDER(Create_func_mbr_intersects)},
{ { C_STRING_WITH_LEN("MBROVERLAPS") }, GEOM_BUILDER(Create_func_mbr_overlaps)},
{ { C_STRING_WITH_LEN("MBRTOUCHES") }, GEOM_BUILDER(Create_func_touches)},
{ { C_STRING_WITH_LEN("MBRWITHIN") }, GEOM_BUILDER(Create_func_mbr_within)},
{ { C_STRING_WITH_LEN("MD5") }, BUILDER(Create_func_md5)},
{ { C_STRING_WITH_LEN("MLINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MLINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("MONTHNAME") }, BUILDER(Create_func_monthname)},
{ { C_STRING_WITH_LEN("MPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("MPOLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MPOLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("MULTILINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MULTILINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("MULTIPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MULTIPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("MULTIPOLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MULTIPOLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("NAME_CONST") }, BUILDER(Create_func_name_const)},
{ { C_STRING_WITH_LEN("NVL") }, BUILDER(Create_func_ifnull)},
{ { C_STRING_WITH_LEN("NVL2") }, BUILDER(Create_func_nvl2)},
{ { C_STRING_WITH_LEN("NULLIF") }, BUILDER(Create_func_nullif)},
{ { C_STRING_WITH_LEN("NUMGEOMETRIES") }, GEOM_BUILDER(Create_func_numgeometries)},
{ { C_STRING_WITH_LEN("NUMINTERIORRINGS") }, GEOM_BUILDER(Create_func_numinteriorring)},
{ { C_STRING_WITH_LEN("NUMPOINTS") }, GEOM_BUILDER(Create_func_numpoints)},
{ { C_STRING_WITH_LEN("OCT") }, BUILDER(Create_func_oct)},
{ { C_STRING_WITH_LEN("OCTET_LENGTH") }, BUILDER(Create_func_octet_length)},
{ { C_STRING_WITH_LEN("ORD") }, BUILDER(Create_func_ord)},
{ { C_STRING_WITH_LEN("OVERLAPS") }, GEOM_BUILDER(Create_func_mbr_overlaps)},
{ { C_STRING_WITH_LEN("PERIOD_ADD") }, BUILDER(Create_func_period_add)},
{ { C_STRING_WITH_LEN("PERIOD_DIFF") }, BUILDER(Create_func_period_diff)},
{ { C_STRING_WITH_LEN("PI") }, BUILDER(Create_func_pi)},
{ { C_STRING_WITH_LEN("POINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("POINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("POINTN") }, GEOM_BUILDER(Create_func_pointn)},
{ { C_STRING_WITH_LEN("POINTONSURFACE") }, GEOM_BUILDER(Create_func_pointonsurface)},
{ { C_STRING_WITH_LEN("POLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("POLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("POLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("POLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("POW") }, BUILDER(Create_func_pow)},
{ { C_STRING_WITH_LEN("POWER") }, BUILDER(Create_func_pow)},
{ { C_STRING_WITH_LEN("QUOTE") }, BUILDER(Create_func_quote)},
{ { C_STRING_WITH_LEN("REGEXP_INSTR") }, BUILDER(Create_func_regexp_instr)},
{ { C_STRING_WITH_LEN("REGEXP_REPLACE") }, BUILDER(Create_func_regexp_replace)},
{ { C_STRING_WITH_LEN("REGEXP_SUBSTR") }, BUILDER(Create_func_regexp_substr)},
{ { C_STRING_WITH_LEN("RADIANS") }, BUILDER(Create_func_radians)},
{ { C_STRING_WITH_LEN("RAND") }, BUILDER(Create_func_rand)},
{ { C_STRING_WITH_LEN("RELEASE_LOCK") }, BUILDER(Create_func_release_lock)},
{ { C_STRING_WITH_LEN("REPLACE_ORACLE") },
{ { STRING_WITH_LEN("LINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("LINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("LINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("LINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("LN") }, BUILDER(Create_func_ln)},
{ { STRING_WITH_LEN("LOAD_FILE") }, BUILDER(Create_func_load_file)},
{ { STRING_WITH_LEN("LOCATE") }, BUILDER(Create_func_locate)},
{ { STRING_WITH_LEN("LOG") }, BUILDER(Create_func_log)},
{ { STRING_WITH_LEN("LOG10") }, BUILDER(Create_func_log10)},
{ { STRING_WITH_LEN("LOG2") }, BUILDER(Create_func_log2)},
{ { STRING_WITH_LEN("LOWER") }, BUILDER(Create_func_lcase)},
{ { STRING_WITH_LEN("LPAD") }, BUILDER(Create_func_lpad)},
{ { STRING_WITH_LEN("LTRIM") }, BUILDER(Create_func_ltrim)},
{ { STRING_WITH_LEN("MAKEDATE") }, BUILDER(Create_func_makedate)},
{ { STRING_WITH_LEN("MAKETIME") }, BUILDER(Create_func_maketime)},
{ { STRING_WITH_LEN("MAKE_SET") }, BUILDER(Create_func_make_set)},
{ { STRING_WITH_LEN("MASTER_GTID_WAIT") }, BUILDER(Create_func_master_gtid_wait)},
{ { STRING_WITH_LEN("MASTER_POS_WAIT") }, BUILDER(Create_func_master_pos_wait)},
{ { STRING_WITH_LEN("MBRCONTAINS") }, GEOM_BUILDER(Create_func_mbr_contains)},
{ { STRING_WITH_LEN("MBRDISJOINT") }, GEOM_BUILDER(Create_func_mbr_disjoint)},
{ { STRING_WITH_LEN("MBREQUAL") }, GEOM_BUILDER(Create_func_mbr_equals)},
{ { STRING_WITH_LEN("MBREQUALS") }, GEOM_BUILDER(Create_func_mbr_equals)},
{ { STRING_WITH_LEN("MBRINTERSECTS") }, GEOM_BUILDER(Create_func_mbr_intersects)},
{ { STRING_WITH_LEN("MBROVERLAPS") }, GEOM_BUILDER(Create_func_mbr_overlaps)},
{ { STRING_WITH_LEN("MBRTOUCHES") }, GEOM_BUILDER(Create_func_touches)},
{ { STRING_WITH_LEN("MBRWITHIN") }, GEOM_BUILDER(Create_func_mbr_within)},
{ { STRING_WITH_LEN("MD5") }, BUILDER(Create_func_md5)},
{ { STRING_WITH_LEN("MLINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("MLINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("MONTHNAME") }, BUILDER(Create_func_monthname)},
{ { STRING_WITH_LEN("MPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("MPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("MPOLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("MPOLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("MULTILINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("MULTILINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("MULTIPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("MULTIPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("MULTIPOLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("MULTIPOLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("NAME_CONST") }, BUILDER(Create_func_name_const)},
{ { STRING_WITH_LEN("NVL") }, BUILDER(Create_func_ifnull)},
{ { STRING_WITH_LEN("NVL2") }, BUILDER(Create_func_nvl2)},
{ { STRING_WITH_LEN("NULLIF") }, BUILDER(Create_func_nullif)},
{ { STRING_WITH_LEN("NUMGEOMETRIES") }, GEOM_BUILDER(Create_func_numgeometries)},
{ { STRING_WITH_LEN("NUMINTERIORRINGS") }, GEOM_BUILDER(Create_func_numinteriorring)},
{ { STRING_WITH_LEN("NUMPOINTS") }, GEOM_BUILDER(Create_func_numpoints)},
{ { STRING_WITH_LEN("OCT") }, BUILDER(Create_func_oct)},
{ { STRING_WITH_LEN("OCTET_LENGTH") }, BUILDER(Create_func_octet_length)},
{ { STRING_WITH_LEN("ORD") }, BUILDER(Create_func_ord)},
{ { STRING_WITH_LEN("OVERLAPS") }, GEOM_BUILDER(Create_func_mbr_overlaps)},
{ { STRING_WITH_LEN("PERIOD_ADD") }, BUILDER(Create_func_period_add)},
{ { STRING_WITH_LEN("PERIOD_DIFF") }, BUILDER(Create_func_period_diff)},
{ { STRING_WITH_LEN("PI") }, BUILDER(Create_func_pi)},
{ { STRING_WITH_LEN("POINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("POINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("POINTN") }, GEOM_BUILDER(Create_func_pointn)},
{ { STRING_WITH_LEN("POINTONSURFACE") }, GEOM_BUILDER(Create_func_pointonsurface)},
{ { STRING_WITH_LEN("POLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("POLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("POLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("POLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("POW") }, BUILDER(Create_func_pow)},
{ { STRING_WITH_LEN("POWER") }, BUILDER(Create_func_pow)},
{ { STRING_WITH_LEN("QUOTE") }, BUILDER(Create_func_quote)},
{ { STRING_WITH_LEN("REGEXP_INSTR") }, BUILDER(Create_func_regexp_instr)},
{ { STRING_WITH_LEN("REGEXP_REPLACE") }, BUILDER(Create_func_regexp_replace)},
{ { STRING_WITH_LEN("REGEXP_SUBSTR") }, BUILDER(Create_func_regexp_substr)},
{ { STRING_WITH_LEN("RADIANS") }, BUILDER(Create_func_radians)},
{ { STRING_WITH_LEN("RAND") }, BUILDER(Create_func_rand)},
{ { STRING_WITH_LEN("RELEASE_LOCK") }, BUILDER(Create_func_release_lock)},
{ { STRING_WITH_LEN("REPLACE_ORACLE") },
BUILDER(Create_func_replace_oracle)},
{ { C_STRING_WITH_LEN("REVERSE") }, BUILDER(Create_func_reverse)},
{ { C_STRING_WITH_LEN("ROUND") }, BUILDER(Create_func_round)},
{ { C_STRING_WITH_LEN("RPAD") }, BUILDER(Create_func_rpad)},
{ { C_STRING_WITH_LEN("RTRIM") }, BUILDER(Create_func_rtrim)},
{ { C_STRING_WITH_LEN("SEC_TO_TIME") }, BUILDER(Create_func_sec_to_time)},
{ { C_STRING_WITH_LEN("SHA") }, BUILDER(Create_func_sha)},
{ { C_STRING_WITH_LEN("SHA1") }, BUILDER(Create_func_sha)},
{ { C_STRING_WITH_LEN("SHA2") }, BUILDER(Create_func_sha2)},
{ { C_STRING_WITH_LEN("SIGN") }, BUILDER(Create_func_sign)},
{ { C_STRING_WITH_LEN("SIN") }, BUILDER(Create_func_sin)},
{ { C_STRING_WITH_LEN("SLEEP") }, BUILDER(Create_func_sleep)},
{ { C_STRING_WITH_LEN("SOUNDEX") }, BUILDER(Create_func_soundex)},
{ { C_STRING_WITH_LEN("SPACE") }, BUILDER(Create_func_space)},
{ { C_STRING_WITH_LEN("SQRT") }, BUILDER(Create_func_sqrt)},
{ { C_STRING_WITH_LEN("SRID") }, GEOM_BUILDER(Create_func_srid)},
{ { C_STRING_WITH_LEN("STARTPOINT") }, GEOM_BUILDER(Create_func_startpoint)},
{ { C_STRING_WITH_LEN("STRCMP") }, BUILDER(Create_func_strcmp)},
{ { C_STRING_WITH_LEN("STR_TO_DATE") }, BUILDER(Create_func_str_to_date)},
{ { C_STRING_WITH_LEN("ST_AREA") }, GEOM_BUILDER(Create_func_area)},
{ { C_STRING_WITH_LEN("ST_ASBINARY") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { C_STRING_WITH_LEN("ST_ASGEOJSON") }, GEOM_BUILDER(Create_func_as_geojson)},
{ { C_STRING_WITH_LEN("ST_ASTEXT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { C_STRING_WITH_LEN("ST_ASWKB") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { C_STRING_WITH_LEN("ST_ASWKT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { C_STRING_WITH_LEN("ST_BOUNDARY") }, GEOM_BUILDER(Create_func_boundary)},
{ { C_STRING_WITH_LEN("ST_BUFFER") }, GEOM_BUILDER(Create_func_buffer)},
{ { C_STRING_WITH_LEN("ST_CENTROID") }, GEOM_BUILDER(Create_func_centroid)},
{ { C_STRING_WITH_LEN("ST_CONTAINS") }, GEOM_BUILDER(Create_func_contains)},
{ { C_STRING_WITH_LEN("ST_CONVEXHULL") }, GEOM_BUILDER(Create_func_convexhull)},
{ { C_STRING_WITH_LEN("ST_CROSSES") }, GEOM_BUILDER(Create_func_crosses)},
{ { C_STRING_WITH_LEN("ST_DIFFERENCE") }, GEOM_BUILDER(Create_func_difference)},
{ { C_STRING_WITH_LEN("ST_DIMENSION") }, GEOM_BUILDER(Create_func_dimension)},
{ { C_STRING_WITH_LEN("ST_DISJOINT") }, GEOM_BUILDER(Create_func_disjoint)},
{ { C_STRING_WITH_LEN("ST_DISTANCE") }, GEOM_BUILDER(Create_func_distance)},
{ { C_STRING_WITH_LEN("ST_ENDPOINT") }, GEOM_BUILDER(Create_func_endpoint)},
{ { C_STRING_WITH_LEN("ST_ENVELOPE") }, GEOM_BUILDER(Create_func_envelope)},
{ { C_STRING_WITH_LEN("ST_EQUALS") }, GEOM_BUILDER(Create_func_equals)},
{ { C_STRING_WITH_LEN("ST_EXTERIORRING") }, GEOM_BUILDER(Create_func_exteriorring)},
{ { C_STRING_WITH_LEN("ST_GEOMCOLLFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_GEOMCOLLFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_GEOMETRYCOLLECTIONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_GEOMETRYCOLLECTIONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_GEOMETRYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_GEOMETRYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_GEOMETRYN") }, GEOM_BUILDER(Create_func_geometryn)},
{ { C_STRING_WITH_LEN("ST_GEOMETRYTYPE") }, GEOM_BUILDER(Create_func_geometry_type)},
{ { C_STRING_WITH_LEN("ST_GEOMFROMGEOJSON") }, GEOM_BUILDER(Create_func_geometry_from_json)},
{ { C_STRING_WITH_LEN("ST_GEOMFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_GEOMFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("REVERSE") }, BUILDER(Create_func_reverse)},
{ { STRING_WITH_LEN("ROUND") }, BUILDER(Create_func_round)},
{ { STRING_WITH_LEN("RPAD") }, BUILDER(Create_func_rpad)},
{ { STRING_WITH_LEN("RTRIM") }, BUILDER(Create_func_rtrim)},
{ { STRING_WITH_LEN("SEC_TO_TIME") }, BUILDER(Create_func_sec_to_time)},
{ { STRING_WITH_LEN("SHA") }, BUILDER(Create_func_sha)},
{ { STRING_WITH_LEN("SHA1") }, BUILDER(Create_func_sha)},
{ { STRING_WITH_LEN("SHA2") }, BUILDER(Create_func_sha2)},
{ { STRING_WITH_LEN("SIGN") }, BUILDER(Create_func_sign)},
{ { STRING_WITH_LEN("SIN") }, BUILDER(Create_func_sin)},
{ { STRING_WITH_LEN("SLEEP") }, BUILDER(Create_func_sleep)},
{ { STRING_WITH_LEN("SOUNDEX") }, BUILDER(Create_func_soundex)},
{ { STRING_WITH_LEN("SPACE") }, BUILDER(Create_func_space)},
{ { STRING_WITH_LEN("SQRT") }, BUILDER(Create_func_sqrt)},
{ { STRING_WITH_LEN("SRID") }, GEOM_BUILDER(Create_func_srid)},
{ { STRING_WITH_LEN("STARTPOINT") }, GEOM_BUILDER(Create_func_startpoint)},
{ { STRING_WITH_LEN("STRCMP") }, BUILDER(Create_func_strcmp)},
{ { STRING_WITH_LEN("STR_TO_DATE") }, BUILDER(Create_func_str_to_date)},
{ { STRING_WITH_LEN("ST_AREA") }, GEOM_BUILDER(Create_func_area)},
{ { STRING_WITH_LEN("ST_ASBINARY") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { STRING_WITH_LEN("ST_ASGEOJSON") }, GEOM_BUILDER(Create_func_as_geojson)},
{ { STRING_WITH_LEN("ST_ASTEXT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { STRING_WITH_LEN("ST_ASWKB") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { STRING_WITH_LEN("ST_ASWKT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { STRING_WITH_LEN("ST_BOUNDARY") }, GEOM_BUILDER(Create_func_boundary)},
{ { STRING_WITH_LEN("ST_BUFFER") }, GEOM_BUILDER(Create_func_buffer)},
{ { STRING_WITH_LEN("ST_CENTROID") }, GEOM_BUILDER(Create_func_centroid)},
{ { STRING_WITH_LEN("ST_CONTAINS") }, GEOM_BUILDER(Create_func_contains)},
{ { STRING_WITH_LEN("ST_CONVEXHULL") }, GEOM_BUILDER(Create_func_convexhull)},
{ { STRING_WITH_LEN("ST_CROSSES") }, GEOM_BUILDER(Create_func_crosses)},
{ { STRING_WITH_LEN("ST_DIFFERENCE") }, GEOM_BUILDER(Create_func_difference)},
{ { STRING_WITH_LEN("ST_DIMENSION") }, GEOM_BUILDER(Create_func_dimension)},
{ { STRING_WITH_LEN("ST_DISJOINT") }, GEOM_BUILDER(Create_func_disjoint)},
{ { STRING_WITH_LEN("ST_DISTANCE") }, GEOM_BUILDER(Create_func_distance)},
{ { STRING_WITH_LEN("ST_ENDPOINT") }, GEOM_BUILDER(Create_func_endpoint)},
{ { STRING_WITH_LEN("ST_ENVELOPE") }, GEOM_BUILDER(Create_func_envelope)},
{ { STRING_WITH_LEN("ST_EQUALS") }, GEOM_BUILDER(Create_func_equals)},
{ { STRING_WITH_LEN("ST_EXTERIORRING") }, GEOM_BUILDER(Create_func_exteriorring)},
{ { STRING_WITH_LEN("ST_GEOMCOLLFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_GEOMCOLLFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_GEOMETRYCOLLECTIONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_GEOMETRYCOLLECTIONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_GEOMETRYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_GEOMETRYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_GEOMETRYN") }, GEOM_BUILDER(Create_func_geometryn)},
{ { STRING_WITH_LEN("ST_GEOMETRYTYPE") }, GEOM_BUILDER(Create_func_geometry_type)},
{ { STRING_WITH_LEN("ST_GEOMFROMGEOJSON") }, GEOM_BUILDER(Create_func_geometry_from_json)},
{ { STRING_WITH_LEN("ST_GEOMFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_GEOMFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
#ifndef DBUG_OFF
{ { C_STRING_WITH_LEN("ST_GIS_DEBUG") }, GEOM_BUILDER(Create_func_gis_debug)},
{ { STRING_WITH_LEN("ST_GIS_DEBUG") }, GEOM_BUILDER(Create_func_gis_debug)},
#endif
{ { C_STRING_WITH_LEN("ST_EQUALS") }, GEOM_BUILDER(Create_func_equals)},
{ { C_STRING_WITH_LEN("ST_INTERIORRINGN") }, GEOM_BUILDER(Create_func_interiorringn)},
{ { C_STRING_WITH_LEN("ST_INTERSECTS") }, GEOM_BUILDER(Create_func_intersects)},
{ { C_STRING_WITH_LEN("ST_INTERSECTION") }, GEOM_BUILDER(Create_func_intersection)},
{ { C_STRING_WITH_LEN("ST_ISCLOSED") }, GEOM_BUILDER(Create_func_isclosed)},
{ { C_STRING_WITH_LEN("ST_ISEMPTY") }, GEOM_BUILDER(Create_func_isempty)},
{ { C_STRING_WITH_LEN("ST_ISRING") }, GEOM_BUILDER(Create_func_isring)},
{ { C_STRING_WITH_LEN("ST_ISSIMPLE") }, GEOM_BUILDER(Create_func_issimple)},
{ { C_STRING_WITH_LEN("ST_LENGTH") }, GEOM_BUILDER(Create_func_glength)},
{ { C_STRING_WITH_LEN("ST_LINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_LINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_LINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_LINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_MLINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_MLINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_MPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_MPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_MPOLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_MPOLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_MULTILINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_MULTILINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_MULTIPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_MULTIPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_MULTIPOLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_MULTIPOLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_NUMGEOMETRIES") }, GEOM_BUILDER(Create_func_numgeometries)},
{ { C_STRING_WITH_LEN("ST_NUMINTERIORRINGS") }, GEOM_BUILDER(Create_func_numinteriorring)},
{ { C_STRING_WITH_LEN("ST_NUMPOINTS") }, GEOM_BUILDER(Create_func_numpoints)},
{ { C_STRING_WITH_LEN("ST_OVERLAPS") }, GEOM_BUILDER(Create_func_overlaps)},
{ { C_STRING_WITH_LEN("ST_POINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_POINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_POINTN") }, GEOM_BUILDER(Create_func_pointn)},
{ { C_STRING_WITH_LEN("ST_POINTONSURFACE") }, GEOM_BUILDER(Create_func_pointonsurface)},
{ { C_STRING_WITH_LEN("ST_POLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_POLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_POLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("ST_POLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_RELATE") }, GEOM_BUILDER(Create_func_relate)},
{ { C_STRING_WITH_LEN("ST_SRID") }, GEOM_BUILDER(Create_func_srid)},
{ { C_STRING_WITH_LEN("ST_STARTPOINT") }, GEOM_BUILDER(Create_func_startpoint)},
{ { C_STRING_WITH_LEN("ST_SYMDIFFERENCE") }, GEOM_BUILDER(Create_func_symdifference)},
{ { C_STRING_WITH_LEN("ST_TOUCHES") }, GEOM_BUILDER(Create_func_touches)},
{ { C_STRING_WITH_LEN("ST_UNION") }, GEOM_BUILDER(Create_func_union)},
{ { C_STRING_WITH_LEN("ST_WITHIN") }, GEOM_BUILDER(Create_func_within)},
{ { C_STRING_WITH_LEN("ST_X") }, GEOM_BUILDER(Create_func_x)},
{ { C_STRING_WITH_LEN("ST_Y") }, GEOM_BUILDER(Create_func_y)},
{ { C_STRING_WITH_LEN("SUBSTR_ORACLE") },
{ { STRING_WITH_LEN("ST_EQUALS") }, GEOM_BUILDER(Create_func_equals)},
{ { STRING_WITH_LEN("ST_INTERIORRINGN") }, GEOM_BUILDER(Create_func_interiorringn)},
{ { STRING_WITH_LEN("ST_INTERSECTS") }, GEOM_BUILDER(Create_func_intersects)},
{ { STRING_WITH_LEN("ST_INTERSECTION") }, GEOM_BUILDER(Create_func_intersection)},
{ { STRING_WITH_LEN("ST_ISCLOSED") }, GEOM_BUILDER(Create_func_isclosed)},
{ { STRING_WITH_LEN("ST_ISEMPTY") }, GEOM_BUILDER(Create_func_isempty)},
{ { STRING_WITH_LEN("ST_ISRING") }, GEOM_BUILDER(Create_func_isring)},
{ { STRING_WITH_LEN("ST_ISSIMPLE") }, GEOM_BUILDER(Create_func_issimple)},
{ { STRING_WITH_LEN("ST_LENGTH") }, GEOM_BUILDER(Create_func_glength)},
{ { STRING_WITH_LEN("ST_LINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_LINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_LINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_LINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_MLINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_MLINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_MPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_MPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_MPOLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_MPOLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_MULTILINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_MULTILINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_MULTIPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_MULTIPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_MULTIPOLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_MULTIPOLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_NUMGEOMETRIES") }, GEOM_BUILDER(Create_func_numgeometries)},
{ { STRING_WITH_LEN("ST_NUMINTERIORRINGS") }, GEOM_BUILDER(Create_func_numinteriorring)},
{ { STRING_WITH_LEN("ST_NUMPOINTS") }, GEOM_BUILDER(Create_func_numpoints)},
{ { STRING_WITH_LEN("ST_OVERLAPS") }, GEOM_BUILDER(Create_func_overlaps)},
{ { STRING_WITH_LEN("ST_POINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_POINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_POINTN") }, GEOM_BUILDER(Create_func_pointn)},
{ { STRING_WITH_LEN("ST_POINTONSURFACE") }, GEOM_BUILDER(Create_func_pointonsurface)},
{ { STRING_WITH_LEN("ST_POLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_POLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_POLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { STRING_WITH_LEN("ST_POLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { STRING_WITH_LEN("ST_RELATE") }, GEOM_BUILDER(Create_func_relate)},
{ { STRING_WITH_LEN("ST_SRID") }, GEOM_BUILDER(Create_func_srid)},
{ { STRING_WITH_LEN("ST_STARTPOINT") }, GEOM_BUILDER(Create_func_startpoint)},
{ { STRING_WITH_LEN("ST_SYMDIFFERENCE") }, GEOM_BUILDER(Create_func_symdifference)},
{ { STRING_WITH_LEN("ST_TOUCHES") }, GEOM_BUILDER(Create_func_touches)},
{ { STRING_WITH_LEN("ST_UNION") }, GEOM_BUILDER(Create_func_union)},
{ { STRING_WITH_LEN("ST_WITHIN") }, GEOM_BUILDER(Create_func_within)},
{ { STRING_WITH_LEN("ST_X") }, GEOM_BUILDER(Create_func_x)},
{ { STRING_WITH_LEN("ST_Y") }, GEOM_BUILDER(Create_func_y)},
{ { STRING_WITH_LEN("SUBSTR_ORACLE") },
BUILDER(Create_func_substr_oracle)},
{ { C_STRING_WITH_LEN("SUBSTRING_INDEX") }, BUILDER(Create_func_substr_index)},
{ { C_STRING_WITH_LEN("SUBTIME") }, BUILDER(Create_func_subtime)},
{ { C_STRING_WITH_LEN("TAN") }, BUILDER(Create_func_tan)},
{ { C_STRING_WITH_LEN("TIMEDIFF") }, BUILDER(Create_func_timediff)},
{ { C_STRING_WITH_LEN("TIME_FORMAT") }, BUILDER(Create_func_time_format)},
{ { C_STRING_WITH_LEN("TIME_TO_SEC") }, BUILDER(Create_func_time_to_sec)},
{ { C_STRING_WITH_LEN("TOUCHES") }, GEOM_BUILDER(Create_func_touches)},
{ { C_STRING_WITH_LEN("TO_BASE64") }, BUILDER(Create_func_to_base64)},
{ { C_STRING_WITH_LEN("TO_DAYS") }, BUILDER(Create_func_to_days)},
{ { C_STRING_WITH_LEN("TO_SECONDS") }, BUILDER(Create_func_to_seconds)},
{ { C_STRING_WITH_LEN("UCASE") }, BUILDER(Create_func_ucase)},
{ { C_STRING_WITH_LEN("UNCOMPRESS") }, BUILDER(Create_func_uncompress)},
{ { C_STRING_WITH_LEN("UNCOMPRESSED_LENGTH") }, BUILDER(Create_func_uncompressed_length)},
{ { C_STRING_WITH_LEN("UNHEX") }, BUILDER(Create_func_unhex)},
{ { C_STRING_WITH_LEN("UNIX_TIMESTAMP") }, BUILDER(Create_func_unix_timestamp)},
{ { C_STRING_WITH_LEN("UPDATEXML") }, BUILDER(Create_func_xml_update)},
{ { C_STRING_WITH_LEN("UPPER") }, BUILDER(Create_func_ucase)},
{ { C_STRING_WITH_LEN("UUID") }, BUILDER(Create_func_uuid)},
{ { C_STRING_WITH_LEN("UUID_SHORT") }, BUILDER(Create_func_uuid_short)},
{ { C_STRING_WITH_LEN("VERSION") }, BUILDER(Create_func_version)},
{ { C_STRING_WITH_LEN("WEEKDAY") }, BUILDER(Create_func_weekday)},
{ { C_STRING_WITH_LEN("WEEKOFYEAR") }, BUILDER(Create_func_weekofyear)},
{ { C_STRING_WITH_LEN("WITHIN") }, GEOM_BUILDER(Create_func_within)},
{ { C_STRING_WITH_LEN("X") }, GEOM_BUILDER(Create_func_x)},
{ { C_STRING_WITH_LEN("Y") }, GEOM_BUILDER(Create_func_y)},
{ { C_STRING_WITH_LEN("YEARWEEK") }, BUILDER(Create_func_year_week)},
{ { STRING_WITH_LEN("SUBSTRING_INDEX") }, BUILDER(Create_func_substr_index)},
{ { STRING_WITH_LEN("SUBTIME") }, BUILDER(Create_func_subtime)},
{ { STRING_WITH_LEN("TAN") }, BUILDER(Create_func_tan)},
{ { STRING_WITH_LEN("TIMEDIFF") }, BUILDER(Create_func_timediff)},
{ { STRING_WITH_LEN("TIME_FORMAT") }, BUILDER(Create_func_time_format)},
{ { STRING_WITH_LEN("TIME_TO_SEC") }, BUILDER(Create_func_time_to_sec)},
{ { STRING_WITH_LEN("TOUCHES") }, GEOM_BUILDER(Create_func_touches)},
{ { STRING_WITH_LEN("TO_BASE64") }, BUILDER(Create_func_to_base64)},
{ { STRING_WITH_LEN("TO_DAYS") }, BUILDER(Create_func_to_days)},
{ { STRING_WITH_LEN("TO_SECONDS") }, BUILDER(Create_func_to_seconds)},
{ { STRING_WITH_LEN("UCASE") }, BUILDER(Create_func_ucase)},
{ { STRING_WITH_LEN("UNCOMPRESS") }, BUILDER(Create_func_uncompress)},
{ { STRING_WITH_LEN("UNCOMPRESSED_LENGTH") }, BUILDER(Create_func_uncompressed_length)},
{ { STRING_WITH_LEN("UNHEX") }, BUILDER(Create_func_unhex)},
{ { STRING_WITH_LEN("UNIX_TIMESTAMP") }, BUILDER(Create_func_unix_timestamp)},
{ { STRING_WITH_LEN("UPDATEXML") }, BUILDER(Create_func_xml_update)},
{ { STRING_WITH_LEN("UPPER") }, BUILDER(Create_func_ucase)},
{ { STRING_WITH_LEN("UUID") }, BUILDER(Create_func_uuid)},
{ { STRING_WITH_LEN("UUID_SHORT") }, BUILDER(Create_func_uuid_short)},
{ { STRING_WITH_LEN("VERSION") }, BUILDER(Create_func_version)},
{ { STRING_WITH_LEN("WEEKDAY") }, BUILDER(Create_func_weekday)},
{ { STRING_WITH_LEN("WEEKOFYEAR") }, BUILDER(Create_func_weekofyear)},
{ { STRING_WITH_LEN("WITHIN") }, GEOM_BUILDER(Create_func_within)},
{ { STRING_WITH_LEN("X") }, GEOM_BUILDER(Create_func_x)},
{ { STRING_WITH_LEN("Y") }, GEOM_BUILDER(Create_func_y)},
{ { STRING_WITH_LEN("YEARWEEK") }, BUILDER(Create_func_year_week)},
{ {0, 0}, NULL}
};

2
sql/item_create.h
View File

@ -208,7 +208,7 @@ Item *create_temporal_literal(THD *thd, const String *str,
struct Native_func_registry
{
LEX_STRING name;
LEX_CSTRING name;
Create_func *builder;
};

4
sql/item_strfunc.cc
View File

@ -2408,7 +2408,7 @@ String *Item_func_sqlerrm::val_str(String *str)
system_charset_info);
return str;
}
str->copy(C_STRING_WITH_LEN("normal, successful completition"),
str->copy(STRING_WITH_LEN("normal, successful completition"),
system_charset_info);
return str;
}
@ -2925,7 +2925,7 @@ void Item_func_char::print(String *str, enum_query_type query_type)
print_args(str, 0, query_type);
if (collation.collation != &my_charset_bin)
{
str->append(C_STRING_WITH_LEN(" using "));
str->append(STRING_WITH_LEN(" using "));
str->append(collation.collation->csname);
}
str->append(')');

8
sql/keycaches.cc
View File

@ -100,7 +100,7 @@ void NAMED_ILIST::delete_elements(void (*free_element)(const char *name, uchar*)
/* Key cache functions */
LEX_CSTRING default_key_cache_base= {C_STRING_WITH_LEN("default")};
LEX_CSTRING default_key_cache_base= {STRING_WITH_LEN("default")};
KEY_CACHE zero_key_cache; ///< @@nonexistent_cache.param->value_ptr() points here
@ -180,9 +180,9 @@ bool process_key_caches(process_key_cache_t func, void *param)
/* Rpl_filter functions */
LEX_STRING default_rpl_filter_base= {C_STRING_WITH_LEN("")};
LEX_CSTRING default_rpl_filter_base= {STRING_WITH_LEN("")};
Rpl_filter *get_rpl_filter(LEX_STRING *filter_name)
Rpl_filter *get_rpl_filter(LEX_CSTRING *filter_name)
{
if (!filter_name->length)
filter_name= &default_rpl_filter_base;
@ -211,7 +211,7 @@ Rpl_filter *create_rpl_filter(const char *name, uint length)
Rpl_filter *get_or_create_rpl_filter(const char *name, uint length)
{
LEX_STRING rpl_filter_name;
LEX_CSTRING rpl_filter_name;
Rpl_filter *filter;
rpl_filter_name.str= (char *) name;

4
sql/keycaches.h
View File

@ -46,11 +46,11 @@ void free_key_cache(const char *name, KEY_CACHE *key_cache);
bool process_key_caches(process_key_cache_t func, void *param);
/* For Rpl_filter */
extern LEX_STRING default_rpl_filter_base;
extern LEX_CSTRING default_rpl_filter_base;
extern NAMED_ILIST rpl_filters;
Rpl_filter *create_rpl_filter(const char *name, uint length);
Rpl_filter *get_rpl_filter(LEX_STRING *filter_name);
Rpl_filter *get_rpl_filter(LEX_CSTRING *filter_name);
Rpl_filter *get_or_create_rpl_filter(const char *name, uint length);
void free_rpl_filter(const char *name, Rpl_filter *filter);
void free_all_rpl_filters(void);

12
sql/log.cc
View File

@ -87,8 +87,8 @@ static int binlog_rollback(handlerton *hton, THD *thd, bool all);
static int binlog_prepare(handlerton *hton, THD *thd, bool all);
static int binlog_start_consistent_snapshot(handlerton *hton, THD *thd);
static LEX_STRING const write_error_msg=
{ C_STRING_WITH_LEN("error writing to the binary log") };
static const LEX_CSTRING write_error_msg=
{ STRING_WITH_LEN("error writing to the binary log") };
static my_bool opt_optimize_thread_scheduling= TRUE;
ulong binlog_checksum_options;
@ -6318,7 +6318,7 @@ bool MYSQL_BIN_LOG::write(Log_event *event_info, my_bool *with_annotate)
prev_binlog_id= current_binlog_id;
DBUG_EXECUTE_IF("binlog_force_commit_id",
{
const LEX_STRING commit_name= { C_STRING_WITH_LEN("commit_id") };
const LEX_CSTRING commit_name= { STRING_WITH_LEN("commit_id") };
bool null_value;
user_var_entry *entry=
(user_var_entry*) my_hash_search(&thd->user_vars,
@ -7164,7 +7164,7 @@ bool MYSQL_BIN_LOG::write_incident_already_locked(THD *thd)
uint error= 0;
DBUG_ENTER("MYSQL_BIN_LOG::write_incident_already_locked");
Incident incident= INCIDENT_LOST_EVENTS;
Incident_log_event ev(thd, incident, write_error_msg);
Incident_log_event ev(thd, incident, &write_error_msg);
if (likely(is_open()))
{
@ -7332,7 +7332,7 @@ MYSQL_BIN_LOG::write_transaction_to_binlog(THD *thd,
if (cache_mngr->stmt_cache.has_incident() ||
cache_mngr->trx_cache.has_incident())
{
Incident_log_event inc_ev(thd, INCIDENT_LOST_EVENTS, write_error_msg);
Incident_log_event inc_ev(thd, INCIDENT_LOST_EVENTS, &write_error_msg);
entry.incident_event= &inc_ev;
DBUG_RETURN(write_transaction_to_binlog_events(&entry));
}
@ -7840,7 +7840,7 @@ MYSQL_BIN_LOG::trx_group_commit_leader(group_commit_entry *leader)
commit_id= (last_in_queue == leader ? 0 : (uint64)leader->thd->query_id);
DBUG_EXECUTE_IF("binlog_force_commit_id",
{
const LEX_STRING commit_name= { C_STRING_WITH_LEN("commit_id") };
const LEX_CSTRING commit_name= { STRING_WITH_LEN("commit_id") };
bool null_value;
user_var_entry *entry=
(user_var_entry*) my_hash_search(&leader->thd->user_vars,

9
sql/log_event.h
View File

@ -5028,21 +5028,20 @@ public:
DBUG_VOID_RETURN;
}
Incident_log_event(THD *thd_arg, Incident incident, LEX_STRING const msg)
Incident_log_event(THD *thd_arg, Incident incident, const LEX_CSTRING *msg)
: Log_event(thd_arg, 0, FALSE), m_incident(incident)
{
DBUG_ENTER("Incident_log_event::Incident_log_event");
DBUG_PRINT("enter", ("m_incident: %d", m_incident));
m_message.str= NULL;
m_message.length= 0;
if (!(m_message.str= (char*) my_malloc(msg.length+1, MYF(MY_WME))))
if (!(m_message.str= (char*) my_malloc(msg->length+1, MYF(MY_WME))))
{
/* Mark this event invalid */
m_incident= INCIDENT_NONE;
DBUG_VOID_RETURN;
}
strmake(m_message.str, msg.str, msg.length);
m_message.length= msg.length;
strmake(m_message.str, msg->str, msg->length);
m_message.length= msg->length;
set_direct_logging();
/* Replicate the incident irregardless of @@skip_replication. */
flags&= ~LOG_EVENT_SKIP_REPLICATION_F;

16
sql/rpl_gtid.cc
View File

@ -427,17 +427,17 @@ rpl_slave_state::truncate_state_table(THD *thd)
static const TABLE_FIELD_TYPE mysql_rpl_slave_state_coltypes[4]= {
{ { C_STRING_WITH_LEN("domain_id") },
{ C_STRING_WITH_LEN("int(10) unsigned") },
{ { STRING_WITH_LEN("domain_id") },
{ STRING_WITH_LEN("int(10) unsigned") },
{NULL, 0} },
{ { C_STRING_WITH_LEN("sub_id") },
{ C_STRING_WITH_LEN("bigint(20) unsigned") },
{ { STRING_WITH_LEN("sub_id") },
{ STRING_WITH_LEN("bigint(20) unsigned") },
{NULL, 0} },
{ { C_STRING_WITH_LEN("server_id") },
{ C_STRING_WITH_LEN("int(10) unsigned") },
{ { STRING_WITH_LEN("server_id") },
{ STRING_WITH_LEN("int(10) unsigned") },
{NULL, 0} },
{ { C_STRING_WITH_LEN("seq_no") },
{ C_STRING_WITH_LEN("bigint(20) unsigned") },
{ { STRING_WITH_LEN("seq_no") },
{ STRING_WITH_LEN("bigint(20) unsigned") },
{NULL, 0} },
};

3
sql/rpl_injector.cc
View File

@ -185,7 +185,8 @@ int injector::record_incident(THD *thd, Incident incident)
return mysql_bin_log.rotate_and_purge(true);
}
int injector::record_incident(THD *thd, Incident incident, LEX_STRING const message)
int injector::record_incident(THD *thd, Incident incident,
const LEX_CSTRING *message)
{
Incident_log_event ev(thd, incident, message);
if (int error= mysql_bin_log.write(&ev))

2
sql/rpl_injector.h
View File

@ -302,7 +302,7 @@ public:
void new_trans(THD *, transaction *);
int record_incident(THD*, Incident incident);
int record_incident(THD*, Incident incident, LEX_STRING const message);
int record_incident(THD*, Incident incident, const LEX_CSTRING *message);
private:
explicit injector();

14
sql/set_var.cc
View File

@ -324,14 +324,14 @@ do { \
sval.length= sval.str ? strlen(sval.str) : 0; \
break; \
case SHOW_LEX_STRING: \
sval= *(LEX_STRING *) value; \
sval= *(LEX_CSTRING *) value; \
break
longlong sys_var::val_int(bool *is_null,
THD *thd, enum_var_type type,
const LEX_CSTRING *base)
{
LEX_STRING sval;
LEX_CSTRING sval;
AutoWLock lock(&PLock_global_system_variables);
const uchar *value= value_ptr(thd, type, base);
*is_null= false;
@ -357,13 +357,13 @@ longlong sys_var::val_int(bool *is_null,
String *sys_var::val_str_nolock(String *str, THD *thd, const uchar *value)
{
static LEX_STRING bools[]=
static LEX_CSTRING bools[]=
{
{ C_STRING_WITH_LEN("OFF") },
{ C_STRING_WITH_LEN("ON") }
{ STRING_WITH_LEN("OFF") },
{ STRING_WITH_LEN("ON") }
};
LEX_STRING sval;
LEX_CSTRING sval;
switch (show_type())
{
case_get_string_as_lex_string;
@ -395,7 +395,7 @@ String *sys_var::val_str(String *str,
double sys_var::val_real(bool *is_null,
THD *thd, enum_var_type type, const LEX_CSTRING *base)
{
LEX_STRING sval;
LEX_CSTRING sval;
AutoWLock lock(&PLock_global_system_variables);
const uchar *value= value_ptr(thd, type, base);
*is_null= false;

100
sql/sp.cc
View File

@ -92,79 +92,79 @@ static const
TABLE_FIELD_TYPE proc_table_fields[MYSQL_PROC_FIELD_COUNT] =
{
{
{ C_STRING_WITH_LEN("db") },
{ C_STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("db") },
{ STRING_WITH_LEN("char(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("name") },
{ C_STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("name") },
{ STRING_WITH_LEN("char(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("type") },
{ C_STRING_WITH_LEN("enum('FUNCTION','PROCEDURE')") },
{ STRING_WITH_LEN("type") },
{ STRING_WITH_LEN("enum('FUNCTION','PROCEDURE')") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("specific_name") },
{ C_STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("specific_name") },
{ STRING_WITH_LEN("char(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("language") },
{ C_STRING_WITH_LEN("enum('SQL')") },
{ STRING_WITH_LEN("language") },
{ STRING_WITH_LEN("enum('SQL')") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("sql_data_access") },
{ C_STRING_WITH_LEN("enum('CONTAINS_SQL','NO_SQL','READS_SQL_DATA','MODIFIES_SQL_DATA')") },
{ STRING_WITH_LEN("sql_data_access") },
{ STRING_WITH_LEN("enum('CONTAINS_SQL','NO_SQL','READS_SQL_DATA','MODIFIES_SQL_DATA')") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("is_deterministic") },
{ C_STRING_WITH_LEN("enum('YES','NO')") },
{ STRING_WITH_LEN("is_deterministic") },
{ STRING_WITH_LEN("enum('YES','NO')") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("security_type") },
{ C_STRING_WITH_LEN("enum('INVOKER','DEFINER')") },
{ STRING_WITH_LEN("security_type") },
{ STRING_WITH_LEN("enum('INVOKER','DEFINER')") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("param_list") },
{ C_STRING_WITH_LEN("blob") },
{ STRING_WITH_LEN("param_list") },
{ STRING_WITH_LEN("blob") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("returns") },
{ C_STRING_WITH_LEN("longblob") },
{ STRING_WITH_LEN("returns") },
{ STRING_WITH_LEN("longblob") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("body") },
{ C_STRING_WITH_LEN("longblob") },
{ STRING_WITH_LEN("body") },
{ STRING_WITH_LEN("longblob") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("definer") },
{ C_STRING_WITH_LEN("char(") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("definer") },
{ STRING_WITH_LEN("char(") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("created") },
{ C_STRING_WITH_LEN("timestamp") },
{ STRING_WITH_LEN("created") },
{ STRING_WITH_LEN("timestamp") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("modified") },
{ C_STRING_WITH_LEN("timestamp") },
{ STRING_WITH_LEN("modified") },
{ STRING_WITH_LEN("timestamp") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("sql_mode") },
{ C_STRING_WITH_LEN("set('REAL_AS_FLOAT','PIPES_AS_CONCAT','ANSI_QUOTES',"
{ STRING_WITH_LEN("sql_mode") },
{ STRING_WITH_LEN("set('REAL_AS_FLOAT','PIPES_AS_CONCAT','ANSI_QUOTES',"
"'IGNORE_SPACE','IGNORE_BAD_TABLE_OPTIONS','ONLY_FULL_GROUP_BY',"
"'NO_UNSIGNED_SUBTRACTION',"
"'NO_DIR_IN_CREATE','POSTGRESQL','ORACLE','MSSQL','DB2','MAXDB',"
@ -177,33 +177,33 @@ TABLE_FIELD_TYPE proc_table_fields[MYSQL_PROC_FIELD_COUNT] =
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("comment") },
{ C_STRING_WITH_LEN("text") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("comment") },
{ STRING_WITH_LEN("text") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("character_set_client") },
{ C_STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("character_set_client") },
{ STRING_WITH_LEN("char(32)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("collation_connection") },
{ C_STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("collation_connection") },
{ STRING_WITH_LEN("char(32)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("db_collation") },
{ C_STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("db_collation") },
{ STRING_WITH_LEN("char(32)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("body_utf8") },
{ C_STRING_WITH_LEN("longblob") },
{ STRING_WITH_LEN("body_utf8") },
{ STRING_WITH_LEN("longblob") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("aggregate") },
{ C_STRING_WITH_LEN("enum('NONE','GROUP')") },
{ STRING_WITH_LEN("aggregate") },
{ STRING_WITH_LEN("enum('NONE','GROUP')") },
{ NULL, 0 }
}
};

12
sql/sp.h
View File

@ -100,7 +100,7 @@ public:
virtual LEX_CSTRING type_lex_cstring() const= 0;
virtual LEX_CSTRING empty_body_lex_cstring() const
{
static LEX_CSTRING m_empty_body= {C_STRING_WITH_LEN("???")};
static LEX_CSTRING m_empty_body= {STRING_WITH_LEN("???")};
DBUG_ASSERT(0);
return m_empty_body;
}
@ -182,12 +182,12 @@ public:
stored_procedure_type type() const { return TYPE_ENUM_PROCEDURE; }
LEX_CSTRING type_lex_cstring() const
{
static LEX_CSTRING m_type_str= {C_STRING_WITH_LEN("PROCEDURE")};
static LEX_CSTRING m_type_str= { STRING_WITH_LEN("PROCEDURE")};
return m_type_str;
}
LEX_CSTRING empty_body_lex_cstring() const
{
static LEX_CSTRING m_empty_body= {C_STRING_WITH_LEN("BEGIN END")};
static LEX_CSTRING m_empty_body= { STRING_WITH_LEN("BEGIN END")};
return m_empty_body;
}
const char *show_create_routine_col1_caption() const
@ -218,12 +218,12 @@ public:
stored_procedure_type type() const { return TYPE_ENUM_FUNCTION; }
LEX_CSTRING type_lex_cstring() const
{
static LEX_CSTRING m_type_str= {C_STRING_WITH_LEN("FUNCTION")};
static LEX_CSTRING m_type_str= { STRING_WITH_LEN("FUNCTION")};
return m_type_str;
}
LEX_CSTRING empty_body_lex_cstring() const
{
static LEX_CSTRING m_empty_body= {C_STRING_WITH_LEN("RETURN NULL")};
static LEX_CSTRING m_empty_body= { STRING_WITH_LEN("RETURN NULL")};
return m_empty_body;
}
const char *show_create_routine_col1_caption() const
@ -253,7 +253,7 @@ public:
stored_procedure_type type() const { return TYPE_ENUM_TRIGGER; }
LEX_CSTRING type_lex_cstring() const
{
static LEX_CSTRING m_type_str= {C_STRING_WITH_LEN("TRIGGER")};
static LEX_CSTRING m_type_str= { STRING_WITH_LEN("TRIGGER")};
return m_type_str;
}
MDL_key::enum_mdl_namespace get_mdl_type() const

10
sql/sp_pcontext.cc
View File

@ -423,12 +423,12 @@ static sp_condition_value
static sp_condition sp_predefined_conditions[]=
{
// Warnings
sp_condition(C_STRING_WITH_LEN("NO_DATA_FOUND"), &cond_no_data_found),
sp_condition(STRING_WITH_LEN("NO_DATA_FOUND"), &cond_no_data_found),
// Errors
sp_condition(C_STRING_WITH_LEN("INVALID_CURSOR"), &cond_invalid_cursor),
sp_condition(C_STRING_WITH_LEN("DUP_VAL_ON_INDEX"), &cond_dup_val_on_index),
sp_condition(C_STRING_WITH_LEN("DUP_VAL_ON_INDEX"), &cond_dup_val_on_index2),
sp_condition(C_STRING_WITH_LEN("TOO_MANY_ROWS"), &cond_too_many_rows)
sp_condition(STRING_WITH_LEN("INVALID_CURSOR"), &cond_invalid_cursor),
sp_condition(STRING_WITH_LEN("DUP_VAL_ON_INDEX"), &cond_dup_val_on_index),
sp_condition(STRING_WITH_LEN("DUP_VAL_ON_INDEX"), &cond_dup_val_on_index2),
sp_condition(STRING_WITH_LEN("TOO_MANY_ROWS"), &cond_too_many_rows)
};

132
sql/sql_acl.cc
View File

@ -62,119 +62,119 @@ bool mysql_user_table_is_in_short_password_format= false;
static const
TABLE_FIELD_TYPE mysql_db_table_fields[MYSQL_DB_FIELD_COUNT] = {
{
{ C_STRING_WITH_LEN("Host") },
{ C_STRING_WITH_LEN("char(60)") },
{ STRING_WITH_LEN("Host") },
{ STRING_WITH_LEN("char(60)") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("Db") },
{ C_STRING_WITH_LEN("char(64)") },
{ STRING_WITH_LEN("Db") },
{ STRING_WITH_LEN("char(64)") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("User") },
{ C_STRING_WITH_LEN("char(") },
{ STRING_WITH_LEN("User") },
{ STRING_WITH_LEN("char(") },
{NULL, 0}
},
{
{ C_STRING_WITH_LEN("Select_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Select_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Insert_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Insert_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Update_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Update_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Delete_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Delete_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Create_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Create_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Drop_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Drop_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Grant_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Grant_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("References_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("References_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Index_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Index_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Alter_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Alter_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Create_tmp_table_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Create_tmp_table_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Lock_tables_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Lock_tables_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Create_view_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Create_view_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Show_view_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Show_view_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Create_routine_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Create_routine_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Alter_routine_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Alter_routine_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Execute_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Execute_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Event_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Event_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Trigger_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Trigger_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("Truncate_versioning_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("Truncate_versioning_priv") },
{ STRING_WITH_LEN("enum('N','Y')") },
{ STRING_WITH_LEN("utf8") }
}
};

17
sql/sql_class.h
View File

@ -443,7 +443,7 @@ typedef enum enum_diag_condition_item_name
Name of each diagnostic condition item.
This array is indexed by Diag_condition_item_name.
*/
extern const LEX_STRING Diag_condition_item_names[];
extern const LEX_CSTRING Diag_condition_item_names[];
/**
These states are bit coded with HARD. For each state there must be a pair
@ -3571,21 +3571,6 @@ public:
return lex_str;
}
LEX_STRING *make_lex_string(const char* str, uint length)
{
LEX_STRING *lex_str;
char *tmp;
if (!(lex_str= (LEX_STRING *) alloc_root(mem_root, sizeof(LEX_STRING) +
length+1)))
return 0;
tmp= (char*) (lex_str+1);
lex_str->str= tmp;
memcpy(tmp, str, length);
tmp[length]= 0;
lex_str->length= length;
return lex_str;
}
LEX_CSTRING *make_clex_string(const char* str, uint length)
{
LEX_CSTRING *lex_str;

10
sql/sql_error.cc
View File

@ -769,12 +769,12 @@ void push_warning_printf(THD *thd, Sql_condition::enum_warning_level level,
TRUE Error sending data to client
*/
const LEX_STRING warning_level_names[]=
const LEX_CSTRING warning_level_names[]=
{
{ C_STRING_WITH_LEN("Note") },
{ C_STRING_WITH_LEN("Warning") },
{ C_STRING_WITH_LEN("Error") },
{ C_STRING_WITH_LEN("?") }
{ STRING_WITH_LEN("Note") },
{ STRING_WITH_LEN("Warning") },
{ STRING_WITH_LEN("Error") },
{ STRING_WITH_LEN("?") }
};
bool mysqld_show_warnings(THD *thd, ulong levels_to_show)

2
sql/sql_error.h
View File

@ -1245,7 +1245,7 @@ uint32 convert_error_message(char *to, uint32 to_length,
const char *from, uint32 from_length,
CHARSET_INFO *from_cs, uint *errors);
extern const LEX_STRING warning_level_names[];
extern const LEX_CSTRING warning_level_names[];
bool is_sqlstate_valid(const LEX_CSTRING *sqlstate);
/**

78
sql/sql_parse.cc
View File

@ -132,39 +132,39 @@ static bool check_rename_table(THD *, TABLE_LIST *, TABLE_LIST *);
const char *any_db="*any*"; // Special symbol for check_access
const LEX_STRING command_name[257]={
{ C_STRING_WITH_LEN("Sleep") }, //0
{ C_STRING_WITH_LEN("Quit") }, //1
{ C_STRING_WITH_LEN("Init DB") }, //2
{ C_STRING_WITH_LEN("Query") }, //3
{ C_STRING_WITH_LEN("Field List") }, //4
{ C_STRING_WITH_LEN("Create DB") }, //5
{ C_STRING_WITH_LEN("Drop DB") }, //6
{ C_STRING_WITH_LEN("Refresh") }, //7
{ C_STRING_WITH_LEN("Shutdown") }, //8
{ C_STRING_WITH_LEN("Statistics") }, //9
{ C_STRING_WITH_LEN("Processlist") }, //10
{ C_STRING_WITH_LEN("Connect") }, //11
{ C_STRING_WITH_LEN("Kill") }, //12
{ C_STRING_WITH_LEN("Debug") }, //13
{ C_STRING_WITH_LEN("Ping") }, //14
{ C_STRING_WITH_LEN("Time") }, //15
{ C_STRING_WITH_LEN("Delayed insert") }, //16
{ C_STRING_WITH_LEN("Change user") }, //17
{ C_STRING_WITH_LEN("Binlog Dump") }, //18
{ C_STRING_WITH_LEN("Table Dump") }, //19
{ C_STRING_WITH_LEN("Connect Out") }, //20
{ C_STRING_WITH_LEN("Register Slave") }, //21
{ C_STRING_WITH_LEN("Prepare") }, //22
{ C_STRING_WITH_LEN("Execute") }, //23
{ C_STRING_WITH_LEN("Long Data") }, //24
{ C_STRING_WITH_LEN("Close stmt") }, //25
{ C_STRING_WITH_LEN("Reset stmt") }, //26
{ C_STRING_WITH_LEN("Set option") }, //27
{ C_STRING_WITH_LEN("Fetch") }, //28
{ C_STRING_WITH_LEN("Daemon") }, //29
{ C_STRING_WITH_LEN("Unimpl get tid") }, //30
{ C_STRING_WITH_LEN("Reset connection") },//31
const LEX_CSTRING command_name[257]={
{ STRING_WITH_LEN("Sleep") }, //0
{ STRING_WITH_LEN("Quit") }, //1
{ STRING_WITH_LEN("Init DB") }, //2
{ STRING_WITH_LEN("Query") }, //3
{ STRING_WITH_LEN("Field List") }, //4
{ STRING_WITH_LEN("Create DB") }, //5
{ STRING_WITH_LEN("Drop DB") }, //6
{ STRING_WITH_LEN("Refresh") }, //7
{ STRING_WITH_LEN("Shutdown") }, //8
{ STRING_WITH_LEN("Statistics") }, //9
{ STRING_WITH_LEN("Processlist") }, //10
{ STRING_WITH_LEN("Connect") }, //11
{ STRING_WITH_LEN("Kill") }, //12
{ STRING_WITH_LEN("Debug") }, //13
{ STRING_WITH_LEN("Ping") }, //14
{ STRING_WITH_LEN("Time") }, //15
{ STRING_WITH_LEN("Delayed insert") }, //16
{ STRING_WITH_LEN("Change user") }, //17
{ STRING_WITH_LEN("Binlog Dump") }, //18
{ STRING_WITH_LEN("Table Dump") }, //19
{ STRING_WITH_LEN("Connect Out") }, //20
{ STRING_WITH_LEN("Register Slave") }, //21
{ STRING_WITH_LEN("Prepare") }, //22
{ STRING_WITH_LEN("Execute") }, //23
{ STRING_WITH_LEN("Long Data") }, //24
{ STRING_WITH_LEN("Close stmt") }, //25
{ STRING_WITH_LEN("Reset stmt") }, //26
{ STRING_WITH_LEN("Set option") }, //27
{ STRING_WITH_LEN("Fetch") }, //28
{ STRING_WITH_LEN("Daemon") }, //29
{ STRING_WITH_LEN("Unimpl get tid") }, //30
{ STRING_WITH_LEN("Reset connection") },//31
{ 0, 0 }, //32
{ 0, 0 }, //33
{ 0, 0 }, //34
@ -383,12 +383,12 @@ const LEX_STRING command_name[257]={
{ 0, 0 }, //247
{ 0, 0 }, //248
{ 0, 0 }, //249
{ C_STRING_WITH_LEN("Bulk_execute") }, //250
{ C_STRING_WITH_LEN("Slave_worker") }, //251
{ C_STRING_WITH_LEN("Slave_IO") }, //252
{ C_STRING_WITH_LEN("Slave_SQL") }, //253
{ C_STRING_WITH_LEN("Com_multi") }, //254
{ C_STRING_WITH_LEN("Error") } // Last command number 255
{ STRING_WITH_LEN("Bulk_execute") }, //250
{ STRING_WITH_LEN("Slave_worker") }, //251
{ STRING_WITH_LEN("Slave_IO") }, //252
{ STRING_WITH_LEN("Slave_SQL") }, //253
{ STRING_WITH_LEN("Com_multi") }, //254
{ STRING_WITH_LEN("Error") } // Last command number 255
};
const char *xa_state_names[]={

2
sql/sql_parse.h
View File

@ -129,7 +129,7 @@ bool check_stack_overrun(THD *thd, long margin, uchar *dummy);
extern const char* any_db;
extern uint sql_command_flags[];
extern uint server_command_flags[];
extern const LEX_STRING command_name[];
extern const LEX_CSTRING command_name[];
extern uint server_command_flags[];
/* Inline functions */

24
sql/sql_plugin.cc
View File

@ -82,18 +82,18 @@ uint plugin_maturity_map[]=
When you ad a new plugin type, add both a string and make sure that the
init and deinit array are correctly updated.
*/
const LEX_STRING plugin_type_names[MYSQL_MAX_PLUGIN_TYPE_NUM]=
const LEX_CSTRING plugin_type_names[MYSQL_MAX_PLUGIN_TYPE_NUM]=
{
{ C_STRING_WITH_LEN("UDF") },
{ C_STRING_WITH_LEN("STORAGE ENGINE") },
{ C_STRING_WITH_LEN("FTPARSER") },
{ C_STRING_WITH_LEN("DAEMON") },
{ C_STRING_WITH_LEN("INFORMATION SCHEMA") },
{ C_STRING_WITH_LEN("AUDIT") },
{ C_STRING_WITH_LEN("REPLICATION") },
{ C_STRING_WITH_LEN("AUTHENTICATION") },
{ C_STRING_WITH_LEN("PASSWORD VALIDATION") },
{ C_STRING_WITH_LEN("ENCRYPTION") }
{ STRING_WITH_LEN("UDF") },
{ STRING_WITH_LEN("STORAGE ENGINE") },
{ STRING_WITH_LEN("FTPARSER") },
{ STRING_WITH_LEN("DAEMON") },
{ STRING_WITH_LEN("INFORMATION SCHEMA") },
{ STRING_WITH_LEN("AUDIT") },
{ STRING_WITH_LEN("REPLICATION") },
{ STRING_WITH_LEN("AUTHENTICATION") },
{ STRING_WITH_LEN("PASSWORD VALIDATION") },
{ STRING_WITH_LEN("ENCRYPTION") }
};
extern int initialize_schema_table(st_plugin_int *plugin);
@ -3693,7 +3693,7 @@ static int construct_options(MEM_ROOT *mem_root, struct st_plugin_int *tmp,
my_option *options)
{
const char *plugin_name= tmp->plugin->name;
const LEX_STRING plugin_dash = { C_STRING_WITH_LEN("plugin-") };
const LEX_CSTRING plugin_dash = { STRING_WITH_LEN("plugin-") };
uint plugin_name_len= strlen(plugin_name);
uint optnamelen;
const int max_comment_len= 180;

2
sql/sql_plugin.h
View File

@ -156,7 +156,7 @@ typedef int (*plugin_type_init)(struct st_plugin_int *);
extern I_List<i_string> *opt_plugin_load_list_ptr;
extern char *opt_plugin_dir_ptr;
extern MYSQL_PLUGIN_IMPORT char opt_plugin_dir[FN_REFLEN];
extern const LEX_STRING plugin_type_names[];
extern const LEX_CSTRING plugin_type_names[];
extern ulong plugin_maturity;
extern TYPELIB plugin_maturity_values;
extern const char *plugin_maturity_names[];

14
sql/sql_repl.cc
View File

@ -445,7 +445,7 @@ inline void fix_checksum(String *packet, ulong ev_offset)
static user_var_entry * get_binlog_checksum_uservar(THD * thd)
{
LEX_STRING name= { C_STRING_WITH_LEN("master_binlog_checksum")};
LEX_CSTRING name= { STRING_WITH_LEN("master_binlog_checksum")};
user_var_entry *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length);
@ -695,7 +695,7 @@ void set_read_error(binlog_send_info *info, int error)
static ulonglong get_heartbeat_period(THD * thd)
{
bool null_value;
LEX_STRING name= { C_STRING_WITH_LEN("master_heartbeat_period")};
LEX_CSTRING name= { STRING_WITH_LEN("master_heartbeat_period")};
user_var_entry *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length);
@ -714,7 +714,7 @@ static int
get_mariadb_slave_capability(THD *thd)
{
bool null_value;
const LEX_STRING name= { C_STRING_WITH_LEN("mariadb_slave_capability") };
const LEX_CSTRING name= { STRING_WITH_LEN("mariadb_slave_capability") };
const user_var_entry *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length);
@ -735,7 +735,7 @@ get_slave_connect_state(THD *thd, String *out_str)
{
bool null_value;
const LEX_STRING name= { C_STRING_WITH_LEN("slave_connect_state") };
const LEX_CSTRING name= { STRING_WITH_LEN("slave_connect_state") };
user_var_entry *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length);
@ -748,7 +748,7 @@ get_slave_gtid_strict_mode(THD *thd)
{
bool null_value;
const LEX_STRING name= { C_STRING_WITH_LEN("slave_gtid_strict_mode") };
const LEX_CSTRING name= { STRING_WITH_LEN("slave_gtid_strict_mode") };
user_var_entry *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length);
@ -761,7 +761,7 @@ get_slave_gtid_ignore_duplicates(THD *thd)
{
bool null_value;
const LEX_STRING name= { C_STRING_WITH_LEN("slave_gtid_ignore_duplicates") };
const LEX_CSTRING name= { STRING_WITH_LEN("slave_gtid_ignore_duplicates") };
user_var_entry *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length);
@ -782,7 +782,7 @@ get_slave_until_gtid(THD *thd, String *out_str)
{
bool null_value;
const LEX_STRING name= { C_STRING_WITH_LEN("slave_until_gtid") };
const LEX_CSTRING name= { STRING_WITH_LEN("slave_until_gtid") };
user_var_entry *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length);

2
sql/sql_sequence.cc
View File

@ -54,7 +54,7 @@ static Field_definition sequence_structure[]=
{"maximum_value", 21, &type_handler_longlong, STRING_WITH_LEN(""), FL},
{"start_value", 21, &type_handler_longlong, {STRING_WITH_LEN("start value when sequences is created or value if RESTART is used")}, FL},
{"increment", 21, &type_handler_longlong,
{C_STRING_WITH_LEN("increment value")}, FL},
{STRING_WITH_LEN("increment value")}, FL},
{"cache_size", 21, &type_handler_longlong, STRING_WITH_LEN(""),
FL | UNSIGNED_FLAG},
{"cycle_option", 1, &type_handler_tiny, {STRING_WITH_LEN("0 if no cycles are allowed, 1 if the sequence should begin a new cycle when maximum_value is passed")},

2
sql/sql_show.cc
View File

@ -5999,7 +5999,7 @@ static my_bool iter_schema_engines(THD *thd, plugin_ref plugin,
{
restore_record(table, s->default_values);
table->field[0]->store(plug->name, strlen(plug->name), scs);
table->field[1]->store(C_STRING_WITH_LEN("NO"), scs);
table->field[1]->store(STRING_WITH_LEN("NO"), scs);
table->field[2]->store(plug->descr, strlen(plug->descr), scs);
if (schema_table_store_record(thd, table))
DBUG_RETURN(1);

62
sql/sql_signal.cc
View File

@ -29,38 +29,38 @@
*/
#define MAX_MYSQL_ERRNO 65534
const LEX_STRING Diag_condition_item_names[]=
const LEX_CSTRING Diag_condition_item_names[]=
{
{ C_STRING_WITH_LEN("CLASS_ORIGIN") },
{ C_STRING_WITH_LEN("SUBCLASS_ORIGIN") },
{ C_STRING_WITH_LEN("CONSTRAINT_CATALOG") },
{ C_STRING_WITH_LEN("CONSTRAINT_SCHEMA") },
{ C_STRING_WITH_LEN("CONSTRAINT_NAME") },
{ C_STRING_WITH_LEN("CATALOG_NAME") },
{ C_STRING_WITH_LEN("SCHEMA_NAME") },
{ C_STRING_WITH_LEN("TABLE_NAME") },
{ C_STRING_WITH_LEN("COLUMN_NAME") },
{ C_STRING_WITH_LEN("CURSOR_NAME") },
{ C_STRING_WITH_LEN("MESSAGE_TEXT") },
{ C_STRING_WITH_LEN("MYSQL_ERRNO") },
{ STRING_WITH_LEN("CLASS_ORIGIN") },
{ STRING_WITH_LEN("SUBCLASS_ORIGIN") },
{ STRING_WITH_LEN("CONSTRAINT_CATALOG") },
{ STRING_WITH_LEN("CONSTRAINT_SCHEMA") },
{ STRING_WITH_LEN("CONSTRAINT_NAME") },
{ STRING_WITH_LEN("CATALOG_NAME") },
{ STRING_WITH_LEN("SCHEMA_NAME") },
{ STRING_WITH_LEN("TABLE_NAME") },
{ STRING_WITH_LEN("COLUMN_NAME") },
{ STRING_WITH_LEN("CURSOR_NAME") },
{ STRING_WITH_LEN("MESSAGE_TEXT") },
{ STRING_WITH_LEN("MYSQL_ERRNO") },
{ C_STRING_WITH_LEN("CONDITION_IDENTIFIER") },
{ C_STRING_WITH_LEN("CONDITION_NUMBER") },
{ C_STRING_WITH_LEN("CONNECTION_NAME") },
{ C_STRING_WITH_LEN("MESSAGE_LENGTH") },
{ C_STRING_WITH_LEN("MESSAGE_OCTET_LENGTH") },
{ C_STRING_WITH_LEN("PARAMETER_MODE") },
{ C_STRING_WITH_LEN("PARAMETER_NAME") },
{ C_STRING_WITH_LEN("PARAMETER_ORDINAL_POSITION") },
{ C_STRING_WITH_LEN("RETURNED_SQLSTATE") },
{ C_STRING_WITH_LEN("ROUTINE_CATALOG") },
{ C_STRING_WITH_LEN("ROUTINE_NAME") },
{ C_STRING_WITH_LEN("ROUTINE_SCHEMA") },
{ C_STRING_WITH_LEN("SERVER_NAME") },
{ C_STRING_WITH_LEN("SPECIFIC_NAME") },
{ C_STRING_WITH_LEN("TRIGGER_CATALOG") },
{ C_STRING_WITH_LEN("TRIGGER_NAME") },
{ C_STRING_WITH_LEN("TRIGGER_SCHEMA") }
{ STRING_WITH_LEN("CONDITION_IDENTIFIER") },
{ STRING_WITH_LEN("CONDITION_NUMBER") },
{ STRING_WITH_LEN("CONNECTION_NAME") },
{ STRING_WITH_LEN("MESSAGE_LENGTH") },
{ STRING_WITH_LEN("MESSAGE_OCTET_LENGTH") },
{ STRING_WITH_LEN("PARAMETER_MODE") },
{ STRING_WITH_LEN("PARAMETER_NAME") },
{ STRING_WITH_LEN("PARAMETER_ORDINAL_POSITION") },
{ STRING_WITH_LEN("RETURNED_SQLSTATE") },
{ STRING_WITH_LEN("ROUTINE_CATALOG") },
{ STRING_WITH_LEN("ROUTINE_NAME") },
{ STRING_WITH_LEN("ROUTINE_SCHEMA") },
{ STRING_WITH_LEN("SERVER_NAME") },
{ STRING_WITH_LEN("SPECIFIC_NAME") },
{ STRING_WITH_LEN("TRIGGER_CATALOG") },
{ STRING_WITH_LEN("TRIGGER_NAME") },
{ STRING_WITH_LEN("TRIGGER_SCHEMA") }
};
@ -210,7 +210,7 @@ int Sql_cmd_common_signal::eval_signal_informations(THD *thd, Sql_condition *con
int result= 1;
enum enum_diag_condition_item_name item_enum;
String *member;
const LEX_STRING *name;
const LEX_CSTRING *name;
DBUG_ENTER("Sql_cmd_common_signal::eval_signal_informations");

94
sql/sql_statistics.cc
View File

@ -131,18 +131,18 @@ static const
TABLE_FIELD_TYPE table_stat_fields[TABLE_STAT_N_FIELDS] =
{
{
{ C_STRING_WITH_LEN("db_name") },
{ C_STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("db_name") },
{ STRING_WITH_LEN("varchar(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("table_name") },
{ C_STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("table_name") },
{ STRING_WITH_LEN("varchar(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("cardinality") },
{ C_STRING_WITH_LEN("bigint(21)") },
{ STRING_WITH_LEN("cardinality") },
{ STRING_WITH_LEN("bigint(21)") },
{ NULL, 0 }
},
};
@ -154,58 +154,58 @@ static const
TABLE_FIELD_TYPE column_stat_fields[COLUMN_STAT_N_FIELDS] =
{
{
{ C_STRING_WITH_LEN("db_name") },
{ C_STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("db_name") },
{ STRING_WITH_LEN("varchar(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("table_name") },
{ C_STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("table_name") },
{ STRING_WITH_LEN("varchar(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("column_name") },
{ C_STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("column_name") },
{ STRING_WITH_LEN("varchar(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("min_value") },
{ C_STRING_WITH_LEN("varbinary(255)") },
{ STRING_WITH_LEN("min_value") },
{ STRING_WITH_LEN("varbinary(255)") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("max_value") },
{ C_STRING_WITH_LEN("varbinary(255)") },
{ STRING_WITH_LEN("max_value") },
{ STRING_WITH_LEN("varbinary(255)") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("nulls_ratio") },
{ C_STRING_WITH_LEN("decimal(12,4)") },
{ STRING_WITH_LEN("nulls_ratio") },
{ STRING_WITH_LEN("decimal(12,4)") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("avg_length") },
{ C_STRING_WITH_LEN("decimal(12,4)") },
{ STRING_WITH_LEN("avg_length") },
{ STRING_WITH_LEN("decimal(12,4)") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("avg_frequency") },
{ C_STRING_WITH_LEN("decimal(12,4)") },
{ STRING_WITH_LEN("avg_frequency") },
{ STRING_WITH_LEN("decimal(12,4)") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("hist_size") },
{ C_STRING_WITH_LEN("tinyint(3)") },
{ STRING_WITH_LEN("hist_size") },
{ STRING_WITH_LEN("tinyint(3)") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("hist_type") },
{ C_STRING_WITH_LEN("enum('SINGLE_PREC_HB','DOUBLE_PREC_HB')") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("hist_type") },
{ STRING_WITH_LEN("enum('SINGLE_PREC_HB','DOUBLE_PREC_HB')") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("histogram") },
{ C_STRING_WITH_LEN("varbinary(255)") },
{ STRING_WITH_LEN("histogram") },
{ STRING_WITH_LEN("varbinary(255)") },
{ NULL, 0 }
}
};
@ -217,28 +217,28 @@ static const
TABLE_FIELD_TYPE index_stat_fields[INDEX_STAT_N_FIELDS] =
{
{
{ C_STRING_WITH_LEN("db_name") },
{ C_STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("db_name") },
{ STRING_WITH_LEN("varchar(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("table_name") },
{ C_STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("table_name") },
{ STRING_WITH_LEN("varchar(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("index") },
{ C_STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") }
{ STRING_WITH_LEN("index") },
{ STRING_WITH_LEN("varchar(64)") },
{ STRING_WITH_LEN("utf8") }
},
{
{ C_STRING_WITH_LEN("prefix_arity") },
{ C_STRING_WITH_LEN("int(11)") },
{ STRING_WITH_LEN("prefix_arity") },
{ STRING_WITH_LEN("int(11)") },
{ NULL, 0 }
},
{
{ C_STRING_WITH_LEN("avg_frequency") },
{ C_STRING_WITH_LEN("decimal(12,4)") },
{ STRING_WITH_LEN("avg_frequency") },
{ STRING_WITH_LEN("decimal(12,4)") },
{ NULL, 0 }
}
};

2
sql/sql_trigger.cc
View File

@ -164,7 +164,7 @@ Trigger_creation_ctx::create(THD *thd,
/*************************************************************************/
static const LEX_CSTRING triggers_file_type=
{ C_STRING_WITH_LEN("TRIGGERS") };
{ STRING_WITH_LEN("TRIGGERS") };
const char * const TRG_EXT= ".TRG";

66
sql/sql_type.cc
View File

@ -399,45 +399,45 @@ uint Type_handler_time::m_hires_bytes[MAX_DATETIME_PRECISION + 1]=
{ 3, 4, 4, 5, 5, 5, 6 };
/***************************************************************************/
const Name Type_handler_row::m_name_row(C_STRING_WITH_LEN("row"));
const Name Type_handler_row::m_name_row(STRING_WITH_LEN("row"));
const Name Type_handler_null::m_name_null(C_STRING_WITH_LEN("null"));
const Name Type_handler_null::m_name_null(STRING_WITH_LEN("null"));
const Name
Type_handler_string::m_name_char(C_STRING_WITH_LEN("char")),
Type_handler_var_string::m_name_var_string(C_STRING_WITH_LEN("varchar")),
Type_handler_varchar::m_name_varchar(C_STRING_WITH_LEN("varchar")),
Type_handler_tiny_blob::m_name_tinyblob(C_STRING_WITH_LEN("tinyblob")),
Type_handler_medium_blob::m_name_mediumblob(C_STRING_WITH_LEN("mediumblob")),
Type_handler_long_blob::m_name_longblob(C_STRING_WITH_LEN("longblob")),
Type_handler_blob::m_name_blob(C_STRING_WITH_LEN("blob"));
Type_handler_string::m_name_char(STRING_WITH_LEN("char")),
Type_handler_var_string::m_name_var_string(STRING_WITH_LEN("varchar")),
Type_handler_varchar::m_name_varchar(STRING_WITH_LEN("varchar")),
Type_handler_tiny_blob::m_name_tinyblob(STRING_WITH_LEN("tinyblob")),
Type_handler_medium_blob::m_name_mediumblob(STRING_WITH_LEN("mediumblob")),
Type_handler_long_blob::m_name_longblob(STRING_WITH_LEN("longblob")),
Type_handler_blob::m_name_blob(STRING_WITH_LEN("blob"));
const Name
Type_handler_enum::m_name_enum(C_STRING_WITH_LEN("enum")),
Type_handler_set::m_name_set(C_STRING_WITH_LEN("set"));
Type_handler_enum::m_name_enum(STRING_WITH_LEN("enum")),
Type_handler_set::m_name_set(STRING_WITH_LEN("set"));
const Name
Type_handler_tiny::m_name_tiny(C_STRING_WITH_LEN("tinyint")),
Type_handler_short::m_name_short(C_STRING_WITH_LEN("smallint")),
Type_handler_long::m_name_int(C_STRING_WITH_LEN("int")),
Type_handler_longlong::m_name_longlong(C_STRING_WITH_LEN("bigint")),
Type_handler_int24::m_name_mediumint(C_STRING_WITH_LEN("mediumint")),
Type_handler_year::m_name_year(C_STRING_WITH_LEN("year")),
Type_handler_bit::m_name_bit(C_STRING_WITH_LEN("bit"));
Type_handler_tiny::m_name_tiny(STRING_WITH_LEN("tinyint")),
Type_handler_short::m_name_short(STRING_WITH_LEN("smallint")),
Type_handler_long::m_name_int(STRING_WITH_LEN("int")),
Type_handler_longlong::m_name_longlong(STRING_WITH_LEN("bigint")),
Type_handler_int24::m_name_mediumint(STRING_WITH_LEN("mediumint")),
Type_handler_year::m_name_year(STRING_WITH_LEN("year")),
Type_handler_bit::m_name_bit(STRING_WITH_LEN("bit"));
const Name
Type_handler_float::m_name_float(C_STRING_WITH_LEN("float")),
Type_handler_double::m_name_double(C_STRING_WITH_LEN("double"));
Type_handler_float::m_name_float(STRING_WITH_LEN("float")),
Type_handler_double::m_name_double(STRING_WITH_LEN("double"));
const Name
Type_handler_olddecimal::m_name_decimal(C_STRING_WITH_LEN("decimal")),
Type_handler_newdecimal::m_name_decimal(C_STRING_WITH_LEN("decimal"));
Type_handler_olddecimal::m_name_decimal(STRING_WITH_LEN("decimal")),
Type_handler_newdecimal::m_name_decimal(STRING_WITH_LEN("decimal"));
const Name
Type_handler_time_common::m_name_time(C_STRING_WITH_LEN("time")),
Type_handler_date_common::m_name_date(C_STRING_WITH_LEN("date")),
Type_handler_datetime_common::m_name_datetime(C_STRING_WITH_LEN("datetime")),
Type_handler_timestamp_common::m_name_timestamp(C_STRING_WITH_LEN("timestamp"));
Type_handler_time_common::m_name_time(STRING_WITH_LEN("time")),
Type_handler_date_common::m_name_date(STRING_WITH_LEN("date")),
Type_handler_datetime_common::m_name_datetime(STRING_WITH_LEN("datetime")),
Type_handler_timestamp_common::m_name_timestamp(STRING_WITH_LEN("timestamp"));
/***************************************************************************/
@ -1388,7 +1388,7 @@ Field *Type_handler_long_blob::make_conversion_table_field(TABLE *table,
#ifdef HAVE_SPATIAL
const Name Type_handler_geometry::m_name_geometry(C_STRING_WITH_LEN("geometry"));
const Name Type_handler_geometry::m_name_geometry(STRING_WITH_LEN("geometry"));
const Type_handler *Type_handler_geometry::type_handler_for_comparison() const
@ -3966,7 +3966,7 @@ String *Type_handler_row::
{
CHARSET_INFO *cs= thd->variables.character_set_client;
StringBuffer<STRING_BUFFER_USUAL_SIZE> val(cs);
str->append(C_STRING_WITH_LEN("ROW("));
str->append(STRING_WITH_LEN("ROW("));
for (uint i= 0 ; i < item->cols(); i++)
{
if (i > 0)
@ -3978,7 +3978,7 @@ String *Type_handler_row::
else
str->append(STRING_WITH_LEN("NULL"));
}
str->append(C_STRING_WITH_LEN(")"));
str->append(STRING_WITH_LEN(")"));
return str;
}
@ -4042,7 +4042,7 @@ String *Type_handler_time_common::
{
StringBuffer<MAX_TIME_FULL_WIDTH+1> buf;
return print_item_value_temporal(thd, item, str,
Name(C_STRING_WITH_LEN("TIME")), &buf);
Name(STRING_WITH_LEN("TIME")), &buf);
}
@ -4051,7 +4051,7 @@ String *Type_handler_date_common::
{
StringBuffer<MAX_DATE_WIDTH+1> buf;
return print_item_value_temporal(thd, item, str,
Name(C_STRING_WITH_LEN("DATE")), &buf);
Name(STRING_WITH_LEN("DATE")), &buf);
}
@ -4060,7 +4060,7 @@ String *Type_handler_datetime_common::
{
StringBuffer<MAX_DATETIME_FULL_WIDTH+1> buf;
return print_item_value_temporal(thd, item, str,
Name(C_STRING_WITH_LEN("TIMESTAMP")), &buf);
Name(STRING_WITH_LEN("TIMESTAMP")), &buf);
}
@ -4069,7 +4069,7 @@ String *Type_handler_timestamp_common::
{
StringBuffer<MAX_DATETIME_FULL_WIDTH+1> buf;
return print_item_value_temporal(thd, item, str,
Name(C_STRING_WITH_LEN("TIMESTAMP")), &buf);
Name(STRING_WITH_LEN("TIMESTAMP")), &buf);
}

8
sql/sql_view.cc
View File

@ -652,10 +652,10 @@ bool mysql_create_view(THD *thd, TABLE_LIST *views,
{
StringBuffer<128> buff(thd->variables.character_set_client);
DBUG_ASSERT(buff.charset()->mbminlen == 1);
const LEX_STRING command[3]=
{{ C_STRING_WITH_LEN("CREATE ") },
{ C_STRING_WITH_LEN("ALTER ") },
{ C_STRING_WITH_LEN("CREATE OR REPLACE ") }};
const LEX_CSTRING command[3]=
{{ STRING_WITH_LEN("CREATE ") },
{ STRING_WITH_LEN("ALTER ") },
{ STRING_WITH_LEN("CREATE OR REPLACE ") }};
buff.append(&command[thd->lex->create_view->mode]);
view_store_options(thd, views, &buff);

8
sql/sql_yacc.yy
View File

@ -16188,14 +16188,14 @@ opt_lock_wait_timeout:
{}
| WAIT_SYM ulong_num
{
if (set_statement_var_if_exists(thd, C_STRING_WITH_LEN("lock_wait_timeout"), $2) ||
set_statement_var_if_exists(thd, C_STRING_WITH_LEN("innodb_lock_wait_timeout"), $2))
if (set_statement_var_if_exists(thd, STRING_WITH_LEN("lock_wait_timeout"), $2) ||
set_statement_var_if_exists(thd, STRING_WITH_LEN("innodb_lock_wait_timeout"), $2))
MYSQL_YYABORT;
}
| NOWAIT_SYM
{
if (set_statement_var_if_exists(thd, C_STRING_WITH_LEN("lock_wait_timeout"), 0) ||
set_statement_var_if_exists(thd, C_STRING_WITH_LEN("innodb_lock_wait_timeout"), 0))
if (set_statement_var_if_exists(thd, STRING_WITH_LEN("lock_wait_timeout"), 0) ||
set_statement_var_if_exists(thd, STRING_WITH_LEN("innodb_lock_wait_timeout"), 0))
MYSQL_YYABORT;
}
;

8
sql/sql_yacc_ora.yy
View File

@ -15764,14 +15764,14 @@ opt_lock_wait_timeout:
{}
| WAIT_SYM ulong_num
{
if (set_statement_var_if_exists(thd, C_STRING_WITH_LEN("lock_wait_timeout"), $2) ||
set_statement_var_if_exists(thd, C_STRING_WITH_LEN("innodb_lock_wait_timeout"), $2))
if (set_statement_var_if_exists(thd, STRING_WITH_LEN("lock_wait_timeout"), $2) ||
set_statement_var_if_exists(thd, STRING_WITH_LEN("innodb_lock_wait_timeout"), $2))
MYSQL_YYABORT;
}
| NOWAIT_SYM
{
if (set_statement_var_if_exists(thd, C_STRING_WITH_LEN("lock_wait_timeout"), 0) ||
set_statement_var_if_exists(thd, C_STRING_WITH_LEN("innodb_lock_wait_timeout"), 0))
if (set_statement_var_if_exists(thd, STRING_WITH_LEN("lock_wait_timeout"), 0) ||
set_statement_var_if_exists(thd, STRING_WITH_LEN("innodb_lock_wait_timeout"), 0))
MYSQL_YYABORT;
}
;

8
sql/tztime.cc
View File

@ -1478,10 +1478,10 @@ static bool time_zone_tables_exist= 1;
static const LEX_CSTRING tz_tables_names[MY_TZ_TABLES_COUNT]=
{
{ C_STRING_WITH_LEN("time_zone_name")},
{ C_STRING_WITH_LEN("time_zone")},
{ C_STRING_WITH_LEN("time_zone_transition_type")},
{ C_STRING_WITH_LEN("time_zone_transition")}
{ STRING_WITH_LEN("time_zone_name")},
{ STRING_WITH_LEN("time_zone")},
{ STRING_WITH_LEN("time_zone_transition_type")},
{ STRING_WITH_LEN("time_zone_transition")}
};
class Tz_names_entry: public Sql_alloc

8
sql/wsrep_mysqld.cc
View File

@ -1334,10 +1334,10 @@ create_view_query(THD *thd, uchar** buf, size_t* buf_len)
TABLE_LIST *views = first_table;
LEX_USER *definer;
String buff;
const LEX_STRING command[3]=
{{ C_STRING_WITH_LEN("CREATE ") },
{ C_STRING_WITH_LEN("ALTER ") },
{ C_STRING_WITH_LEN("CREATE OR REPLACE ") }};
const LEX_CSTRING command[3]=
{{ STRING_WITH_LEN("CREATE ") },
{ STRING_WITH_LEN("ALTER ") },
{ STRING_WITH_LEN("CREATE OR REPLACE ") }};
buff.append(&command[thd->lex->create_view->mode]);