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->length(0);
sp_sql->append(C_STRING_WITH_LEN("CREATE ")); sp_sql->append(STRING_WITH_LEN("CREATE "));
sp_sql->append(C_STRING_WITH_LEN("PROCEDURE ")); sp_sql->append(STRING_WITH_LEN("PROCEDURE "));
/* /*
Let's use the same name as the event name to perhaps produce a 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. 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 let's execute the procedure with the invoker rights to save on
resets of security contexts. 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); 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->set(buffer.str, buffer.length, system_charset_info);
sp_sql->length(0); 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); append_identifier(thd, sp_sql, &dbname);
sp_sql->append('.'); sp_sql->append('.');
append_identifier(thd, sp_sql, &name); 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] = const TABLE_FIELD_TYPE event_table_fields[ET_FIELD_COUNT] =
{ {
{ {
{ C_STRING_WITH_LEN("db") }, { STRING_WITH_LEN("db") },
{ C_STRING_WITH_LEN("char(64)") }, { STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("name") }, { STRING_WITH_LEN("name") },
{ C_STRING_WITH_LEN("char(64)") }, { STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("body") }, { STRING_WITH_LEN("body") },
{ C_STRING_WITH_LEN("longblob") }, { STRING_WITH_LEN("longblob") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("definer") }, { STRING_WITH_LEN("definer") },
{ C_STRING_WITH_LEN("char(") }, { STRING_WITH_LEN("char(") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("execute_at") }, { STRING_WITH_LEN("execute_at") },
{ C_STRING_WITH_LEN("datetime") }, { STRING_WITH_LEN("datetime") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("interval_value") }, { STRING_WITH_LEN("interval_value") },
{ C_STRING_WITH_LEN("int(11)") }, { STRING_WITH_LEN("int(11)") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("interval_field") }, { STRING_WITH_LEN("interval_field") },
{ C_STRING_WITH_LEN("enum('YEAR','QUARTER','MONTH','DAY'," { STRING_WITH_LEN("enum('YEAR','QUARTER','MONTH','DAY',"
"'HOUR','MINUTE','WEEK','SECOND','MICROSECOND','YEAR_MONTH','DAY_HOUR'," "'HOUR','MINUTE','WEEK','SECOND','MICROSECOND','YEAR_MONTH','DAY_HOUR',"
"'DAY_MINUTE','DAY_SECOND','HOUR_MINUTE','HOUR_SECOND','MINUTE_SECOND'," "'DAY_MINUTE','DAY_SECOND','HOUR_MINUTE','HOUR_SECOND','MINUTE_SECOND',"
"'DAY_MICROSECOND','HOUR_MICROSECOND','MINUTE_MICROSECOND'," "'DAY_MICROSECOND','HOUR_MICROSECOND','MINUTE_MICROSECOND',"
@ -80,43 +80,43 @@ const TABLE_FIELD_TYPE event_table_fields[ET_FIELD_COUNT] =
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("created") }, { STRING_WITH_LEN("created") },
{ C_STRING_WITH_LEN("timestamp") }, { STRING_WITH_LEN("timestamp") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("modified") }, { STRING_WITH_LEN("modified") },
{ C_STRING_WITH_LEN("timestamp") }, { STRING_WITH_LEN("timestamp") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("last_executed") }, { STRING_WITH_LEN("last_executed") },
{ C_STRING_WITH_LEN("datetime") }, { STRING_WITH_LEN("datetime") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("starts") }, { STRING_WITH_LEN("starts") },
{ C_STRING_WITH_LEN("datetime") }, { STRING_WITH_LEN("datetime") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("ends") }, { STRING_WITH_LEN("ends") },
{ C_STRING_WITH_LEN("datetime") }, { STRING_WITH_LEN("datetime") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("status") }, { STRING_WITH_LEN("status") },
{ C_STRING_WITH_LEN("enum('ENABLED','DISABLED','SLAVESIDE_DISABLED')") }, { STRING_WITH_LEN("enum('ENABLED','DISABLED','SLAVESIDE_DISABLED')") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("on_completion") }, { STRING_WITH_LEN("on_completion") },
{ C_STRING_WITH_LEN("enum('DROP','PRESERVE')") }, { STRING_WITH_LEN("enum('DROP','PRESERVE')") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("sql_mode") }, { STRING_WITH_LEN("sql_mode") },
{ C_STRING_WITH_LEN("set('REAL_AS_FLOAT','PIPES_AS_CONCAT','ANSI_QUOTES'," { STRING_WITH_LEN("set('REAL_AS_FLOAT','PIPES_AS_CONCAT','ANSI_QUOTES',"
"'IGNORE_SPACE','IGNORE_BAD_TABLE_OPTIONS','ONLY_FULL_GROUP_BY'," "'IGNORE_SPACE','IGNORE_BAD_TABLE_OPTIONS','ONLY_FULL_GROUP_BY',"
"'NO_UNSIGNED_SUBTRACTION'," "'NO_UNSIGNED_SUBTRACTION',"
"'NO_DIR_IN_CREATE','POSTGRESQL','ORACLE','MSSQL','DB2','MAXDB'," "'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} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("comment") }, { STRING_WITH_LEN("comment") },
{ C_STRING_WITH_LEN("char(64)") }, { STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("originator") }, { STRING_WITH_LEN("originator") },
{ C_STRING_WITH_LEN("int(10)") }, { STRING_WITH_LEN("int(10)") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("time_zone") }, { STRING_WITH_LEN("time_zone") },
{ C_STRING_WITH_LEN("char(64)") }, { STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("latin1") } { STRING_WITH_LEN("latin1") }
}, },
{ {
{ C_STRING_WITH_LEN("character_set_client") }, { STRING_WITH_LEN("character_set_client") },
{ C_STRING_WITH_LEN("char(32)") }, { STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("collation_connection") }, { STRING_WITH_LEN("collation_connection") },
{ C_STRING_WITH_LEN("char(32)") }, { STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("db_collation") }, { STRING_WITH_LEN("db_collation") },
{ C_STRING_WITH_LEN("char(32)") }, { STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("body_utf8") }, { STRING_WITH_LEN("body_utf8") },
{ C_STRING_WITH_LEN("longblob") }, { STRING_WITH_LEN("longblob") },
{ NULL, 0 } { NULL, 0 }
} }
}; };

8
sql/event_scheduler.cc
View File

@ -49,11 +49,11 @@ Event_db_repository *Event_worker_thread::db_repository;
static static
const LEX_STRING scheduler_states_names[] = const LEX_CSTRING scheduler_states_names[] =
{ {
{ C_STRING_WITH_LEN("INITIALIZED") }, { STRING_WITH_LEN("INITIALIZED") },
{ C_STRING_WITH_LEN("RUNNING") }, { STRING_WITH_LEN("RUNNING") },
{ C_STRING_WITH_LEN("STOPPING") } { STRING_WITH_LEN("STOPPING") }
}; };
struct scheduler_param { 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 */ /* Create date string inplace */
switch (value.time.time_type) { switch (value.time.time_type) {
case MYSQL_TIMESTAMP_DATE: case MYSQL_TIMESTAMP_DATE:
str->append(C_STRING_WITH_LEN("DATE")); str->append(STRING_WITH_LEN("DATE"));
break; break;
case MYSQL_TIMESTAMP_TIME: case MYSQL_TIMESTAMP_TIME:
str->append(C_STRING_WITH_LEN("TIME")); str->append(STRING_WITH_LEN("TIME"));
break; break;
case MYSQL_TIMESTAMP_DATETIME: case MYSQL_TIMESTAMP_DATETIME:
str->append(C_STRING_WITH_LEN("TIMESTAMP")); str->append(STRING_WITH_LEN("TIMESTAMP"));
break; break;
case MYSQL_TIMESTAMP_ERROR: case MYSQL_TIMESTAMP_ERROR:
case MYSQL_TIMESTAMP_NONE: 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[] = static Native_func_registry func_array[] =
{ {
{ { C_STRING_WITH_LEN("ABS") }, BUILDER(Create_func_abs)}, { { STRING_WITH_LEN("ABS") }, BUILDER(Create_func_abs)},
{ { C_STRING_WITH_LEN("ACOS") }, BUILDER(Create_func_acos)}, { { STRING_WITH_LEN("ACOS") }, BUILDER(Create_func_acos)},
{ { C_STRING_WITH_LEN("ADDTIME") }, BUILDER(Create_func_addtime)}, { { STRING_WITH_LEN("ADDTIME") }, BUILDER(Create_func_addtime)},
{ { C_STRING_WITH_LEN("AES_DECRYPT") }, BUILDER(Create_func_aes_decrypt)}, { { STRING_WITH_LEN("AES_DECRYPT") }, BUILDER(Create_func_aes_decrypt)},
{ { C_STRING_WITH_LEN("AES_ENCRYPT") }, BUILDER(Create_func_aes_encrypt)}, { { STRING_WITH_LEN("AES_ENCRYPT") }, BUILDER(Create_func_aes_encrypt)},
{ { C_STRING_WITH_LEN("AREA") }, GEOM_BUILDER(Create_func_area)}, { { STRING_WITH_LEN("AREA") }, GEOM_BUILDER(Create_func_area)},
{ { C_STRING_WITH_LEN("ASBINARY") }, GEOM_BUILDER(Create_func_as_wkb)}, { { STRING_WITH_LEN("ASBINARY") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { C_STRING_WITH_LEN("ASIN") }, BUILDER(Create_func_asin)}, { { STRING_WITH_LEN("ASIN") }, BUILDER(Create_func_asin)},
{ { C_STRING_WITH_LEN("ASTEXT") }, GEOM_BUILDER(Create_func_as_wkt)}, { { STRING_WITH_LEN("ASTEXT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { C_STRING_WITH_LEN("ASWKB") }, GEOM_BUILDER(Create_func_as_wkb)}, { { STRING_WITH_LEN("ASWKB") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { C_STRING_WITH_LEN("ASWKT") }, GEOM_BUILDER(Create_func_as_wkt)}, { { STRING_WITH_LEN("ASWKT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { C_STRING_WITH_LEN("ATAN") }, BUILDER(Create_func_atan)}, { { STRING_WITH_LEN("ATAN") }, BUILDER(Create_func_atan)},
{ { C_STRING_WITH_LEN("ATAN2") }, BUILDER(Create_func_atan)}, { { STRING_WITH_LEN("ATAN2") }, BUILDER(Create_func_atan)},
{ { C_STRING_WITH_LEN("BENCHMARK") }, BUILDER(Create_func_benchmark)}, { { STRING_WITH_LEN("BENCHMARK") }, BUILDER(Create_func_benchmark)},
{ { C_STRING_WITH_LEN("BIN") }, BUILDER(Create_func_bin)}, { { STRING_WITH_LEN("BIN") }, BUILDER(Create_func_bin)},
{ { C_STRING_WITH_LEN("BINLOG_GTID_POS") }, BUILDER(Create_func_binlog_gtid_pos)}, { { STRING_WITH_LEN("BINLOG_GTID_POS") }, BUILDER(Create_func_binlog_gtid_pos)},
{ { C_STRING_WITH_LEN("BIT_COUNT") }, BUILDER(Create_func_bit_count)}, { { STRING_WITH_LEN("BIT_COUNT") }, BUILDER(Create_func_bit_count)},
{ { C_STRING_WITH_LEN("BIT_LENGTH") }, BUILDER(Create_func_bit_length)}, { { STRING_WITH_LEN("BIT_LENGTH") }, BUILDER(Create_func_bit_length)},
{ { C_STRING_WITH_LEN("BOUNDARY") }, GEOM_BUILDER(Create_func_boundary)}, { { STRING_WITH_LEN("BOUNDARY") }, GEOM_BUILDER(Create_func_boundary)},
{ { C_STRING_WITH_LEN("BUFFER") }, GEOM_BUILDER(Create_func_buffer)}, { { STRING_WITH_LEN("BUFFER") }, GEOM_BUILDER(Create_func_buffer)},
{ { C_STRING_WITH_LEN("CEIL") }, BUILDER(Create_func_ceiling)}, { { STRING_WITH_LEN("CEIL") }, BUILDER(Create_func_ceiling)},
{ { C_STRING_WITH_LEN("CEILING") }, BUILDER(Create_func_ceiling)}, { { STRING_WITH_LEN("CEILING") }, BUILDER(Create_func_ceiling)},
{ { C_STRING_WITH_LEN("CENTROID") }, GEOM_BUILDER(Create_func_centroid)}, { { STRING_WITH_LEN("CENTROID") }, GEOM_BUILDER(Create_func_centroid)},
{ { C_STRING_WITH_LEN("CHARACTER_LENGTH") }, BUILDER(Create_func_char_length)}, { { STRING_WITH_LEN("CHARACTER_LENGTH") }, BUILDER(Create_func_char_length)},
{ { C_STRING_WITH_LEN("CHAR_LENGTH") }, BUILDER(Create_func_char_length)}, { { STRING_WITH_LEN("CHAR_LENGTH") }, BUILDER(Create_func_char_length)},
{ { C_STRING_WITH_LEN("CHR") }, BUILDER(Create_func_chr)}, { { STRING_WITH_LEN("CHR") }, BUILDER(Create_func_chr)},
{ { C_STRING_WITH_LEN("COERCIBILITY") }, BUILDER(Create_func_coercibility)}, { { STRING_WITH_LEN("COERCIBILITY") }, BUILDER(Create_func_coercibility)},
{ { C_STRING_WITH_LEN("COLUMN_CHECK") }, BUILDER(Create_func_dyncol_check)}, { { STRING_WITH_LEN("COLUMN_CHECK") }, BUILDER(Create_func_dyncol_check)},
{ { C_STRING_WITH_LEN("COLUMN_EXISTS") }, BUILDER(Create_func_dyncol_exists)}, { { STRING_WITH_LEN("COLUMN_EXISTS") }, BUILDER(Create_func_dyncol_exists)},
{ { C_STRING_WITH_LEN("COLUMN_LIST") }, BUILDER(Create_func_dyncol_list)}, { { STRING_WITH_LEN("COLUMN_LIST") }, BUILDER(Create_func_dyncol_list)},
{ { C_STRING_WITH_LEN("COLUMN_JSON") }, BUILDER(Create_func_dyncol_json)}, { { STRING_WITH_LEN("COLUMN_JSON") }, BUILDER(Create_func_dyncol_json)},
{ { C_STRING_WITH_LEN("COMPRESS") }, BUILDER(Create_func_compress)}, { { STRING_WITH_LEN("COMPRESS") }, BUILDER(Create_func_compress)},
{ { C_STRING_WITH_LEN("CONCAT") }, BUILDER(Create_func_concat)}, { { STRING_WITH_LEN("CONCAT") }, BUILDER(Create_func_concat)},
{ { C_STRING_WITH_LEN("CONCAT_OPERATOR_ORACLE") }, BUILDER(Create_func_concat_operator_oracle)}, { { STRING_WITH_LEN("CONCAT_OPERATOR_ORACLE") }, BUILDER(Create_func_concat_operator_oracle)},
{ { C_STRING_WITH_LEN("CONCAT_WS") }, BUILDER(Create_func_concat_ws)}, { { STRING_WITH_LEN("CONCAT_WS") }, BUILDER(Create_func_concat_ws)},
{ { C_STRING_WITH_LEN("CONNECTION_ID") }, BUILDER(Create_func_connection_id)}, { { STRING_WITH_LEN("CONNECTION_ID") }, BUILDER(Create_func_connection_id)},
{ { C_STRING_WITH_LEN("CONV") }, BUILDER(Create_func_conv)}, { { STRING_WITH_LEN("CONV") }, BUILDER(Create_func_conv)},
{ { C_STRING_WITH_LEN("CONVERT_TZ") }, BUILDER(Create_func_convert_tz)}, { { STRING_WITH_LEN("CONVERT_TZ") }, BUILDER(Create_func_convert_tz)},
{ { C_STRING_WITH_LEN("CONVEXHULL") }, GEOM_BUILDER(Create_func_convexhull)}, { { STRING_WITH_LEN("CONVEXHULL") }, GEOM_BUILDER(Create_func_convexhull)},
{ { C_STRING_WITH_LEN("COS") }, BUILDER(Create_func_cos)}, { { STRING_WITH_LEN("COS") }, BUILDER(Create_func_cos)},
{ { C_STRING_WITH_LEN("COT") }, BUILDER(Create_func_cot)}, { { STRING_WITH_LEN("COT") }, BUILDER(Create_func_cot)},
{ { C_STRING_WITH_LEN("CRC32") }, BUILDER(Create_func_crc32)}, { { STRING_WITH_LEN("CRC32") }, BUILDER(Create_func_crc32)},
{ { C_STRING_WITH_LEN("CROSSES") }, GEOM_BUILDER(Create_func_crosses)}, { { STRING_WITH_LEN("CROSSES") }, GEOM_BUILDER(Create_func_crosses)},
{ { C_STRING_WITH_LEN("DATEDIFF") }, BUILDER(Create_func_datediff)}, { { STRING_WITH_LEN("DATEDIFF") }, BUILDER(Create_func_datediff)},
{ { C_STRING_WITH_LEN("DAYNAME") }, BUILDER(Create_func_dayname)}, { { STRING_WITH_LEN("DAYNAME") }, BUILDER(Create_func_dayname)},
{ { C_STRING_WITH_LEN("DAYOFMONTH") }, BUILDER(Create_func_dayofmonth)}, { { STRING_WITH_LEN("DAYOFMONTH") }, BUILDER(Create_func_dayofmonth)},
{ { C_STRING_WITH_LEN("DAYOFWEEK") }, BUILDER(Create_func_dayofweek)}, { { STRING_WITH_LEN("DAYOFWEEK") }, BUILDER(Create_func_dayofweek)},
{ { C_STRING_WITH_LEN("DAYOFYEAR") }, BUILDER(Create_func_dayofyear)}, { { STRING_WITH_LEN("DAYOFYEAR") }, BUILDER(Create_func_dayofyear)},
{ { C_STRING_WITH_LEN("DEGREES") }, BUILDER(Create_func_degrees)}, { { STRING_WITH_LEN("DEGREES") }, BUILDER(Create_func_degrees)},
{ { C_STRING_WITH_LEN("DECODE_HISTOGRAM") }, BUILDER(Create_func_decode_histogram)}, { { STRING_WITH_LEN("DECODE_HISTOGRAM") }, BUILDER(Create_func_decode_histogram)},
{ { C_STRING_WITH_LEN("DECODE_ORACLE") }, BUILDER(Create_func_decode_oracle)}, { { STRING_WITH_LEN("DECODE_ORACLE") }, BUILDER(Create_func_decode_oracle)},
{ { C_STRING_WITH_LEN("DES_DECRYPT") }, BUILDER(Create_func_des_decrypt)}, { { STRING_WITH_LEN("DES_DECRYPT") }, BUILDER(Create_func_des_decrypt)},
{ { C_STRING_WITH_LEN("DES_ENCRYPT") }, BUILDER(Create_func_des_encrypt)}, { { STRING_WITH_LEN("DES_ENCRYPT") }, BUILDER(Create_func_des_encrypt)},
{ { C_STRING_WITH_LEN("DIMENSION") }, GEOM_BUILDER(Create_func_dimension)}, { { STRING_WITH_LEN("DIMENSION") }, GEOM_BUILDER(Create_func_dimension)},
{ { C_STRING_WITH_LEN("DISJOINT") }, GEOM_BUILDER(Create_func_mbr_disjoint)}, { { STRING_WITH_LEN("DISJOINT") }, GEOM_BUILDER(Create_func_mbr_disjoint)},
{ { C_STRING_WITH_LEN("ELT") }, BUILDER(Create_func_elt)}, { { STRING_WITH_LEN("ELT") }, BUILDER(Create_func_elt)},
{ { C_STRING_WITH_LEN("ENCODE") }, BUILDER(Create_func_encode)}, { { STRING_WITH_LEN("ENCODE") }, BUILDER(Create_func_encode)},
{ { C_STRING_WITH_LEN("ENCRYPT") }, BUILDER(Create_func_encrypt)}, { { STRING_WITH_LEN("ENCRYPT") }, BUILDER(Create_func_encrypt)},
{ { C_STRING_WITH_LEN("ENDPOINT") }, GEOM_BUILDER(Create_func_endpoint)}, { { STRING_WITH_LEN("ENDPOINT") }, GEOM_BUILDER(Create_func_endpoint)},
{ { C_STRING_WITH_LEN("ENVELOPE") }, GEOM_BUILDER(Create_func_envelope)}, { { STRING_WITH_LEN("ENVELOPE") }, GEOM_BUILDER(Create_func_envelope)},
{ { C_STRING_WITH_LEN("EQUALS") }, GEOM_BUILDER(Create_func_equals)}, { { STRING_WITH_LEN("EQUALS") }, GEOM_BUILDER(Create_func_equals)},
{ { C_STRING_WITH_LEN("EXP") }, BUILDER(Create_func_exp)}, { { STRING_WITH_LEN("EXP") }, BUILDER(Create_func_exp)},
{ { C_STRING_WITH_LEN("EXPORT_SET") }, BUILDER(Create_func_export_set)}, { { STRING_WITH_LEN("EXPORT_SET") }, BUILDER(Create_func_export_set)},
{ { C_STRING_WITH_LEN("EXTERIORRING") }, GEOM_BUILDER(Create_func_exteriorring)}, { { STRING_WITH_LEN("EXTERIORRING") }, GEOM_BUILDER(Create_func_exteriorring)},
{ { C_STRING_WITH_LEN("EXTRACTVALUE") }, BUILDER(Create_func_xml_extractvalue)}, { { STRING_WITH_LEN("EXTRACTVALUE") }, BUILDER(Create_func_xml_extractvalue)},
{ { C_STRING_WITH_LEN("FIELD") }, BUILDER(Create_func_field)}, { { STRING_WITH_LEN("FIELD") }, BUILDER(Create_func_field)},
{ { C_STRING_WITH_LEN("FIND_IN_SET") }, BUILDER(Create_func_find_in_set)}, { { STRING_WITH_LEN("FIND_IN_SET") }, BUILDER(Create_func_find_in_set)},
{ { C_STRING_WITH_LEN("FLOOR") }, BUILDER(Create_func_floor)}, { { STRING_WITH_LEN("FLOOR") }, BUILDER(Create_func_floor)},
{ { C_STRING_WITH_LEN("FORMAT") }, BUILDER(Create_func_format)}, { { STRING_WITH_LEN("FORMAT") }, BUILDER(Create_func_format)},
{ { C_STRING_WITH_LEN("FOUND_ROWS") }, BUILDER(Create_func_found_rows)}, { { STRING_WITH_LEN("FOUND_ROWS") }, BUILDER(Create_func_found_rows)},
{ { C_STRING_WITH_LEN("FROM_BASE64") }, BUILDER(Create_func_from_base64)}, { { STRING_WITH_LEN("FROM_BASE64") }, BUILDER(Create_func_from_base64)},
{ { C_STRING_WITH_LEN("FROM_DAYS") }, BUILDER(Create_func_from_days)}, { { STRING_WITH_LEN("FROM_DAYS") }, BUILDER(Create_func_from_days)},
{ { C_STRING_WITH_LEN("FROM_UNIXTIME") }, BUILDER(Create_func_from_unixtime)}, { { STRING_WITH_LEN("FROM_UNIXTIME") }, BUILDER(Create_func_from_unixtime)},
{ { C_STRING_WITH_LEN("GEOMCOLLFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("GEOMCOLLFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("GEOMCOLLFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("GEOMCOLLFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("GEOMETRYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("GEOMETRYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("GEOMETRYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("GEOMETRYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("GEOMETRYN") }, GEOM_BUILDER(Create_func_geometryn)}, { { STRING_WITH_LEN("GEOMETRYN") }, GEOM_BUILDER(Create_func_geometryn)},
{ { C_STRING_WITH_LEN("GEOMETRYTYPE") }, GEOM_BUILDER(Create_func_geometry_type)}, { { STRING_WITH_LEN("GEOMETRYTYPE") }, GEOM_BUILDER(Create_func_geometry_type)},
{ { C_STRING_WITH_LEN("GEOMFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("GEOMFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("GEOMFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("GEOMFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("GET_LOCK") }, BUILDER(Create_func_get_lock)}, { { STRING_WITH_LEN("GET_LOCK") }, BUILDER(Create_func_get_lock)},
{ { C_STRING_WITH_LEN("GLENGTH") }, GEOM_BUILDER(Create_func_glength)}, { { STRING_WITH_LEN("GLENGTH") }, GEOM_BUILDER(Create_func_glength)},
{ { C_STRING_WITH_LEN("GREATEST") }, BUILDER(Create_func_greatest)}, { { STRING_WITH_LEN("GREATEST") }, BUILDER(Create_func_greatest)},
{ { C_STRING_WITH_LEN("HEX") }, BUILDER(Create_func_hex)}, { { STRING_WITH_LEN("HEX") }, BUILDER(Create_func_hex)},
{ { C_STRING_WITH_LEN("IFNULL") }, BUILDER(Create_func_ifnull)}, { { STRING_WITH_LEN("IFNULL") }, BUILDER(Create_func_ifnull)},
{ { C_STRING_WITH_LEN("INET_ATON") }, BUILDER(Create_func_inet_aton)}, { { STRING_WITH_LEN("INET_ATON") }, BUILDER(Create_func_inet_aton)},
{ { C_STRING_WITH_LEN("INET_NTOA") }, BUILDER(Create_func_inet_ntoa)}, { { STRING_WITH_LEN("INET_NTOA") }, BUILDER(Create_func_inet_ntoa)},
{ { C_STRING_WITH_LEN("INET6_ATON") }, BUILDER(Create_func_inet6_aton)}, { { STRING_WITH_LEN("INET6_ATON") }, BUILDER(Create_func_inet6_aton)},
{ { C_STRING_WITH_LEN("INET6_NTOA") }, BUILDER(Create_func_inet6_ntoa)}, { { STRING_WITH_LEN("INET6_NTOA") }, BUILDER(Create_func_inet6_ntoa)},
{ { C_STRING_WITH_LEN("IS_IPV4") }, BUILDER(Create_func_is_ipv4)}, { { STRING_WITH_LEN("IS_IPV4") }, BUILDER(Create_func_is_ipv4)},
{ { C_STRING_WITH_LEN("IS_IPV6") }, BUILDER(Create_func_is_ipv6)}, { { STRING_WITH_LEN("IS_IPV6") }, BUILDER(Create_func_is_ipv6)},
{ { C_STRING_WITH_LEN("IS_IPV4_COMPAT") }, BUILDER(Create_func_is_ipv4_compat)}, { { 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)}, { { STRING_WITH_LEN("IS_IPV4_MAPPED") }, BUILDER(Create_func_is_ipv4_mapped)},
{ { C_STRING_WITH_LEN("INSTR") }, BUILDER(Create_func_instr)}, { { STRING_WITH_LEN("INSTR") }, BUILDER(Create_func_instr)},
{ { C_STRING_WITH_LEN("INTERIORRINGN") }, GEOM_BUILDER(Create_func_interiorringn)}, { { STRING_WITH_LEN("INTERIORRINGN") }, GEOM_BUILDER(Create_func_interiorringn)},
{ { C_STRING_WITH_LEN("INTERSECTS") }, GEOM_BUILDER(Create_func_mbr_intersects)}, { { STRING_WITH_LEN("INTERSECTS") }, GEOM_BUILDER(Create_func_mbr_intersects)},
{ { C_STRING_WITH_LEN("ISCLOSED") }, GEOM_BUILDER(Create_func_isclosed)}, { { STRING_WITH_LEN("ISCLOSED") }, GEOM_BUILDER(Create_func_isclosed)},
{ { C_STRING_WITH_LEN("ISEMPTY") }, GEOM_BUILDER(Create_func_isempty)}, { { STRING_WITH_LEN("ISEMPTY") }, GEOM_BUILDER(Create_func_isempty)},
{ { C_STRING_WITH_LEN("ISNULL") }, BUILDER(Create_func_isnull)}, { { STRING_WITH_LEN("ISNULL") }, BUILDER(Create_func_isnull)},
{ { C_STRING_WITH_LEN("ISRING") }, GEOM_BUILDER(Create_func_isring)}, { { STRING_WITH_LEN("ISRING") }, GEOM_BUILDER(Create_func_isring)},
{ { C_STRING_WITH_LEN("ISSIMPLE") }, GEOM_BUILDER(Create_func_issimple)}, { { STRING_WITH_LEN("ISSIMPLE") }, GEOM_BUILDER(Create_func_issimple)},
{ { C_STRING_WITH_LEN("IS_FREE_LOCK") }, BUILDER(Create_func_is_free_lock)}, { { 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)}, { { STRING_WITH_LEN("IS_USED_LOCK") }, BUILDER(Create_func_is_used_lock)},
{ { C_STRING_WITH_LEN("JSON_ARRAY") }, BUILDER(Create_func_json_array)}, { { STRING_WITH_LEN("JSON_ARRAY") }, BUILDER(Create_func_json_array)},
{ { C_STRING_WITH_LEN("JSON_ARRAY_APPEND") }, BUILDER(Create_func_json_array_append)}, { { 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)}, { { STRING_WITH_LEN("JSON_ARRAY_INSERT") }, BUILDER(Create_func_json_array_insert)},
{ { C_STRING_WITH_LEN("JSON_COMPACT") }, BUILDER(Create_func_json_compact)}, { { STRING_WITH_LEN("JSON_COMPACT") }, BUILDER(Create_func_json_compact)},
{ { C_STRING_WITH_LEN("JSON_CONTAINS") }, BUILDER(Create_func_json_contains)}, { { STRING_WITH_LEN("JSON_CONTAINS") }, BUILDER(Create_func_json_contains)},
{ { C_STRING_WITH_LEN("JSON_CONTAINS_PATH") }, BUILDER(Create_func_json_contains_path)}, { { STRING_WITH_LEN("JSON_CONTAINS_PATH") }, BUILDER(Create_func_json_contains_path)},
{ { C_STRING_WITH_LEN("JSON_DEPTH") }, BUILDER(Create_func_json_depth)}, { { STRING_WITH_LEN("JSON_DEPTH") }, BUILDER(Create_func_json_depth)},
{ { C_STRING_WITH_LEN("JSON_DETAILED") }, BUILDER(Create_func_json_detailed)}, { { STRING_WITH_LEN("JSON_DETAILED") }, BUILDER(Create_func_json_detailed)},
{ { C_STRING_WITH_LEN("JSON_EXISTS") }, BUILDER(Create_func_json_exists)}, { { STRING_WITH_LEN("JSON_EXISTS") }, BUILDER(Create_func_json_exists)},
{ { C_STRING_WITH_LEN("JSON_EXTRACT") }, BUILDER(Create_func_json_extract)}, { { STRING_WITH_LEN("JSON_EXTRACT") }, BUILDER(Create_func_json_extract)},
{ { C_STRING_WITH_LEN("JSON_INSERT") }, BUILDER(Create_func_json_insert)}, { { STRING_WITH_LEN("JSON_INSERT") }, BUILDER(Create_func_json_insert)},
{ { C_STRING_WITH_LEN("JSON_KEYS") }, BUILDER(Create_func_json_keys)}, { { STRING_WITH_LEN("JSON_KEYS") }, BUILDER(Create_func_json_keys)},
{ { C_STRING_WITH_LEN("JSON_LENGTH") }, BUILDER(Create_func_json_length)}, { { STRING_WITH_LEN("JSON_LENGTH") }, BUILDER(Create_func_json_length)},
{ { C_STRING_WITH_LEN("JSON_LOOSE") }, BUILDER(Create_func_json_loose)}, { { STRING_WITH_LEN("JSON_LOOSE") }, BUILDER(Create_func_json_loose)},
{ { C_STRING_WITH_LEN("JSON_MERGE") }, BUILDER(Create_func_json_merge)}, { { STRING_WITH_LEN("JSON_MERGE") }, BUILDER(Create_func_json_merge)},
{ { C_STRING_WITH_LEN("JSON_QUERY") }, BUILDER(Create_func_json_query)}, { { STRING_WITH_LEN("JSON_QUERY") }, BUILDER(Create_func_json_query)},
{ { C_STRING_WITH_LEN("JSON_QUOTE") }, BUILDER(Create_func_json_quote)}, { { STRING_WITH_LEN("JSON_QUOTE") }, BUILDER(Create_func_json_quote)},
{ { C_STRING_WITH_LEN("JSON_OBJECT") }, BUILDER(Create_func_json_object)}, { { STRING_WITH_LEN("JSON_OBJECT") }, BUILDER(Create_func_json_object)},
{ { C_STRING_WITH_LEN("JSON_REMOVE") }, BUILDER(Create_func_json_remove)}, { { STRING_WITH_LEN("JSON_REMOVE") }, BUILDER(Create_func_json_remove)},
{ { C_STRING_WITH_LEN("JSON_REPLACE") }, BUILDER(Create_func_json_replace)}, { { STRING_WITH_LEN("JSON_REPLACE") }, BUILDER(Create_func_json_replace)},
{ { C_STRING_WITH_LEN("JSON_SET") }, BUILDER(Create_func_json_set)}, { { STRING_WITH_LEN("JSON_SET") }, BUILDER(Create_func_json_set)},
{ { C_STRING_WITH_LEN("JSON_SEARCH") }, BUILDER(Create_func_json_search)}, { { STRING_WITH_LEN("JSON_SEARCH") }, BUILDER(Create_func_json_search)},
{ { C_STRING_WITH_LEN("JSON_TYPE") }, BUILDER(Create_func_json_type)}, { { STRING_WITH_LEN("JSON_TYPE") }, BUILDER(Create_func_json_type)},
{ { C_STRING_WITH_LEN("JSON_UNQUOTE") }, BUILDER(Create_func_json_unquote)}, { { STRING_WITH_LEN("JSON_UNQUOTE") }, BUILDER(Create_func_json_unquote)},
{ { C_STRING_WITH_LEN("JSON_VALID") }, BUILDER(Create_func_json_valid)}, { { STRING_WITH_LEN("JSON_VALID") }, BUILDER(Create_func_json_valid)},
{ { C_STRING_WITH_LEN("JSON_VALUE") }, BUILDER(Create_func_json_value)}, { { STRING_WITH_LEN("JSON_VALUE") }, BUILDER(Create_func_json_value)},
{ { C_STRING_WITH_LEN("LAST_DAY") }, BUILDER(Create_func_last_day)}, { { STRING_WITH_LEN("LAST_DAY") }, BUILDER(Create_func_last_day)},
{ { C_STRING_WITH_LEN("LAST_INSERT_ID") }, BUILDER(Create_func_last_insert_id)}, { { STRING_WITH_LEN("LAST_INSERT_ID") }, BUILDER(Create_func_last_insert_id)},
{ { C_STRING_WITH_LEN("LCASE") }, BUILDER(Create_func_lcase)}, { { STRING_WITH_LEN("LCASE") }, BUILDER(Create_func_lcase)},
{ { C_STRING_WITH_LEN("LEAST") }, BUILDER(Create_func_least)}, { { STRING_WITH_LEN("LEAST") }, BUILDER(Create_func_least)},
{ { C_STRING_WITH_LEN("LENGTH") }, BUILDER(Create_func_length)}, { { STRING_WITH_LEN("LENGTH") }, BUILDER(Create_func_length)},
{ { C_STRING_WITH_LEN("LENGTHB") }, BUILDER(Create_func_octet_length)}, { { STRING_WITH_LEN("LENGTHB") }, BUILDER(Create_func_octet_length)},
#ifndef DBUG_OFF #ifndef DBUG_OFF
{ { C_STRING_WITH_LEN("LIKE_RANGE_MIN") }, BUILDER(Create_func_like_range_min)}, { { 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_MAX") }, BUILDER(Create_func_like_range_max)},
#endif #endif
{ { C_STRING_WITH_LEN("LINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("LINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("LINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("LINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("LINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("LINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("LINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("LINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("LN") }, BUILDER(Create_func_ln)}, { { STRING_WITH_LEN("LN") }, BUILDER(Create_func_ln)},
{ { C_STRING_WITH_LEN("LOAD_FILE") }, BUILDER(Create_func_load_file)}, { { STRING_WITH_LEN("LOAD_FILE") }, BUILDER(Create_func_load_file)},
{ { C_STRING_WITH_LEN("LOCATE") }, BUILDER(Create_func_locate)}, { { STRING_WITH_LEN("LOCATE") }, BUILDER(Create_func_locate)},
{ { C_STRING_WITH_LEN("LOG") }, BUILDER(Create_func_log)}, { { STRING_WITH_LEN("LOG") }, BUILDER(Create_func_log)},
{ { C_STRING_WITH_LEN("LOG10") }, BUILDER(Create_func_log10)}, { { STRING_WITH_LEN("LOG10") }, BUILDER(Create_func_log10)},
{ { C_STRING_WITH_LEN("LOG2") }, BUILDER(Create_func_log2)}, { { STRING_WITH_LEN("LOG2") }, BUILDER(Create_func_log2)},
{ { C_STRING_WITH_LEN("LOWER") }, BUILDER(Create_func_lcase)}, { { STRING_WITH_LEN("LOWER") }, BUILDER(Create_func_lcase)},
{ { C_STRING_WITH_LEN("LPAD") }, BUILDER(Create_func_lpad)}, { { STRING_WITH_LEN("LPAD") }, BUILDER(Create_func_lpad)},
{ { C_STRING_WITH_LEN("LTRIM") }, BUILDER(Create_func_ltrim)}, { { STRING_WITH_LEN("LTRIM") }, BUILDER(Create_func_ltrim)},
{ { C_STRING_WITH_LEN("MAKEDATE") }, BUILDER(Create_func_makedate)}, { { STRING_WITH_LEN("MAKEDATE") }, BUILDER(Create_func_makedate)},
{ { C_STRING_WITH_LEN("MAKETIME") }, BUILDER(Create_func_maketime)}, { { STRING_WITH_LEN("MAKETIME") }, BUILDER(Create_func_maketime)},
{ { C_STRING_WITH_LEN("MAKE_SET") }, BUILDER(Create_func_make_set)}, { { STRING_WITH_LEN("MAKE_SET") }, BUILDER(Create_func_make_set)},
{ { C_STRING_WITH_LEN("MASTER_GTID_WAIT") }, BUILDER(Create_func_master_gtid_wait)}, { { 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)}, { { STRING_WITH_LEN("MASTER_POS_WAIT") }, BUILDER(Create_func_master_pos_wait)},
{ { C_STRING_WITH_LEN("MBRCONTAINS") }, GEOM_BUILDER(Create_func_mbr_contains)}, { { STRING_WITH_LEN("MBRCONTAINS") }, GEOM_BUILDER(Create_func_mbr_contains)},
{ { C_STRING_WITH_LEN("MBRDISJOINT") }, GEOM_BUILDER(Create_func_mbr_disjoint)}, { { STRING_WITH_LEN("MBRDISJOINT") }, GEOM_BUILDER(Create_func_mbr_disjoint)},
{ { C_STRING_WITH_LEN("MBREQUAL") }, GEOM_BUILDER(Create_func_mbr_equals)}, { { STRING_WITH_LEN("MBREQUAL") }, GEOM_BUILDER(Create_func_mbr_equals)},
{ { C_STRING_WITH_LEN("MBREQUALS") }, GEOM_BUILDER(Create_func_mbr_equals)}, { { STRING_WITH_LEN("MBREQUALS") }, GEOM_BUILDER(Create_func_mbr_equals)},
{ { C_STRING_WITH_LEN("MBRINTERSECTS") }, GEOM_BUILDER(Create_func_mbr_intersects)}, { { STRING_WITH_LEN("MBRINTERSECTS") }, GEOM_BUILDER(Create_func_mbr_intersects)},
{ { C_STRING_WITH_LEN("MBROVERLAPS") }, GEOM_BUILDER(Create_func_mbr_overlaps)}, { { STRING_WITH_LEN("MBROVERLAPS") }, GEOM_BUILDER(Create_func_mbr_overlaps)},
{ { C_STRING_WITH_LEN("MBRTOUCHES") }, GEOM_BUILDER(Create_func_touches)}, { { STRING_WITH_LEN("MBRTOUCHES") }, GEOM_BUILDER(Create_func_touches)},
{ { C_STRING_WITH_LEN("MBRWITHIN") }, GEOM_BUILDER(Create_func_mbr_within)}, { { STRING_WITH_LEN("MBRWITHIN") }, GEOM_BUILDER(Create_func_mbr_within)},
{ { C_STRING_WITH_LEN("MD5") }, BUILDER(Create_func_md5)}, { { STRING_WITH_LEN("MD5") }, BUILDER(Create_func_md5)},
{ { C_STRING_WITH_LEN("MLINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("MLINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MLINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("MLINEFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("MONTHNAME") }, BUILDER(Create_func_monthname)}, { { STRING_WITH_LEN("MONTHNAME") }, BUILDER(Create_func_monthname)},
{ { C_STRING_WITH_LEN("MPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("MPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("MPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("MPOLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("MPOLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MPOLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("MPOLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("MULTILINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("MULTILINESTRINGFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MULTILINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("MULTILINESTRINGFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("MULTIPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("MULTIPOINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MULTIPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("MULTIPOINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("MULTIPOLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("MULTIPOLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("MULTIPOLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("MULTIPOLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("NAME_CONST") }, BUILDER(Create_func_name_const)}, { { STRING_WITH_LEN("NAME_CONST") }, BUILDER(Create_func_name_const)},
{ { C_STRING_WITH_LEN("NVL") }, BUILDER(Create_func_ifnull)}, { { STRING_WITH_LEN("NVL") }, BUILDER(Create_func_ifnull)},
{ { C_STRING_WITH_LEN("NVL2") }, BUILDER(Create_func_nvl2)}, { { STRING_WITH_LEN("NVL2") }, BUILDER(Create_func_nvl2)},
{ { C_STRING_WITH_LEN("NULLIF") }, BUILDER(Create_func_nullif)}, { { STRING_WITH_LEN("NULLIF") }, BUILDER(Create_func_nullif)},
{ { C_STRING_WITH_LEN("NUMGEOMETRIES") }, GEOM_BUILDER(Create_func_numgeometries)}, { { STRING_WITH_LEN("NUMGEOMETRIES") }, GEOM_BUILDER(Create_func_numgeometries)},
{ { C_STRING_WITH_LEN("NUMINTERIORRINGS") }, GEOM_BUILDER(Create_func_numinteriorring)}, { { STRING_WITH_LEN("NUMINTERIORRINGS") }, GEOM_BUILDER(Create_func_numinteriorring)},
{ { C_STRING_WITH_LEN("NUMPOINTS") }, GEOM_BUILDER(Create_func_numpoints)}, { { STRING_WITH_LEN("NUMPOINTS") }, GEOM_BUILDER(Create_func_numpoints)},
{ { C_STRING_WITH_LEN("OCT") }, BUILDER(Create_func_oct)}, { { STRING_WITH_LEN("OCT") }, BUILDER(Create_func_oct)},
{ { C_STRING_WITH_LEN("OCTET_LENGTH") }, BUILDER(Create_func_octet_length)}, { { STRING_WITH_LEN("OCTET_LENGTH") }, BUILDER(Create_func_octet_length)},
{ { C_STRING_WITH_LEN("ORD") }, BUILDER(Create_func_ord)}, { { STRING_WITH_LEN("ORD") }, BUILDER(Create_func_ord)},
{ { C_STRING_WITH_LEN("OVERLAPS") }, GEOM_BUILDER(Create_func_mbr_overlaps)}, { { STRING_WITH_LEN("OVERLAPS") }, GEOM_BUILDER(Create_func_mbr_overlaps)},
{ { C_STRING_WITH_LEN("PERIOD_ADD") }, BUILDER(Create_func_period_add)}, { { STRING_WITH_LEN("PERIOD_ADD") }, BUILDER(Create_func_period_add)},
{ { C_STRING_WITH_LEN("PERIOD_DIFF") }, BUILDER(Create_func_period_diff)}, { { STRING_WITH_LEN("PERIOD_DIFF") }, BUILDER(Create_func_period_diff)},
{ { C_STRING_WITH_LEN("PI") }, BUILDER(Create_func_pi)}, { { STRING_WITH_LEN("PI") }, BUILDER(Create_func_pi)},
{ { C_STRING_WITH_LEN("POINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("POINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("POINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("POINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("POINTN") }, GEOM_BUILDER(Create_func_pointn)}, { { STRING_WITH_LEN("POINTN") }, GEOM_BUILDER(Create_func_pointn)},
{ { C_STRING_WITH_LEN("POINTONSURFACE") }, GEOM_BUILDER(Create_func_pointonsurface)}, { { STRING_WITH_LEN("POINTONSURFACE") }, GEOM_BUILDER(Create_func_pointonsurface)},
{ { C_STRING_WITH_LEN("POLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("POLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("POLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("POLYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("POLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { STRING_WITH_LEN("POLYGONFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)},
{ { C_STRING_WITH_LEN("POLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)}, { { STRING_WITH_LEN("POLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("POW") }, BUILDER(Create_func_pow)}, { { STRING_WITH_LEN("POW") }, BUILDER(Create_func_pow)},
{ { C_STRING_WITH_LEN("POWER") }, BUILDER(Create_func_pow)}, { { STRING_WITH_LEN("POWER") }, BUILDER(Create_func_pow)},
{ { C_STRING_WITH_LEN("QUOTE") }, BUILDER(Create_func_quote)}, { { STRING_WITH_LEN("QUOTE") }, BUILDER(Create_func_quote)},
{ { C_STRING_WITH_LEN("REGEXP_INSTR") }, BUILDER(Create_func_regexp_instr)}, { { STRING_WITH_LEN("REGEXP_INSTR") }, BUILDER(Create_func_regexp_instr)},
{ { C_STRING_WITH_LEN("REGEXP_REPLACE") }, BUILDER(Create_func_regexp_replace)}, { { STRING_WITH_LEN("REGEXP_REPLACE") }, BUILDER(Create_func_regexp_replace)},
{ { C_STRING_WITH_LEN("REGEXP_SUBSTR") }, BUILDER(Create_func_regexp_substr)}, { { STRING_WITH_LEN("REGEXP_SUBSTR") }, BUILDER(Create_func_regexp_substr)},
{ { C_STRING_WITH_LEN("RADIANS") }, BUILDER(Create_func_radians)}, { { STRING_WITH_LEN("RADIANS") }, BUILDER(Create_func_radians)},
{ { C_STRING_WITH_LEN("RAND") }, BUILDER(Create_func_rand)}, { { STRING_WITH_LEN("RAND") }, BUILDER(Create_func_rand)},
{ { C_STRING_WITH_LEN("RELEASE_LOCK") }, BUILDER(Create_func_release_lock)}, { { STRING_WITH_LEN("RELEASE_LOCK") }, BUILDER(Create_func_release_lock)},
{ { C_STRING_WITH_LEN("REPLACE_ORACLE") }, { { STRING_WITH_LEN("REPLACE_ORACLE") },
BUILDER(Create_func_replace_oracle)}, BUILDER(Create_func_replace_oracle)},
{ { C_STRING_WITH_LEN("REVERSE") }, BUILDER(Create_func_reverse)}, { { STRING_WITH_LEN("REVERSE") }, BUILDER(Create_func_reverse)},
{ { C_STRING_WITH_LEN("ROUND") }, BUILDER(Create_func_round)}, { { STRING_WITH_LEN("ROUND") }, BUILDER(Create_func_round)},
{ { C_STRING_WITH_LEN("RPAD") }, BUILDER(Create_func_rpad)}, { { STRING_WITH_LEN("RPAD") }, BUILDER(Create_func_rpad)},
{ { C_STRING_WITH_LEN("RTRIM") }, BUILDER(Create_func_rtrim)}, { { STRING_WITH_LEN("RTRIM") }, BUILDER(Create_func_rtrim)},
{ { C_STRING_WITH_LEN("SEC_TO_TIME") }, BUILDER(Create_func_sec_to_time)}, { { STRING_WITH_LEN("SEC_TO_TIME") }, BUILDER(Create_func_sec_to_time)},
{ { C_STRING_WITH_LEN("SHA") }, BUILDER(Create_func_sha)}, { { STRING_WITH_LEN("SHA") }, BUILDER(Create_func_sha)},
{ { C_STRING_WITH_LEN("SHA1") }, BUILDER(Create_func_sha)}, { { STRING_WITH_LEN("SHA1") }, BUILDER(Create_func_sha)},
{ { C_STRING_WITH_LEN("SHA2") }, BUILDER(Create_func_sha2)}, { { STRING_WITH_LEN("SHA2") }, BUILDER(Create_func_sha2)},
{ { C_STRING_WITH_LEN("SIGN") }, BUILDER(Create_func_sign)}, { { STRING_WITH_LEN("SIGN") }, BUILDER(Create_func_sign)},
{ { C_STRING_WITH_LEN("SIN") }, BUILDER(Create_func_sin)}, { { STRING_WITH_LEN("SIN") }, BUILDER(Create_func_sin)},
{ { C_STRING_WITH_LEN("SLEEP") }, BUILDER(Create_func_sleep)}, { { STRING_WITH_LEN("SLEEP") }, BUILDER(Create_func_sleep)},
{ { C_STRING_WITH_LEN("SOUNDEX") }, BUILDER(Create_func_soundex)}, { { STRING_WITH_LEN("SOUNDEX") }, BUILDER(Create_func_soundex)},
{ { C_STRING_WITH_LEN("SPACE") }, BUILDER(Create_func_space)}, { { STRING_WITH_LEN("SPACE") }, BUILDER(Create_func_space)},
{ { C_STRING_WITH_LEN("SQRT") }, BUILDER(Create_func_sqrt)}, { { STRING_WITH_LEN("SQRT") }, BUILDER(Create_func_sqrt)},
{ { C_STRING_WITH_LEN("SRID") }, GEOM_BUILDER(Create_func_srid)}, { { STRING_WITH_LEN("SRID") }, GEOM_BUILDER(Create_func_srid)},
{ { C_STRING_WITH_LEN("STARTPOINT") }, GEOM_BUILDER(Create_func_startpoint)}, { { STRING_WITH_LEN("STARTPOINT") }, GEOM_BUILDER(Create_func_startpoint)},
{ { C_STRING_WITH_LEN("STRCMP") }, BUILDER(Create_func_strcmp)}, { { STRING_WITH_LEN("STRCMP") }, BUILDER(Create_func_strcmp)},
{ { C_STRING_WITH_LEN("STR_TO_DATE") }, BUILDER(Create_func_str_to_date)}, { { STRING_WITH_LEN("STR_TO_DATE") }, BUILDER(Create_func_str_to_date)},
{ { C_STRING_WITH_LEN("ST_AREA") }, GEOM_BUILDER(Create_func_area)}, { { STRING_WITH_LEN("ST_AREA") }, GEOM_BUILDER(Create_func_area)},
{ { C_STRING_WITH_LEN("ST_ASBINARY") }, GEOM_BUILDER(Create_func_as_wkb)}, { { STRING_WITH_LEN("ST_ASBINARY") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { C_STRING_WITH_LEN("ST_ASGEOJSON") }, GEOM_BUILDER(Create_func_as_geojson)}, { { STRING_WITH_LEN("ST_ASGEOJSON") }, GEOM_BUILDER(Create_func_as_geojson)},
{ { C_STRING_WITH_LEN("ST_ASTEXT") }, GEOM_BUILDER(Create_func_as_wkt)}, { { STRING_WITH_LEN("ST_ASTEXT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { C_STRING_WITH_LEN("ST_ASWKB") }, GEOM_BUILDER(Create_func_as_wkb)}, { { STRING_WITH_LEN("ST_ASWKB") }, GEOM_BUILDER(Create_func_as_wkb)},
{ { C_STRING_WITH_LEN("ST_ASWKT") }, GEOM_BUILDER(Create_func_as_wkt)}, { { STRING_WITH_LEN("ST_ASWKT") }, GEOM_BUILDER(Create_func_as_wkt)},
{ { C_STRING_WITH_LEN("ST_BOUNDARY") }, GEOM_BUILDER(Create_func_boundary)}, { { STRING_WITH_LEN("ST_BOUNDARY") }, GEOM_BUILDER(Create_func_boundary)},
{ { C_STRING_WITH_LEN("ST_BUFFER") }, GEOM_BUILDER(Create_func_buffer)}, { { STRING_WITH_LEN("ST_BUFFER") }, GEOM_BUILDER(Create_func_buffer)},
{ { C_STRING_WITH_LEN("ST_CENTROID") }, GEOM_BUILDER(Create_func_centroid)}, { { STRING_WITH_LEN("ST_CENTROID") }, GEOM_BUILDER(Create_func_centroid)},
{ { C_STRING_WITH_LEN("ST_CONTAINS") }, GEOM_BUILDER(Create_func_contains)}, { { STRING_WITH_LEN("ST_CONTAINS") }, GEOM_BUILDER(Create_func_contains)},
{ { C_STRING_WITH_LEN("ST_CONVEXHULL") }, GEOM_BUILDER(Create_func_convexhull)}, { { STRING_WITH_LEN("ST_CONVEXHULL") }, GEOM_BUILDER(Create_func_convexhull)},
{ { C_STRING_WITH_LEN("ST_CROSSES") }, GEOM_BUILDER(Create_func_crosses)}, { { STRING_WITH_LEN("ST_CROSSES") }, GEOM_BUILDER(Create_func_crosses)},
{ { C_STRING_WITH_LEN("ST_DIFFERENCE") }, GEOM_BUILDER(Create_func_difference)}, { { STRING_WITH_LEN("ST_DIFFERENCE") }, GEOM_BUILDER(Create_func_difference)},
{ { C_STRING_WITH_LEN("ST_DIMENSION") }, GEOM_BUILDER(Create_func_dimension)}, { { STRING_WITH_LEN("ST_DIMENSION") }, GEOM_BUILDER(Create_func_dimension)},
{ { C_STRING_WITH_LEN("ST_DISJOINT") }, GEOM_BUILDER(Create_func_disjoint)}, { { STRING_WITH_LEN("ST_DISJOINT") }, GEOM_BUILDER(Create_func_disjoint)},
{ { C_STRING_WITH_LEN("ST_DISTANCE") }, GEOM_BUILDER(Create_func_distance)}, { { STRING_WITH_LEN("ST_DISTANCE") }, GEOM_BUILDER(Create_func_distance)},
{ { C_STRING_WITH_LEN("ST_ENDPOINT") }, GEOM_BUILDER(Create_func_endpoint)}, { { STRING_WITH_LEN("ST_ENDPOINT") }, GEOM_BUILDER(Create_func_endpoint)},
{ { C_STRING_WITH_LEN("ST_ENVELOPE") }, GEOM_BUILDER(Create_func_envelope)}, { { STRING_WITH_LEN("ST_ENVELOPE") }, GEOM_BUILDER(Create_func_envelope)},
{ { C_STRING_WITH_LEN("ST_EQUALS") }, GEOM_BUILDER(Create_func_equals)}, { { STRING_WITH_LEN("ST_EQUALS") }, GEOM_BUILDER(Create_func_equals)},
{ { C_STRING_WITH_LEN("ST_EXTERIORRING") }, GEOM_BUILDER(Create_func_exteriorring)}, { { STRING_WITH_LEN("ST_EXTERIORRING") }, GEOM_BUILDER(Create_func_exteriorring)},
{ { C_STRING_WITH_LEN("ST_GEOMCOLLFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { STRING_WITH_LEN("ST_GEOMETRYFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_GEOMETRYN") }, GEOM_BUILDER(Create_func_geometryn)}, { { STRING_WITH_LEN("ST_GEOMETRYN") }, GEOM_BUILDER(Create_func_geometryn)},
{ { C_STRING_WITH_LEN("ST_GEOMETRYTYPE") }, GEOM_BUILDER(Create_func_geometry_type)}, { { STRING_WITH_LEN("ST_GEOMETRYTYPE") }, GEOM_BUILDER(Create_func_geometry_type)},
{ { C_STRING_WITH_LEN("ST_GEOMFROMGEOJSON") }, GEOM_BUILDER(Create_func_geometry_from_json)}, { { 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)}, { { 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("ST_GEOMFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
#ifndef DBUG_OFF #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 #endif
{ { C_STRING_WITH_LEN("ST_EQUALS") }, GEOM_BUILDER(Create_func_equals)}, { { STRING_WITH_LEN("ST_EQUALS") }, GEOM_BUILDER(Create_func_equals)},
{ { C_STRING_WITH_LEN("ST_INTERIORRINGN") }, GEOM_BUILDER(Create_func_interiorringn)}, { { STRING_WITH_LEN("ST_INTERIORRINGN") }, GEOM_BUILDER(Create_func_interiorringn)},
{ { C_STRING_WITH_LEN("ST_INTERSECTS") }, GEOM_BUILDER(Create_func_intersects)}, { { STRING_WITH_LEN("ST_INTERSECTS") }, GEOM_BUILDER(Create_func_intersects)},
{ { C_STRING_WITH_LEN("ST_INTERSECTION") }, GEOM_BUILDER(Create_func_intersection)}, { { STRING_WITH_LEN("ST_INTERSECTION") }, GEOM_BUILDER(Create_func_intersection)},
{ { C_STRING_WITH_LEN("ST_ISCLOSED") }, GEOM_BUILDER(Create_func_isclosed)}, { { STRING_WITH_LEN("ST_ISCLOSED") }, GEOM_BUILDER(Create_func_isclosed)},
{ { C_STRING_WITH_LEN("ST_ISEMPTY") }, GEOM_BUILDER(Create_func_isempty)}, { { STRING_WITH_LEN("ST_ISEMPTY") }, GEOM_BUILDER(Create_func_isempty)},
{ { C_STRING_WITH_LEN("ST_ISRING") }, GEOM_BUILDER(Create_func_isring)}, { { STRING_WITH_LEN("ST_ISRING") }, GEOM_BUILDER(Create_func_isring)},
{ { C_STRING_WITH_LEN("ST_ISSIMPLE") }, GEOM_BUILDER(Create_func_issimple)}, { { STRING_WITH_LEN("ST_ISSIMPLE") }, GEOM_BUILDER(Create_func_issimple)},
{ { C_STRING_WITH_LEN("ST_LENGTH") }, GEOM_BUILDER(Create_func_glength)}, { { STRING_WITH_LEN("ST_LENGTH") }, GEOM_BUILDER(Create_func_glength)},
{ { C_STRING_WITH_LEN("ST_LINEFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { 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)}, { { STRING_WITH_LEN("ST_MULTIPOLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_NUMGEOMETRIES") }, GEOM_BUILDER(Create_func_numgeometries)}, { { STRING_WITH_LEN("ST_NUMGEOMETRIES") }, GEOM_BUILDER(Create_func_numgeometries)},
{ { C_STRING_WITH_LEN("ST_NUMINTERIORRINGS") }, GEOM_BUILDER(Create_func_numinteriorring)}, { { STRING_WITH_LEN("ST_NUMINTERIORRINGS") }, GEOM_BUILDER(Create_func_numinteriorring)},
{ { C_STRING_WITH_LEN("ST_NUMPOINTS") }, GEOM_BUILDER(Create_func_numpoints)}, { { STRING_WITH_LEN("ST_NUMPOINTS") }, GEOM_BUILDER(Create_func_numpoints)},
{ { C_STRING_WITH_LEN("ST_OVERLAPS") }, GEOM_BUILDER(Create_func_overlaps)}, { { STRING_WITH_LEN("ST_OVERLAPS") }, GEOM_BUILDER(Create_func_overlaps)},
{ { C_STRING_WITH_LEN("ST_POINTFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { 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)}, { { STRING_WITH_LEN("ST_POINTFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_POINTN") }, GEOM_BUILDER(Create_func_pointn)}, { { STRING_WITH_LEN("ST_POINTN") }, GEOM_BUILDER(Create_func_pointn)},
{ { C_STRING_WITH_LEN("ST_POINTONSURFACE") }, GEOM_BUILDER(Create_func_pointonsurface)}, { { STRING_WITH_LEN("ST_POINTONSURFACE") }, GEOM_BUILDER(Create_func_pointonsurface)},
{ { C_STRING_WITH_LEN("ST_POLYFROMTEXT") }, GEOM_BUILDER(Create_func_geometry_from_text)}, { { 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)}, { { 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)}, { { 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)}, { { STRING_WITH_LEN("ST_POLYGONFROMWKB") }, GEOM_BUILDER(Create_func_geometry_from_wkb)},
{ { C_STRING_WITH_LEN("ST_RELATE") }, GEOM_BUILDER(Create_func_relate)}, { { STRING_WITH_LEN("ST_RELATE") }, GEOM_BUILDER(Create_func_relate)},
{ { C_STRING_WITH_LEN("ST_SRID") }, GEOM_BUILDER(Create_func_srid)}, { { STRING_WITH_LEN("ST_SRID") }, GEOM_BUILDER(Create_func_srid)},
{ { C_STRING_WITH_LEN("ST_STARTPOINT") }, GEOM_BUILDER(Create_func_startpoint)}, { { STRING_WITH_LEN("ST_STARTPOINT") }, GEOM_BUILDER(Create_func_startpoint)},
{ { C_STRING_WITH_LEN("ST_SYMDIFFERENCE") }, GEOM_BUILDER(Create_func_symdifference)}, { { STRING_WITH_LEN("ST_SYMDIFFERENCE") }, GEOM_BUILDER(Create_func_symdifference)},
{ { C_STRING_WITH_LEN("ST_TOUCHES") }, GEOM_BUILDER(Create_func_touches)}, { { STRING_WITH_LEN("ST_TOUCHES") }, GEOM_BUILDER(Create_func_touches)},
{ { C_STRING_WITH_LEN("ST_UNION") }, GEOM_BUILDER(Create_func_union)}, { { STRING_WITH_LEN("ST_UNION") }, GEOM_BUILDER(Create_func_union)},
{ { C_STRING_WITH_LEN("ST_WITHIN") }, GEOM_BUILDER(Create_func_within)}, { { STRING_WITH_LEN("ST_WITHIN") }, GEOM_BUILDER(Create_func_within)},
{ { C_STRING_WITH_LEN("ST_X") }, GEOM_BUILDER(Create_func_x)}, { { STRING_WITH_LEN("ST_X") }, GEOM_BUILDER(Create_func_x)},
{ { C_STRING_WITH_LEN("ST_Y") }, GEOM_BUILDER(Create_func_y)}, { { STRING_WITH_LEN("ST_Y") }, GEOM_BUILDER(Create_func_y)},
{ { C_STRING_WITH_LEN("SUBSTR_ORACLE") }, { { STRING_WITH_LEN("SUBSTR_ORACLE") },
BUILDER(Create_func_substr_oracle)}, BUILDER(Create_func_substr_oracle)},
{ { C_STRING_WITH_LEN("SUBSTRING_INDEX") }, BUILDER(Create_func_substr_index)}, { { STRING_WITH_LEN("SUBSTRING_INDEX") }, BUILDER(Create_func_substr_index)},
{ { C_STRING_WITH_LEN("SUBTIME") }, BUILDER(Create_func_subtime)}, { { STRING_WITH_LEN("SUBTIME") }, BUILDER(Create_func_subtime)},
{ { C_STRING_WITH_LEN("TAN") }, BUILDER(Create_func_tan)}, { { STRING_WITH_LEN("TAN") }, BUILDER(Create_func_tan)},
{ { C_STRING_WITH_LEN("TIMEDIFF") }, BUILDER(Create_func_timediff)}, { { STRING_WITH_LEN("TIMEDIFF") }, BUILDER(Create_func_timediff)},
{ { C_STRING_WITH_LEN("TIME_FORMAT") }, BUILDER(Create_func_time_format)}, { { STRING_WITH_LEN("TIME_FORMAT") }, BUILDER(Create_func_time_format)},
{ { C_STRING_WITH_LEN("TIME_TO_SEC") }, BUILDER(Create_func_time_to_sec)}, { { STRING_WITH_LEN("TIME_TO_SEC") }, BUILDER(Create_func_time_to_sec)},
{ { C_STRING_WITH_LEN("TOUCHES") }, GEOM_BUILDER(Create_func_touches)}, { { STRING_WITH_LEN("TOUCHES") }, GEOM_BUILDER(Create_func_touches)},
{ { C_STRING_WITH_LEN("TO_BASE64") }, BUILDER(Create_func_to_base64)}, { { STRING_WITH_LEN("TO_BASE64") }, BUILDER(Create_func_to_base64)},
{ { C_STRING_WITH_LEN("TO_DAYS") }, BUILDER(Create_func_to_days)}, { { STRING_WITH_LEN("TO_DAYS") }, BUILDER(Create_func_to_days)},
{ { C_STRING_WITH_LEN("TO_SECONDS") }, BUILDER(Create_func_to_seconds)}, { { STRING_WITH_LEN("TO_SECONDS") }, BUILDER(Create_func_to_seconds)},
{ { C_STRING_WITH_LEN("UCASE") }, BUILDER(Create_func_ucase)}, { { STRING_WITH_LEN("UCASE") }, BUILDER(Create_func_ucase)},
{ { C_STRING_WITH_LEN("UNCOMPRESS") }, BUILDER(Create_func_uncompress)}, { { STRING_WITH_LEN("UNCOMPRESS") }, BUILDER(Create_func_uncompress)},
{ { C_STRING_WITH_LEN("UNCOMPRESSED_LENGTH") }, BUILDER(Create_func_uncompressed_length)}, { { STRING_WITH_LEN("UNCOMPRESSED_LENGTH") }, BUILDER(Create_func_uncompressed_length)},
{ { C_STRING_WITH_LEN("UNHEX") }, BUILDER(Create_func_unhex)}, { { STRING_WITH_LEN("UNHEX") }, BUILDER(Create_func_unhex)},
{ { C_STRING_WITH_LEN("UNIX_TIMESTAMP") }, BUILDER(Create_func_unix_timestamp)}, { { STRING_WITH_LEN("UNIX_TIMESTAMP") }, BUILDER(Create_func_unix_timestamp)},
{ { C_STRING_WITH_LEN("UPDATEXML") }, BUILDER(Create_func_xml_update)}, { { STRING_WITH_LEN("UPDATEXML") }, BUILDER(Create_func_xml_update)},
{ { C_STRING_WITH_LEN("UPPER") }, BUILDER(Create_func_ucase)}, { { STRING_WITH_LEN("UPPER") }, BUILDER(Create_func_ucase)},
{ { C_STRING_WITH_LEN("UUID") }, BUILDER(Create_func_uuid)}, { { STRING_WITH_LEN("UUID") }, BUILDER(Create_func_uuid)},
{ { C_STRING_WITH_LEN("UUID_SHORT") }, BUILDER(Create_func_uuid_short)}, { { STRING_WITH_LEN("UUID_SHORT") }, BUILDER(Create_func_uuid_short)},
{ { C_STRING_WITH_LEN("VERSION") }, BUILDER(Create_func_version)}, { { STRING_WITH_LEN("VERSION") }, BUILDER(Create_func_version)},
{ { C_STRING_WITH_LEN("WEEKDAY") }, BUILDER(Create_func_weekday)}, { { STRING_WITH_LEN("WEEKDAY") }, BUILDER(Create_func_weekday)},
{ { C_STRING_WITH_LEN("WEEKOFYEAR") }, BUILDER(Create_func_weekofyear)}, { { STRING_WITH_LEN("WEEKOFYEAR") }, BUILDER(Create_func_weekofyear)},
{ { C_STRING_WITH_LEN("WITHIN") }, GEOM_BUILDER(Create_func_within)}, { { STRING_WITH_LEN("WITHIN") }, GEOM_BUILDER(Create_func_within)},
{ { C_STRING_WITH_LEN("X") }, GEOM_BUILDER(Create_func_x)}, { { STRING_WITH_LEN("X") }, GEOM_BUILDER(Create_func_x)},
{ { C_STRING_WITH_LEN("Y") }, GEOM_BUILDER(Create_func_y)}, { { STRING_WITH_LEN("Y") }, GEOM_BUILDER(Create_func_y)},
{ { C_STRING_WITH_LEN("YEARWEEK") }, BUILDER(Create_func_year_week)}, { { STRING_WITH_LEN("YEARWEEK") }, BUILDER(Create_func_year_week)},
{ {0, 0}, NULL} { {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 struct Native_func_registry
{ {
LEX_STRING name; LEX_CSTRING name;
Create_func *builder; 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); system_charset_info);
return str; return str;
} }
str->copy(C_STRING_WITH_LEN("normal, successful completition"), str->copy(STRING_WITH_LEN("normal, successful completition"),
system_charset_info); system_charset_info);
return str; return str;
} }
@ -2925,7 +2925,7 @@ void Item_func_char::print(String *str, enum_query_type query_type)
print_args(str, 0, query_type); print_args(str, 0, query_type);
if (collation.collation != &my_charset_bin) 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(collation.collation->csname);
} }
str->append(')'); 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 */ /* 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 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 */ /* 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) if (!filter_name->length)
filter_name= &default_rpl_filter_base; 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) 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 *filter;
rpl_filter_name.str= (char *) name; 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); bool process_key_caches(process_key_cache_t func, void *param);
/* For Rpl_filter */ /* For Rpl_filter */
extern LEX_STRING default_rpl_filter_base; extern LEX_CSTRING default_rpl_filter_base;
extern NAMED_ILIST rpl_filters; extern NAMED_ILIST rpl_filters;
Rpl_filter *create_rpl_filter(const char *name, uint length); 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); Rpl_filter *get_or_create_rpl_filter(const char *name, uint length);
void free_rpl_filter(const char *name, Rpl_filter *filter); void free_rpl_filter(const char *name, Rpl_filter *filter);
void free_all_rpl_filters(void); 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_prepare(handlerton *hton, THD *thd, bool all);
static int binlog_start_consistent_snapshot(handlerton *hton, THD *thd); static int binlog_start_consistent_snapshot(handlerton *hton, THD *thd);
static LEX_STRING const write_error_msg= static const LEX_CSTRING write_error_msg=
{ C_STRING_WITH_LEN("error writing to the binary log") }; { STRING_WITH_LEN("error writing to the binary log") };
static my_bool opt_optimize_thread_scheduling= TRUE; static my_bool opt_optimize_thread_scheduling= TRUE;
ulong binlog_checksum_options; 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; prev_binlog_id= current_binlog_id;
DBUG_EXECUTE_IF("binlog_force_commit_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; bool null_value;
user_var_entry *entry= user_var_entry *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (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; uint error= 0;
DBUG_ENTER("MYSQL_BIN_LOG::write_incident_already_locked"); DBUG_ENTER("MYSQL_BIN_LOG::write_incident_already_locked");
Incident incident= INCIDENT_LOST_EVENTS; 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())) if (likely(is_open()))
{ {
@ -7332,7 +7332,7 @@ MYSQL_BIN_LOG::write_transaction_to_binlog(THD *thd,
if (cache_mngr->stmt_cache.has_incident() || if (cache_mngr->stmt_cache.has_incident() ||
cache_mngr->trx_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; entry.incident_event= &inc_ev;
DBUG_RETURN(write_transaction_to_binlog_events(&entry)); 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); commit_id= (last_in_queue == leader ? 0 : (uint64)leader->thd->query_id);
DBUG_EXECUTE_IF("binlog_force_commit_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; bool null_value;
user_var_entry *entry= user_var_entry *entry=
(user_var_entry*) my_hash_search(&leader->thd->user_vars, (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; 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) : Log_event(thd_arg, 0, FALSE), m_incident(incident)
{ {
DBUG_ENTER("Incident_log_event::Incident_log_event"); DBUG_ENTER("Incident_log_event::Incident_log_event");
DBUG_PRINT("enter", ("m_incident: %d", m_incident)); DBUG_PRINT("enter", ("m_incident: %d", m_incident));
m_message.str= NULL;
m_message.length= 0; 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 */ /* Mark this event invalid */
m_incident= INCIDENT_NONE; m_incident= INCIDENT_NONE;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
strmake(m_message.str, msg.str, msg.length); strmake(m_message.str, msg->str, msg->length);
m_message.length= msg.length; m_message.length= msg->length;
set_direct_logging(); set_direct_logging();
/* Replicate the incident irregardless of @@skip_replication. */ /* Replicate the incident irregardless of @@skip_replication. */
flags&= ~LOG_EVENT_SKIP_REPLICATION_F; 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]= { static const TABLE_FIELD_TYPE mysql_rpl_slave_state_coltypes[4]= {
{ { C_STRING_WITH_LEN("domain_id") }, { { STRING_WITH_LEN("domain_id") },
{ C_STRING_WITH_LEN("int(10) unsigned") }, { STRING_WITH_LEN("int(10) unsigned") },
{NULL, 0} }, {NULL, 0} },
{ { C_STRING_WITH_LEN("sub_id") }, { { STRING_WITH_LEN("sub_id") },
{ C_STRING_WITH_LEN("bigint(20) unsigned") }, { STRING_WITH_LEN("bigint(20) unsigned") },
{NULL, 0} }, {NULL, 0} },
{ { C_STRING_WITH_LEN("server_id") }, { { STRING_WITH_LEN("server_id") },
{ C_STRING_WITH_LEN("int(10) unsigned") }, { STRING_WITH_LEN("int(10) unsigned") },
{NULL, 0} }, {NULL, 0} },
{ { C_STRING_WITH_LEN("seq_no") }, { { STRING_WITH_LEN("seq_no") },
{ C_STRING_WITH_LEN("bigint(20) unsigned") }, { STRING_WITH_LEN("bigint(20) unsigned") },
{NULL, 0} }, {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); 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); Incident_log_event ev(thd, incident, message);
if (int error= mysql_bin_log.write(&ev)) 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 *); void new_trans(THD *, transaction *);
int record_incident(THD*, Incident incident); 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: private:
explicit injector(); explicit injector();

14
sql/set_var.cc
View File

@ -324,14 +324,14 @@ do { \
sval.length= sval.str ? strlen(sval.str) : 0; \ sval.length= sval.str ? strlen(sval.str) : 0; \
break; \ break; \
case SHOW_LEX_STRING: \ case SHOW_LEX_STRING: \
sval= *(LEX_STRING *) value; \ sval= *(LEX_CSTRING *) value; \
break break
longlong sys_var::val_int(bool *is_null, longlong sys_var::val_int(bool *is_null,
THD *thd, enum_var_type type, THD *thd, enum_var_type type,
const LEX_CSTRING *base) const LEX_CSTRING *base)
{ {
LEX_STRING sval; LEX_CSTRING sval;
AutoWLock lock(&PLock_global_system_variables); AutoWLock lock(&PLock_global_system_variables);
const uchar *value= value_ptr(thd, type, base); const uchar *value= value_ptr(thd, type, base);
*is_null= false; *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) 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") }, { STRING_WITH_LEN("OFF") },
{ C_STRING_WITH_LEN("ON") } { STRING_WITH_LEN("ON") }
}; };
LEX_STRING sval; LEX_CSTRING sval;
switch (show_type()) switch (show_type())
{ {
case_get_string_as_lex_string; 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, double sys_var::val_real(bool *is_null,
THD *thd, enum_var_type type, const LEX_CSTRING *base) THD *thd, enum_var_type type, const LEX_CSTRING *base)
{ {
LEX_STRING sval; LEX_CSTRING sval;
AutoWLock lock(&PLock_global_system_variables); AutoWLock lock(&PLock_global_system_variables);
const uchar *value= value_ptr(thd, type, base); const uchar *value= value_ptr(thd, type, base);
*is_null= false; *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] = TABLE_FIELD_TYPE proc_table_fields[MYSQL_PROC_FIELD_COUNT] =
{ {
{ {
{ C_STRING_WITH_LEN("db") }, { STRING_WITH_LEN("db") },
{ C_STRING_WITH_LEN("char(64)") }, { STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("name") }, { STRING_WITH_LEN("name") },
{ C_STRING_WITH_LEN("char(64)") }, { STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("type") }, { STRING_WITH_LEN("type") },
{ C_STRING_WITH_LEN("enum('FUNCTION','PROCEDURE')") }, { STRING_WITH_LEN("enum('FUNCTION','PROCEDURE')") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("specific_name") }, { STRING_WITH_LEN("specific_name") },
{ C_STRING_WITH_LEN("char(64)") }, { STRING_WITH_LEN("char(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("language") }, { STRING_WITH_LEN("language") },
{ C_STRING_WITH_LEN("enum('SQL')") }, { STRING_WITH_LEN("enum('SQL')") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("sql_data_access") }, { STRING_WITH_LEN("sql_data_access") },
{ C_STRING_WITH_LEN("enum('CONTAINS_SQL','NO_SQL','READS_SQL_DATA','MODIFIES_SQL_DATA')") }, { STRING_WITH_LEN("enum('CONTAINS_SQL','NO_SQL','READS_SQL_DATA','MODIFIES_SQL_DATA')") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("is_deterministic") }, { STRING_WITH_LEN("is_deterministic") },
{ C_STRING_WITH_LEN("enum('YES','NO')") }, { STRING_WITH_LEN("enum('YES','NO')") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("security_type") }, { STRING_WITH_LEN("security_type") },
{ C_STRING_WITH_LEN("enum('INVOKER','DEFINER')") }, { STRING_WITH_LEN("enum('INVOKER','DEFINER')") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("param_list") }, { STRING_WITH_LEN("param_list") },
{ C_STRING_WITH_LEN("blob") }, { STRING_WITH_LEN("blob") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("returns") }, { STRING_WITH_LEN("returns") },
{ C_STRING_WITH_LEN("longblob") }, { STRING_WITH_LEN("longblob") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("body") }, { STRING_WITH_LEN("body") },
{ C_STRING_WITH_LEN("longblob") }, { STRING_WITH_LEN("longblob") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("definer") }, { STRING_WITH_LEN("definer") },
{ C_STRING_WITH_LEN("char(") }, { STRING_WITH_LEN("char(") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("created") }, { STRING_WITH_LEN("created") },
{ C_STRING_WITH_LEN("timestamp") }, { STRING_WITH_LEN("timestamp") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("modified") }, { STRING_WITH_LEN("modified") },
{ C_STRING_WITH_LEN("timestamp") }, { STRING_WITH_LEN("timestamp") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("sql_mode") }, { STRING_WITH_LEN("sql_mode") },
{ C_STRING_WITH_LEN("set('REAL_AS_FLOAT','PIPES_AS_CONCAT','ANSI_QUOTES'," { STRING_WITH_LEN("set('REAL_AS_FLOAT','PIPES_AS_CONCAT','ANSI_QUOTES',"
"'IGNORE_SPACE','IGNORE_BAD_TABLE_OPTIONS','ONLY_FULL_GROUP_BY'," "'IGNORE_SPACE','IGNORE_BAD_TABLE_OPTIONS','ONLY_FULL_GROUP_BY',"
"'NO_UNSIGNED_SUBTRACTION'," "'NO_UNSIGNED_SUBTRACTION',"
"'NO_DIR_IN_CREATE','POSTGRESQL','ORACLE','MSSQL','DB2','MAXDB'," "'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 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("comment") }, { STRING_WITH_LEN("comment") },
{ C_STRING_WITH_LEN("text") }, { STRING_WITH_LEN("text") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("character_set_client") }, { STRING_WITH_LEN("character_set_client") },
{ C_STRING_WITH_LEN("char(32)") }, { STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("collation_connection") }, { STRING_WITH_LEN("collation_connection") },
{ C_STRING_WITH_LEN("char(32)") }, { STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("db_collation") }, { STRING_WITH_LEN("db_collation") },
{ C_STRING_WITH_LEN("char(32)") }, { STRING_WITH_LEN("char(32)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("body_utf8") }, { STRING_WITH_LEN("body_utf8") },
{ C_STRING_WITH_LEN("longblob") }, { STRING_WITH_LEN("longblob") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("aggregate") }, { STRING_WITH_LEN("aggregate") },
{ C_STRING_WITH_LEN("enum('NONE','GROUP')") }, { STRING_WITH_LEN("enum('NONE','GROUP')") },
{ NULL, 0 } { NULL, 0 }
} }
}; };

12
sql/sp.h
View File

@ -100,7 +100,7 @@ public:
virtual LEX_CSTRING type_lex_cstring() const= 0; virtual LEX_CSTRING type_lex_cstring() const= 0;
virtual LEX_CSTRING empty_body_lex_cstring() const 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); DBUG_ASSERT(0);
return m_empty_body; return m_empty_body;
} }
@ -182,12 +182,12 @@ public:
stored_procedure_type type() const { return TYPE_ENUM_PROCEDURE; } stored_procedure_type type() const { return TYPE_ENUM_PROCEDURE; }
LEX_CSTRING type_lex_cstring() const 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; return m_type_str;
} }
LEX_CSTRING empty_body_lex_cstring() const 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; return m_empty_body;
} }
const char *show_create_routine_col1_caption() const const char *show_create_routine_col1_caption() const
@ -218,12 +218,12 @@ public:
stored_procedure_type type() const { return TYPE_ENUM_FUNCTION; } stored_procedure_type type() const { return TYPE_ENUM_FUNCTION; }
LEX_CSTRING type_lex_cstring() const 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; return m_type_str;
} }
LEX_CSTRING empty_body_lex_cstring() const 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; return m_empty_body;
} }
const char *show_create_routine_col1_caption() const const char *show_create_routine_col1_caption() const
@ -253,7 +253,7 @@ public:
stored_procedure_type type() const { return TYPE_ENUM_TRIGGER; } stored_procedure_type type() const { return TYPE_ENUM_TRIGGER; }
LEX_CSTRING type_lex_cstring() const 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; return m_type_str;
} }
MDL_key::enum_mdl_namespace get_mdl_type() const 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[]= static sp_condition sp_predefined_conditions[]=
{ {
// Warnings // 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 // Errors
sp_condition(C_STRING_WITH_LEN("INVALID_CURSOR"), &cond_invalid_cursor), sp_condition(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(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(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("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 static const
TABLE_FIELD_TYPE mysql_db_table_fields[MYSQL_DB_FIELD_COUNT] = { TABLE_FIELD_TYPE mysql_db_table_fields[MYSQL_DB_FIELD_COUNT] = {
{ {
{ C_STRING_WITH_LEN("Host") }, { STRING_WITH_LEN("Host") },
{ C_STRING_WITH_LEN("char(60)") }, { STRING_WITH_LEN("char(60)") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("Db") }, { STRING_WITH_LEN("Db") },
{ C_STRING_WITH_LEN("char(64)") }, { STRING_WITH_LEN("char(64)") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("User") }, { STRING_WITH_LEN("User") },
{ C_STRING_WITH_LEN("char(") }, { STRING_WITH_LEN("char(") },
{NULL, 0} {NULL, 0}
}, },
{ {
{ C_STRING_WITH_LEN("Select_priv") }, { STRING_WITH_LEN("Select_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Insert_priv") }, { STRING_WITH_LEN("Insert_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Update_priv") }, { STRING_WITH_LEN("Update_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Delete_priv") }, { STRING_WITH_LEN("Delete_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Create_priv") }, { STRING_WITH_LEN("Create_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Drop_priv") }, { STRING_WITH_LEN("Drop_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Grant_priv") }, { STRING_WITH_LEN("Grant_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("References_priv") }, { STRING_WITH_LEN("References_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Index_priv") }, { STRING_WITH_LEN("Index_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Alter_priv") }, { STRING_WITH_LEN("Alter_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Create_tmp_table_priv") }, { STRING_WITH_LEN("Create_tmp_table_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Lock_tables_priv") }, { STRING_WITH_LEN("Lock_tables_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Create_view_priv") }, { STRING_WITH_LEN("Create_view_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Show_view_priv") }, { STRING_WITH_LEN("Show_view_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Create_routine_priv") }, { STRING_WITH_LEN("Create_routine_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Alter_routine_priv") }, { STRING_WITH_LEN("Alter_routine_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Execute_priv") }, { STRING_WITH_LEN("Execute_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Event_priv") }, { STRING_WITH_LEN("Event_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Trigger_priv") }, { STRING_WITH_LEN("Trigger_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("Truncate_versioning_priv") }, { STRING_WITH_LEN("Truncate_versioning_priv") },
{ C_STRING_WITH_LEN("enum('N','Y')") }, { STRING_WITH_LEN("enum('N','Y')") },
{ C_STRING_WITH_LEN("utf8") } { 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. Name of each diagnostic condition item.
This array is indexed by Diag_condition_item_name. 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 These states are bit coded with HARD. For each state there must be a pair
@ -3571,21 +3571,6 @@ public:
return lex_str; 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 *make_clex_string(const char* str, uint length)
{ {
LEX_CSTRING *lex_str; 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 TRUE Error sending data to client
*/ */
const LEX_STRING warning_level_names[]= const LEX_CSTRING warning_level_names[]=
{ {
{ C_STRING_WITH_LEN("Note") }, { STRING_WITH_LEN("Note") },
{ C_STRING_WITH_LEN("Warning") }, { STRING_WITH_LEN("Warning") },
{ C_STRING_WITH_LEN("Error") }, { STRING_WITH_LEN("Error") },
{ C_STRING_WITH_LEN("?") } { STRING_WITH_LEN("?") }
}; };
bool mysqld_show_warnings(THD *thd, ulong levels_to_show) 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, const char *from, uint32 from_length,
CHARSET_INFO *from_cs, uint *errors); 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); 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 char *any_db="*any*"; // Special symbol for check_access
const LEX_STRING command_name[257]={ const LEX_CSTRING command_name[257]={
{ C_STRING_WITH_LEN("Sleep") }, //0 { STRING_WITH_LEN("Sleep") }, //0
{ C_STRING_WITH_LEN("Quit") }, //1 { STRING_WITH_LEN("Quit") }, //1
{ C_STRING_WITH_LEN("Init DB") }, //2 { STRING_WITH_LEN("Init DB") }, //2
{ C_STRING_WITH_LEN("Query") }, //3 { STRING_WITH_LEN("Query") }, //3
{ C_STRING_WITH_LEN("Field List") }, //4 { STRING_WITH_LEN("Field List") }, //4
{ C_STRING_WITH_LEN("Create DB") }, //5 { STRING_WITH_LEN("Create DB") }, //5
{ C_STRING_WITH_LEN("Drop DB") }, //6 { STRING_WITH_LEN("Drop DB") }, //6
{ C_STRING_WITH_LEN("Refresh") }, //7 { STRING_WITH_LEN("Refresh") }, //7
{ C_STRING_WITH_LEN("Shutdown") }, //8 { STRING_WITH_LEN("Shutdown") }, //8
{ C_STRING_WITH_LEN("Statistics") }, //9 { STRING_WITH_LEN("Statistics") }, //9
{ C_STRING_WITH_LEN("Processlist") }, //10 { STRING_WITH_LEN("Processlist") }, //10
{ C_STRING_WITH_LEN("Connect") }, //11 { STRING_WITH_LEN("Connect") }, //11
{ C_STRING_WITH_LEN("Kill") }, //12 { STRING_WITH_LEN("Kill") }, //12
{ C_STRING_WITH_LEN("Debug") }, //13 { STRING_WITH_LEN("Debug") }, //13
{ C_STRING_WITH_LEN("Ping") }, //14 { STRING_WITH_LEN("Ping") }, //14
{ C_STRING_WITH_LEN("Time") }, //15 { STRING_WITH_LEN("Time") }, //15
{ C_STRING_WITH_LEN("Delayed insert") }, //16 { STRING_WITH_LEN("Delayed insert") }, //16
{ C_STRING_WITH_LEN("Change user") }, //17 { STRING_WITH_LEN("Change user") }, //17
{ C_STRING_WITH_LEN("Binlog Dump") }, //18 { STRING_WITH_LEN("Binlog Dump") }, //18
{ C_STRING_WITH_LEN("Table Dump") }, //19 { STRING_WITH_LEN("Table Dump") }, //19
{ C_STRING_WITH_LEN("Connect Out") }, //20 { STRING_WITH_LEN("Connect Out") }, //20
{ C_STRING_WITH_LEN("Register Slave") }, //21 { STRING_WITH_LEN("Register Slave") }, //21
{ C_STRING_WITH_LEN("Prepare") }, //22 { STRING_WITH_LEN("Prepare") }, //22
{ C_STRING_WITH_LEN("Execute") }, //23 { STRING_WITH_LEN("Execute") }, //23
{ C_STRING_WITH_LEN("Long Data") }, //24 { STRING_WITH_LEN("Long Data") }, //24
{ C_STRING_WITH_LEN("Close stmt") }, //25 { STRING_WITH_LEN("Close stmt") }, //25
{ C_STRING_WITH_LEN("Reset stmt") }, //26 { STRING_WITH_LEN("Reset stmt") }, //26
{ C_STRING_WITH_LEN("Set option") }, //27 { STRING_WITH_LEN("Set option") }, //27
{ C_STRING_WITH_LEN("Fetch") }, //28 { STRING_WITH_LEN("Fetch") }, //28
{ C_STRING_WITH_LEN("Daemon") }, //29 { STRING_WITH_LEN("Daemon") }, //29
{ C_STRING_WITH_LEN("Unimpl get tid") }, //30 { STRING_WITH_LEN("Unimpl get tid") }, //30
{ C_STRING_WITH_LEN("Reset connection") },//31 { STRING_WITH_LEN("Reset connection") },//31
{ 0, 0 }, //32 { 0, 0 }, //32
{ 0, 0 }, //33 { 0, 0 }, //33
{ 0, 0 }, //34 { 0, 0 }, //34
@ -383,12 +383,12 @@ const LEX_STRING command_name[257]={
{ 0, 0 }, //247 { 0, 0 }, //247
{ 0, 0 }, //248 { 0, 0 }, //248
{ 0, 0 }, //249 { 0, 0 }, //249
{ C_STRING_WITH_LEN("Bulk_execute") }, //250 { STRING_WITH_LEN("Bulk_execute") }, //250
{ C_STRING_WITH_LEN("Slave_worker") }, //251 { STRING_WITH_LEN("Slave_worker") }, //251
{ C_STRING_WITH_LEN("Slave_IO") }, //252 { STRING_WITH_LEN("Slave_IO") }, //252
{ C_STRING_WITH_LEN("Slave_SQL") }, //253 { STRING_WITH_LEN("Slave_SQL") }, //253
{ C_STRING_WITH_LEN("Com_multi") }, //254 { STRING_WITH_LEN("Com_multi") }, //254
{ C_STRING_WITH_LEN("Error") } // Last command number 255 { STRING_WITH_LEN("Error") } // Last command number 255
}; };
const char *xa_state_names[]={ 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 const char* any_db;
extern uint sql_command_flags[]; extern uint sql_command_flags[];
extern uint server_command_flags[]; extern uint server_command_flags[];
extern const LEX_STRING command_name[]; extern const LEX_CSTRING command_name[];
extern uint server_command_flags[]; extern uint server_command_flags[];
/* Inline functions */ /* 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 When you ad a new plugin type, add both a string and make sure that the
init and deinit array are correctly updated. 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") }, { STRING_WITH_LEN("UDF") },
{ C_STRING_WITH_LEN("STORAGE ENGINE") }, { STRING_WITH_LEN("STORAGE ENGINE") },
{ C_STRING_WITH_LEN("FTPARSER") }, { STRING_WITH_LEN("FTPARSER") },
{ C_STRING_WITH_LEN("DAEMON") }, { STRING_WITH_LEN("DAEMON") },
{ C_STRING_WITH_LEN("INFORMATION SCHEMA") }, { STRING_WITH_LEN("INFORMATION SCHEMA") },
{ C_STRING_WITH_LEN("AUDIT") }, { STRING_WITH_LEN("AUDIT") },
{ C_STRING_WITH_LEN("REPLICATION") }, { STRING_WITH_LEN("REPLICATION") },
{ C_STRING_WITH_LEN("AUTHENTICATION") }, { STRING_WITH_LEN("AUTHENTICATION") },
{ C_STRING_WITH_LEN("PASSWORD VALIDATION") }, { STRING_WITH_LEN("PASSWORD VALIDATION") },
{ C_STRING_WITH_LEN("ENCRYPTION") } { STRING_WITH_LEN("ENCRYPTION") }
}; };
extern int initialize_schema_table(st_plugin_int *plugin); 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) my_option *options)
{ {
const char *plugin_name= tmp->plugin->name; 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 plugin_name_len= strlen(plugin_name);
uint optnamelen; uint optnamelen;
const int max_comment_len= 180; 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 I_List<i_string> *opt_plugin_load_list_ptr;
extern char *opt_plugin_dir_ptr; extern char *opt_plugin_dir_ptr;
extern MYSQL_PLUGIN_IMPORT char opt_plugin_dir[FN_REFLEN]; 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 ulong plugin_maturity;
extern TYPELIB plugin_maturity_values; extern TYPELIB plugin_maturity_values;
extern const char *plugin_maturity_names[]; 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) 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 *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str, (user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length); name.length);
@ -695,7 +695,7 @@ void set_read_error(binlog_send_info *info, int error)
static ulonglong get_heartbeat_period(THD * thd) static ulonglong get_heartbeat_period(THD * thd)
{ {
bool null_value; 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 *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str, (user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length); name.length);
@ -714,7 +714,7 @@ static int
get_mariadb_slave_capability(THD *thd) get_mariadb_slave_capability(THD *thd)
{ {
bool null_value; 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= const user_var_entry *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str, (user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length); name.length);
@ -735,7 +735,7 @@ get_slave_connect_state(THD *thd, String *out_str)
{ {
bool null_value; 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 *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str, (user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length); name.length);
@ -748,7 +748,7 @@ get_slave_gtid_strict_mode(THD *thd)
{ {
bool null_value; 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 *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str, (user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length); name.length);
@ -761,7 +761,7 @@ get_slave_gtid_ignore_duplicates(THD *thd)
{ {
bool null_value; 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 *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str, (user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length); name.length);
@ -782,7 +782,7 @@ get_slave_until_gtid(THD *thd, String *out_str)
{ {
bool null_value; 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 *entry=
(user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str, (user_var_entry*) my_hash_search(&thd->user_vars, (uchar*) name.str,
name.length); 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}, {"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}, {"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, {"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(""), {"cache_size", 21, &type_handler_longlong, STRING_WITH_LEN(""),
FL | UNSIGNED_FLAG}, 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")}, {"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); restore_record(table, s->default_values);
table->field[0]->store(plug->name, strlen(plug->name), scs); 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); table->field[2]->store(plug->descr, strlen(plug->descr), scs);
if (schema_table_store_record(thd, table)) if (schema_table_store_record(thd, table))
DBUG_RETURN(1); DBUG_RETURN(1);

62
sql/sql_signal.cc
View File

@ -29,38 +29,38 @@
*/ */
#define MAX_MYSQL_ERRNO 65534 #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") }, { STRING_WITH_LEN("CLASS_ORIGIN") },
{ C_STRING_WITH_LEN("SUBCLASS_ORIGIN") }, { STRING_WITH_LEN("SUBCLASS_ORIGIN") },
{ C_STRING_WITH_LEN("CONSTRAINT_CATALOG") }, { STRING_WITH_LEN("CONSTRAINT_CATALOG") },
{ C_STRING_WITH_LEN("CONSTRAINT_SCHEMA") }, { STRING_WITH_LEN("CONSTRAINT_SCHEMA") },
{ C_STRING_WITH_LEN("CONSTRAINT_NAME") }, { STRING_WITH_LEN("CONSTRAINT_NAME") },
{ C_STRING_WITH_LEN("CATALOG_NAME") }, { STRING_WITH_LEN("CATALOG_NAME") },
{ C_STRING_WITH_LEN("SCHEMA_NAME") }, { STRING_WITH_LEN("SCHEMA_NAME") },
{ C_STRING_WITH_LEN("TABLE_NAME") }, { STRING_WITH_LEN("TABLE_NAME") },
{ C_STRING_WITH_LEN("COLUMN_NAME") }, { STRING_WITH_LEN("COLUMN_NAME") },
{ C_STRING_WITH_LEN("CURSOR_NAME") }, { STRING_WITH_LEN("CURSOR_NAME") },
{ C_STRING_WITH_LEN("MESSAGE_TEXT") }, { STRING_WITH_LEN("MESSAGE_TEXT") },
{ C_STRING_WITH_LEN("MYSQL_ERRNO") }, { STRING_WITH_LEN("MYSQL_ERRNO") },
{ C_STRING_WITH_LEN("CONDITION_IDENTIFIER") }, { STRING_WITH_LEN("CONDITION_IDENTIFIER") },
{ C_STRING_WITH_LEN("CONDITION_NUMBER") }, { STRING_WITH_LEN("CONDITION_NUMBER") },
{ C_STRING_WITH_LEN("CONNECTION_NAME") }, { STRING_WITH_LEN("CONNECTION_NAME") },
{ C_STRING_WITH_LEN("MESSAGE_LENGTH") }, { STRING_WITH_LEN("MESSAGE_LENGTH") },
{ C_STRING_WITH_LEN("MESSAGE_OCTET_LENGTH") }, { STRING_WITH_LEN("MESSAGE_OCTET_LENGTH") },
{ C_STRING_WITH_LEN("PARAMETER_MODE") }, { STRING_WITH_LEN("PARAMETER_MODE") },
{ C_STRING_WITH_LEN("PARAMETER_NAME") }, { STRING_WITH_LEN("PARAMETER_NAME") },
{ C_STRING_WITH_LEN("PARAMETER_ORDINAL_POSITION") }, { STRING_WITH_LEN("PARAMETER_ORDINAL_POSITION") },
{ C_STRING_WITH_LEN("RETURNED_SQLSTATE") }, { STRING_WITH_LEN("RETURNED_SQLSTATE") },
{ C_STRING_WITH_LEN("ROUTINE_CATALOG") }, { STRING_WITH_LEN("ROUTINE_CATALOG") },
{ C_STRING_WITH_LEN("ROUTINE_NAME") }, { STRING_WITH_LEN("ROUTINE_NAME") },
{ C_STRING_WITH_LEN("ROUTINE_SCHEMA") }, { STRING_WITH_LEN("ROUTINE_SCHEMA") },
{ C_STRING_WITH_LEN("SERVER_NAME") }, { STRING_WITH_LEN("SERVER_NAME") },
{ C_STRING_WITH_LEN("SPECIFIC_NAME") }, { STRING_WITH_LEN("SPECIFIC_NAME") },
{ C_STRING_WITH_LEN("TRIGGER_CATALOG") }, { STRING_WITH_LEN("TRIGGER_CATALOG") },
{ C_STRING_WITH_LEN("TRIGGER_NAME") }, { STRING_WITH_LEN("TRIGGER_NAME") },
{ C_STRING_WITH_LEN("TRIGGER_SCHEMA") } { 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; int result= 1;
enum enum_diag_condition_item_name item_enum; enum enum_diag_condition_item_name item_enum;
String *member; String *member;
const LEX_STRING *name; const LEX_CSTRING *name;
DBUG_ENTER("Sql_cmd_common_signal::eval_signal_informations"); 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] = TABLE_FIELD_TYPE table_stat_fields[TABLE_STAT_N_FIELDS] =
{ {
{ {
{ C_STRING_WITH_LEN("db_name") }, { STRING_WITH_LEN("db_name") },
{ C_STRING_WITH_LEN("varchar(64)") }, { STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("table_name") }, { STRING_WITH_LEN("table_name") },
{ C_STRING_WITH_LEN("varchar(64)") }, { STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("cardinality") }, { STRING_WITH_LEN("cardinality") },
{ C_STRING_WITH_LEN("bigint(21)") }, { STRING_WITH_LEN("bigint(21)") },
{ NULL, 0 } { NULL, 0 }
}, },
}; };
@ -154,58 +154,58 @@ static const
TABLE_FIELD_TYPE column_stat_fields[COLUMN_STAT_N_FIELDS] = TABLE_FIELD_TYPE column_stat_fields[COLUMN_STAT_N_FIELDS] =
{ {
{ {
{ C_STRING_WITH_LEN("db_name") }, { STRING_WITH_LEN("db_name") },
{ C_STRING_WITH_LEN("varchar(64)") }, { STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("table_name") }, { STRING_WITH_LEN("table_name") },
{ C_STRING_WITH_LEN("varchar(64)") }, { STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("column_name") }, { STRING_WITH_LEN("column_name") },
{ C_STRING_WITH_LEN("varchar(64)") }, { STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("min_value") }, { STRING_WITH_LEN("min_value") },
{ C_STRING_WITH_LEN("varbinary(255)") }, { STRING_WITH_LEN("varbinary(255)") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("max_value") }, { STRING_WITH_LEN("max_value") },
{ C_STRING_WITH_LEN("varbinary(255)") }, { STRING_WITH_LEN("varbinary(255)") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("nulls_ratio") }, { STRING_WITH_LEN("nulls_ratio") },
{ C_STRING_WITH_LEN("decimal(12,4)") }, { STRING_WITH_LEN("decimal(12,4)") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("avg_length") }, { STRING_WITH_LEN("avg_length") },
{ C_STRING_WITH_LEN("decimal(12,4)") }, { STRING_WITH_LEN("decimal(12,4)") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("avg_frequency") }, { STRING_WITH_LEN("avg_frequency") },
{ C_STRING_WITH_LEN("decimal(12,4)") }, { STRING_WITH_LEN("decimal(12,4)") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("hist_size") }, { STRING_WITH_LEN("hist_size") },
{ C_STRING_WITH_LEN("tinyint(3)") }, { STRING_WITH_LEN("tinyint(3)") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("hist_type") }, { STRING_WITH_LEN("hist_type") },
{ C_STRING_WITH_LEN("enum('SINGLE_PREC_HB','DOUBLE_PREC_HB')") }, { STRING_WITH_LEN("enum('SINGLE_PREC_HB','DOUBLE_PREC_HB')") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("histogram") }, { STRING_WITH_LEN("histogram") },
{ C_STRING_WITH_LEN("varbinary(255)") }, { STRING_WITH_LEN("varbinary(255)") },
{ NULL, 0 } { NULL, 0 }
} }
}; };
@ -217,28 +217,28 @@ static const
TABLE_FIELD_TYPE index_stat_fields[INDEX_STAT_N_FIELDS] = TABLE_FIELD_TYPE index_stat_fields[INDEX_STAT_N_FIELDS] =
{ {
{ {
{ C_STRING_WITH_LEN("db_name") }, { STRING_WITH_LEN("db_name") },
{ C_STRING_WITH_LEN("varchar(64)") }, { STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("table_name") }, { STRING_WITH_LEN("table_name") },
{ C_STRING_WITH_LEN("varchar(64)") }, { STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("index") }, { STRING_WITH_LEN("index") },
{ C_STRING_WITH_LEN("varchar(64)") }, { STRING_WITH_LEN("varchar(64)") },
{ C_STRING_WITH_LEN("utf8") } { STRING_WITH_LEN("utf8") }
}, },
{ {
{ C_STRING_WITH_LEN("prefix_arity") }, { STRING_WITH_LEN("prefix_arity") },
{ C_STRING_WITH_LEN("int(11)") }, { STRING_WITH_LEN("int(11)") },
{ NULL, 0 } { NULL, 0 }
}, },
{ {
{ C_STRING_WITH_LEN("avg_frequency") }, { STRING_WITH_LEN("avg_frequency") },
{ C_STRING_WITH_LEN("decimal(12,4)") }, { STRING_WITH_LEN("decimal(12,4)") },
{ NULL, 0 } { 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= static const LEX_CSTRING triggers_file_type=
{ C_STRING_WITH_LEN("TRIGGERS") }; { STRING_WITH_LEN("TRIGGERS") };
const char * const TRG_EXT= ".TRG"; 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 }; { 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 const Name
Type_handler_string::m_name_char(C_STRING_WITH_LEN("char")), Type_handler_string::m_name_char(STRING_WITH_LEN("char")),
Type_handler_var_string::m_name_var_string(C_STRING_WITH_LEN("varchar")), Type_handler_var_string::m_name_var_string(STRING_WITH_LEN("varchar")),
Type_handler_varchar::m_name_varchar(C_STRING_WITH_LEN("varchar")), Type_handler_varchar::m_name_varchar(STRING_WITH_LEN("varchar")),
Type_handler_tiny_blob::m_name_tinyblob(C_STRING_WITH_LEN("tinyblob")), Type_handler_tiny_blob::m_name_tinyblob(STRING_WITH_LEN("tinyblob")),
Type_handler_medium_blob::m_name_mediumblob(C_STRING_WITH_LEN("mediumblob")), Type_handler_medium_blob::m_name_mediumblob(STRING_WITH_LEN("mediumblob")),
Type_handler_long_blob::m_name_longblob(C_STRING_WITH_LEN("longblob")), Type_handler_long_blob::m_name_longblob(STRING_WITH_LEN("longblob")),
Type_handler_blob::m_name_blob(C_STRING_WITH_LEN("blob")); Type_handler_blob::m_name_blob(STRING_WITH_LEN("blob"));
const Name const Name
Type_handler_enum::m_name_enum(C_STRING_WITH_LEN("enum")), Type_handler_enum::m_name_enum(STRING_WITH_LEN("enum")),
Type_handler_set::m_name_set(C_STRING_WITH_LEN("set")); Type_handler_set::m_name_set(STRING_WITH_LEN("set"));
const Name const Name
Type_handler_tiny::m_name_tiny(C_STRING_WITH_LEN("tinyint")), Type_handler_tiny::m_name_tiny(STRING_WITH_LEN("tinyint")),
Type_handler_short::m_name_short(C_STRING_WITH_LEN("smallint")), Type_handler_short::m_name_short(STRING_WITH_LEN("smallint")),
Type_handler_long::m_name_int(C_STRING_WITH_LEN("int")), Type_handler_long::m_name_int(STRING_WITH_LEN("int")),
Type_handler_longlong::m_name_longlong(C_STRING_WITH_LEN("bigint")), Type_handler_longlong::m_name_longlong(STRING_WITH_LEN("bigint")),
Type_handler_int24::m_name_mediumint(C_STRING_WITH_LEN("mediumint")), Type_handler_int24::m_name_mediumint(STRING_WITH_LEN("mediumint")),
Type_handler_year::m_name_year(C_STRING_WITH_LEN("year")), Type_handler_year::m_name_year(STRING_WITH_LEN("year")),
Type_handler_bit::m_name_bit(C_STRING_WITH_LEN("bit")); Type_handler_bit::m_name_bit(STRING_WITH_LEN("bit"));
const Name const Name
Type_handler_float::m_name_float(C_STRING_WITH_LEN("float")), Type_handler_float::m_name_float(STRING_WITH_LEN("float")),
Type_handler_double::m_name_double(C_STRING_WITH_LEN("double")); Type_handler_double::m_name_double(STRING_WITH_LEN("double"));
const Name const Name
Type_handler_olddecimal::m_name_decimal(C_STRING_WITH_LEN("decimal")), Type_handler_olddecimal::m_name_decimal(STRING_WITH_LEN("decimal")),
Type_handler_newdecimal::m_name_decimal(C_STRING_WITH_LEN("decimal")); Type_handler_newdecimal::m_name_decimal(STRING_WITH_LEN("decimal"));
const Name const Name
Type_handler_time_common::m_name_time(C_STRING_WITH_LEN("time")), Type_handler_time_common::m_name_time(STRING_WITH_LEN("time")),
Type_handler_date_common::m_name_date(C_STRING_WITH_LEN("date")), Type_handler_date_common::m_name_date(STRING_WITH_LEN("date")),
Type_handler_datetime_common::m_name_datetime(C_STRING_WITH_LEN("datetime")), Type_handler_datetime_common::m_name_datetime(STRING_WITH_LEN("datetime")),
Type_handler_timestamp_common::m_name_timestamp(C_STRING_WITH_LEN("timestamp")); 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 #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 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; CHARSET_INFO *cs= thd->variables.character_set_client;
StringBuffer<STRING_BUFFER_USUAL_SIZE> val(cs); 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++) for (uint i= 0 ; i < item->cols(); i++)
{ {
if (i > 0) if (i > 0)
@ -3978,7 +3978,7 @@ String *Type_handler_row::
else else
str->append(STRING_WITH_LEN("NULL")); str->append(STRING_WITH_LEN("NULL"));
} }
str->append(C_STRING_WITH_LEN(")")); str->append(STRING_WITH_LEN(")"));
return str; return str;
} }
@ -4042,7 +4042,7 @@ String *Type_handler_time_common::
{ {
StringBuffer<MAX_TIME_FULL_WIDTH+1> buf; StringBuffer<MAX_TIME_FULL_WIDTH+1> buf;
return print_item_value_temporal(thd, item, str, 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; StringBuffer<MAX_DATE_WIDTH+1> buf;
return print_item_value_temporal(thd, item, str, 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; StringBuffer<MAX_DATETIME_FULL_WIDTH+1> buf;
return print_item_value_temporal(thd, item, str, 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; StringBuffer<MAX_DATETIME_FULL_WIDTH+1> buf;
return print_item_value_temporal(thd, item, str, 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); StringBuffer<128> buff(thd->variables.character_set_client);
DBUG_ASSERT(buff.charset()->mbminlen == 1); DBUG_ASSERT(buff.charset()->mbminlen == 1);
const LEX_STRING command[3]= const LEX_CSTRING command[3]=
{{ C_STRING_WITH_LEN("CREATE ") }, {{ STRING_WITH_LEN("CREATE ") },
{ C_STRING_WITH_LEN("ALTER ") }, { STRING_WITH_LEN("ALTER ") },
{ C_STRING_WITH_LEN("CREATE OR REPLACE ") }}; { STRING_WITH_LEN("CREATE OR REPLACE ") }};
buff.append(&command[thd->lex->create_view->mode]); buff.append(&command[thd->lex->create_view->mode]);
view_store_options(thd, views, &buff); 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 | WAIT_SYM ulong_num
{ {
if (set_statement_var_if_exists(thd, C_STRING_WITH_LEN("lock_wait_timeout"), $2) || if (set_statement_var_if_exists(thd, STRING_WITH_LEN("lock_wait_timeout"), $2) ||
set_statement_var_if_exists(thd, C_STRING_WITH_LEN("innodb_lock_wait_timeout"), $2)) set_statement_var_if_exists(thd, STRING_WITH_LEN("innodb_lock_wait_timeout"), $2))
MYSQL_YYABORT; MYSQL_YYABORT;
} }
| NOWAIT_SYM | NOWAIT_SYM
{ {
if (set_statement_var_if_exists(thd, C_STRING_WITH_LEN("lock_wait_timeout"), 0) || if (set_statement_var_if_exists(thd, STRING_WITH_LEN("lock_wait_timeout"), 0) ||
set_statement_var_if_exists(thd, C_STRING_WITH_LEN("innodb_lock_wait_timeout"), 0)) set_statement_var_if_exists(thd, STRING_WITH_LEN("innodb_lock_wait_timeout"), 0))
MYSQL_YYABORT; MYSQL_YYABORT;
} }
; ;

8
sql/sql_yacc_ora.yy
View File

@ -15764,14 +15764,14 @@ opt_lock_wait_timeout:
{} {}
| WAIT_SYM ulong_num | WAIT_SYM ulong_num
{ {
if (set_statement_var_if_exists(thd, C_STRING_WITH_LEN("lock_wait_timeout"), $2) || if (set_statement_var_if_exists(thd, STRING_WITH_LEN("lock_wait_timeout"), $2) ||
set_statement_var_if_exists(thd, C_STRING_WITH_LEN("innodb_lock_wait_timeout"), $2)) set_statement_var_if_exists(thd, STRING_WITH_LEN("innodb_lock_wait_timeout"), $2))
MYSQL_YYABORT; MYSQL_YYABORT;
} }
| NOWAIT_SYM | NOWAIT_SYM
{ {
if (set_statement_var_if_exists(thd, C_STRING_WITH_LEN("lock_wait_timeout"), 0) || if (set_statement_var_if_exists(thd, STRING_WITH_LEN("lock_wait_timeout"), 0) ||
set_statement_var_if_exists(thd, C_STRING_WITH_LEN("innodb_lock_wait_timeout"), 0)) set_statement_var_if_exists(thd, STRING_WITH_LEN("innodb_lock_wait_timeout"), 0))
MYSQL_YYABORT; 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]= static const LEX_CSTRING tz_tables_names[MY_TZ_TABLES_COUNT]=
{ {
{ C_STRING_WITH_LEN("time_zone_name")}, { STRING_WITH_LEN("time_zone_name")},
{ C_STRING_WITH_LEN("time_zone")}, { STRING_WITH_LEN("time_zone")},
{ C_STRING_WITH_LEN("time_zone_transition_type")}, { STRING_WITH_LEN("time_zone_transition_type")},
{ C_STRING_WITH_LEN("time_zone_transition")} { STRING_WITH_LEN("time_zone_transition")}
}; };
class Tz_names_entry: public Sql_alloc 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; TABLE_LIST *views = first_table;
LEX_USER *definer; LEX_USER *definer;
String buff; String buff;
const LEX_STRING command[3]= const LEX_CSTRING command[3]=
{{ C_STRING_WITH_LEN("CREATE ") }, {{ STRING_WITH_LEN("CREATE ") },
{ C_STRING_WITH_LEN("ALTER ") }, { STRING_WITH_LEN("ALTER ") },
{ C_STRING_WITH_LEN("CREATE OR REPLACE ") }}; { STRING_WITH_LEN("CREATE OR REPLACE ") }};
buff.append(&command[thd->lex->create_view->mode]); buff.append(&command[thd->lex->create_view->mode]);