SILENT KILLERPanel

Current Path: > > usr > > include > mysql > server > private >


Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]

Files and Folders in: //usr//include/mysql/server/private/

NameTypeSizeLast ModifiedActions
atomic Directory - -
aligned.h File 1136 bytes May 28 2025 17:32:51.
aria_backup.h File 1547 bytes May 28 2025 17:32:51.
assume_aligned.h File 2350 bytes May 28 2025 17:32:51.
authors.h File 10141 bytes May 28 2025 17:32:51.
backup.h File 1703 bytes May 28 2025 17:32:51.
bounded_queue.h File 6093 bytes May 28 2025 17:32:51.
client_settings.h File 1935 bytes May 28 2025 17:32:51.
compat56.h File 2280 bytes May 28 2025 17:32:51.
config.h File 14574 bytes May 28 2025 17:32:51.
contributors.h File 4878 bytes May 28 2025 17:32:51.
create_options.h File 4524 bytes May 28 2025 17:32:51.
create_tmp_table.h File 2808 bytes May 28 2025 17:32:51.
cset_narrowing.h File 3968 bytes May 28 2025 17:32:51.
custom_conf.h File 1082 bytes May 28 2025 17:32:51.
datadict.h File 1700 bytes May 28 2025 17:32:51.
ddl_log.h File 12685 bytes May 28 2025 17:32:51.
debug.h File 1234 bytes May 28 2025 17:32:51.
debug_sync.h File 2046 bytes May 28 2025 17:32:51.
derived_handler.h File 2379 bytes May 28 2025 17:32:51.
derror.h File 980 bytes May 28 2025 17:32:51.
des_key_file.h File 1236 bytes May 28 2025 17:32:51.
discover.h File 1570 bytes May 28 2025 17:32:51.
dur_prop.h File 1082 bytes May 28 2025 17:32:51.
embedded_priv.h File 1733 bytes May 28 2025 17:32:51.
event_data_objects.h File 4187 bytes May 28 2025 17:32:51.
event_db_repository.h File 3648 bytes May 28 2025 17:32:51.
event_parse_data.h File 2899 bytes May 28 2025 17:32:51.
event_queue.h File 3438 bytes May 28 2025 17:32:51.
event_scheduler.h File 3290 bytes May 28 2025 17:32:51.
events.h File 4704 bytes May 28 2025 17:32:51.
field.h File 220415 bytes May 28 2025 17:32:51.
field_comp.h File 1174 bytes May 28 2025 17:32:51.
filesort.h File 7283 bytes May 28 2025 17:32:51.
filesort_utils.h File 8195 bytes May 28 2025 17:32:51.
ft_global.h File 3113 bytes May 28 2025 17:32:51.
gcalc_slicescan.h File 17272 bytes May 28 2025 17:32:51.
gcalc_tools.h File 11900 bytes May 28 2025 17:32:51.
grant.h File 2758 bytes May 28 2025 17:32:51.
group_by_handler.h File 3534 bytes May 28 2025 17:32:51.
gstream.h File 2437 bytes May 28 2025 17:32:51.
ha_handler_stats.h File 2335 bytes May 28 2025 17:32:51.
ha_partition.h File 64413 bytes May 28 2025 17:32:51.
ha_sequence.h File 6245 bytes May 28 2025 17:32:51.
handle_connections_win.h File 884 bytes May 28 2025 17:32:51.
handler.h File 201171 bytes May 28 2025 17:32:51.
hash.h File 4449 bytes May 28 2025 17:32:51.
hash_filo.h File 5688 bytes May 28 2025 17:32:51.
heap.h File 9480 bytes May 28 2025 17:32:51.
hostname.h File 5419 bytes May 28 2025 17:32:51.
ilist.h File 7048 bytes May 28 2025 17:32:51.
init.h File 852 bytes May 28 2025 17:32:51.
innodb_priv.h File 1319 bytes May 28 2025 17:32:51.
item.h File 279188 bytes May 28 2025 17:32:51.
item_cmpfunc.h File 135027 bytes May 28 2025 17:32:51.
item_create.h File 11501 bytes May 28 2025 17:32:51.
item_func.h File 136655 bytes May 28 2025 17:32:51.
item_geofunc.h File 38904 bytes May 28 2025 17:32:51.
item_jsonfunc.h File 22516 bytes May 28 2025 17:32:51.
item_row.h File 5221 bytes May 28 2025 17:32:51.
item_strfunc.h File 72241 bytes May 28 2025 17:32:51.
item_subselect.h File 59153 bytes May 28 2025 17:32:51.
item_sum.h File 72287 bytes May 28 2025 17:32:51.
item_timefunc.h File 64615 bytes May 28 2025 17:32:51.
item_vers.h File 4334 bytes May 28 2025 17:32:51.
item_windowfunc.h File 34315 bytes May 28 2025 17:32:51.
item_xmlfunc.h File 4607 bytes May 28 2025 17:32:51.
json_table.h File 9506 bytes May 28 2025 17:32:51.
key.h File 2132 bytes May 28 2025 17:32:51.
keycaches.h File 1995 bytes May 28 2025 17:32:51.
lex.h File 29827 bytes May 28 2025 17:32:51.
lex_string.h File 4068 bytes May 28 2025 17:32:51.
lex_symbol.h File 1323 bytes May 28 2025 17:32:51.
lf.h File 6462 bytes May 28 2025 17:32:51.
lock.h File 2203 bytes May 28 2025 17:32:51.
log.h File 46083 bytes May 28 2025 17:32:51.
log_event.h File 186410 bytes May 28 2025 17:32:51.
log_event_data_type.h File 1890 bytes May 28 2025 17:32:51.
log_event_old.h File 19830 bytes May 28 2025 17:32:51.
log_slow.h File 2442 bytes May 28 2025 17:32:51.
maria.h File 5872 bytes May 28 2025 17:32:51.
mariadb.h File 1277 bytes May 28 2025 17:32:51.
mdl.h File 38468 bytes May 28 2025 17:32:51.
mem_root_array.h File 7106 bytes May 28 2025 17:32:51.
message.h File 1195 bytes May 28 2025 17:32:51.
multi_range_read.h File 23179 bytes May 28 2025 17:32:51.
my_alarm.h File 2429 bytes May 28 2025 17:32:51.
my_apc.h File 4747 bytes May 28 2025 17:32:51.
my_atomic.h File 7281 bytes May 28 2025 17:32:51.
my_atomic_wrapper.h File 3051 bytes May 28 2025 17:32:51.
my_base.h File 27210 bytes May 28 2025 17:32:51.
my_bit.h File 6196 bytes May 28 2025 17:32:51.
my_bitmap.h File 5882 bytes May 28 2025 17:32:51.
my_check_opt.h File 2618 bytes May 28 2025 17:32:51.
my_compare.h File 11194 bytes May 28 2025 17:32:51.
my_counter.h File 1721 bytes May 28 2025 17:32:51.
my_cpu.h File 4855 bytes May 28 2025 17:32:51.
my_crypt.h File 904 bytes May 28 2025 17:32:51.
my_decimal.h File 14489 bytes May 28 2025 17:32:51.
my_default.h File 1880 bytes May 28 2025 17:32:51.
my_handler_errors.h File 4882 bytes May 28 2025 17:32:51.
my_json_writer.h File 18382 bytes May 28 2025 17:32:51.
my_libwrap.h File 1183 bytes May 28 2025 17:32:51.
my_md5.h File 1486 bytes May 28 2025 17:32:51.
my_minidump.h File 848 bytes May 28 2025 17:32:51.
my_nosys.h File 1438 bytes May 28 2025 17:32:51.
my_rdtsc.h File 8425 bytes May 28 2025 17:32:51.
my_rnd.h File 1064 bytes May 28 2025 17:32:51.
my_service_manager.h File 2050 bytes May 28 2025 17:32:51.
my_stack_alloc.h File 6493 bytes May 28 2025 17:32:51.
my_stacktrace.h File 3215 bytes May 28 2025 17:32:51.
my_time.h File 10466 bytes May 28 2025 17:32:51.
my_tree.h File 3991 bytes May 28 2025 17:32:51.
my_uctype.h File 69528 bytes May 28 2025 17:32:51.
my_user.h File 1126 bytes May 28 2025 17:32:51.
myisam.h File 17506 bytes May 28 2025 17:32:51.
myisamchk.h File 4716 bytes May 28 2025 17:32:51.
myisammrg.h File 4897 bytes May 28 2025 17:32:51.
myisampack.h File 14929 bytes May 28 2025 17:32:51.
mysqld.h File 40502 bytes May 28 2025 17:32:51.
mysqld_default_groups.h File 204 bytes May 28 2025 17:32:51.
mysqld_suffix.h File 1201 bytes May 28 2025 17:32:51.
mysys_err.h File 3022 bytes May 28 2025 17:32:51.
opt_range.h File 59591 bytes May 28 2025 17:32:51.
opt_subselect.h File 14551 bytes May 28 2025 17:32:51.
opt_trace.h File 8494 bytes May 28 2025 17:32:51.
opt_trace_context.h File 3291 bytes May 28 2025 17:32:51.
parse_file.h File 4387 bytes May 28 2025 17:32:51.
partition_element.h File 5209 bytes May 28 2025 17:32:51.
partition_info.h File 19300 bytes May 28 2025 17:32:51.
password.h File 1170 bytes May 28 2025 17:32:51.
pfs_file_provider.h File 3153 bytes May 28 2025 17:32:51.
pfs_idle_provider.h File 1385 bytes May 28 2025 17:32:51.
pfs_memory_provider.h File 1626 bytes May 28 2025 17:32:51.
pfs_metadata_provider.h File 1898 bytes May 28 2025 17:32:51.
pfs_socket_provider.h File 2258 bytes May 28 2025 17:32:51.
pfs_stage_provider.h File 1556 bytes May 28 2025 17:32:51.
pfs_statement_provider.h File 4347 bytes May 28 2025 17:32:51.
pfs_table_provider.h File 2625 bytes May 28 2025 17:32:51.
pfs_thread_provider.h File 5560 bytes May 28 2025 17:32:51.
pfs_transaction_provider.h File 2846 bytes May 28 2025 17:32:51.
privilege.h File 28642 bytes May 28 2025 17:32:51.
probes_mysql.h File 973 bytes May 28 2025 17:32:51.
probes_mysql_dtrace.h File 33005 bytes May 28 2025 17:32:51.
probes_mysql_nodtrace.h File 5005 bytes May 28 2025 17:32:51.
procedure.h File 6784 bytes May 28 2025 17:32:51.
protocol.h File 12490 bytes May 28 2025 17:32:51.
proxy_protocol.h File 548 bytes May 28 2025 17:32:51.
queues.h File 3477 bytes May 28 2025 17:32:51.
records.h File 3147 bytes May 28 2025 17:32:51.
repl_failsafe.h File 1585 bytes May 28 2025 17:32:51.
replication.h File 16106 bytes May 28 2025 17:32:51.
rijndael.h File 1711 bytes May 28 2025 17:32:51.
rowid_filter.h File 15477 bytes May 28 2025 17:32:51.
rpl_constants.h File 3357 bytes May 28 2025 17:32:51.
rpl_filter.h File 4535 bytes May 28 2025 17:32:51.
rpl_gtid.h File 13683 bytes May 28 2025 17:32:51.
rpl_injector.h File 9621 bytes May 28 2025 17:32:51.
rpl_mi.h File 14991 bytes May 28 2025 17:32:51.
rpl_parallel.h File 17461 bytes May 28 2025 17:32:51.
rpl_record.h File 1585 bytes May 28 2025 17:32:51.
rpl_record_old.h File 1407 bytes May 28 2025 17:32:51.
rpl_reporting.h File 3713 bytes May 28 2025 17:32:51.
rpl_rli.h File 32746 bytes May 28 2025 17:32:51.
rpl_tblmap.h File 3177 bytes May 28 2025 17:32:51.
rpl_utility.h File 9630 bytes May 28 2025 17:32:51.
scheduler.h File 3199 bytes May 28 2025 17:32:51.
scope.h File 4393 bytes May 28 2025 17:32:51.
select_handler.h File 2228 bytes May 28 2025 17:32:51.
semisync.h File 2287 bytes May 28 2025 17:32:51.
semisync_master.h File 25562 bytes May 28 2025 17:32:51.
semisync_master_ack_receiver.h File 8709 bytes May 28 2025 17:32:51.
semisync_slave.h File 3733 bytes May 28 2025 17:32:51.
service_versions.h File 2049 bytes May 28 2025 17:32:51.
session_tracker.h File 14275 bytes May 28 2025 17:32:51.
set_var.h File 16551 bytes May 28 2025 17:32:51.
slave.h File 12275 bytes May 28 2025 17:32:51.
socketpair.h File 842 bytes May 28 2025 17:32:51.
source_revision.h File 67 bytes May 28 2025 17:32:51.
sp.h File 22588 bytes May 28 2025 17:32:51.
sp_cache.h File 2045 bytes May 28 2025 17:32:51.
sp_head.h File 64509 bytes May 28 2025 17:32:51.
sp_pcontext.h File 24897 bytes May 28 2025 17:32:51.
sp_rcontext.h File 14334 bytes May 28 2025 17:32:51.
span.h File 3931 bytes May 28 2025 17:32:51.
spatial.h File 22305 bytes May 28 2025 17:32:51.
sql_acl.h File 14132 bytes May 28 2025 17:32:51.
sql_admin.h File 2915 bytes May 28 2025 17:32:51.
sql_alloc.h File 1732 bytes May 28 2025 17:32:51.
sql_alter.h File 15277 bytes May 28 2025 17:32:51.
sql_analyse.h File 11125 bytes May 28 2025 17:32:51.
sql_analyze_stmt.h File 12681 bytes May 28 2025 17:32:51.
sql_array.h File 6875 bytes May 28 2025 17:32:51.
sql_audit.h File 13943 bytes May 28 2025 17:32:51.
sql_base.h File 25880 bytes May 28 2025 17:32:51.
sql_basic_types.h File 9528 bytes May 28 2025 17:32:51.
sql_binlog.h File 895 bytes May 28 2025 17:32:51.
sql_bitmap.h File 7845 bytes May 28 2025 17:32:51.
sql_bootstrap.h File 1812 bytes May 28 2025 17:32:51.
sql_cache.h File 21676 bytes May 28 2025 17:32:51.
sql_callback.h File 1542 bytes May 28 2025 17:32:51.
sql_class.h File 267375 bytes May 28 2025 17:32:51.
sql_cmd.h File 9421 bytes May 28 2025 17:32:51.
sql_connect.h File 4087 bytes May 28 2025 17:32:51.
sql_const.h File 11228 bytes May 28 2025 17:32:51.
sql_crypt.h File 1437 bytes May 28 2025 17:32:51.
sql_cte.h File 16533 bytes May 28 2025 17:32:51.
sql_cursor.h File 2316 bytes May 28 2025 17:32:51.
sql_db.h File 2440 bytes May 28 2025 17:32:51.
sql_debug.h File 5646 bytes May 28 2025 17:32:51.
sql_delete.h File 1343 bytes May 28 2025 17:32:51.
sql_derived.h File 1289 bytes May 28 2025 17:32:51.
sql_digest.h File 3819 bytes May 28 2025 17:32:51.
sql_digest_stream.h File 1567 bytes May 28 2025 17:32:51.
sql_do.h File 954 bytes May 28 2025 17:32:51.
sql_error.h File 39588 bytes May 28 2025 17:32:51.
sql_explain.h File 29020 bytes May 28 2025 17:32:51.
sql_expression_cache.h File 4359 bytes May 28 2025 17:32:51.
sql_get_diagnostics.h File 7867 bytes May 28 2025 17:32:51.
sql_handler.h File 2910 bytes May 28 2025 17:32:51.
sql_help.h File 995 bytes May 28 2025 17:32:51.
sql_hset.h File 3401 bytes May 28 2025 17:32:51.
sql_i_s.h File 8232 bytes May 28 2025 17:32:51.
sql_insert.h File 2651 bytes May 28 2025 17:32:51.
sql_join_cache.h File 48669 bytes May 28 2025 17:32:51.
sql_lex.h File 172548 bytes May 28 2025 17:32:51.
sql_lifo_buffer.h File 9676 bytes May 28 2025 17:32:51.
sql_limit.h File 3187 bytes May 28 2025 17:32:51.
sql_list.h File 22458 bytes May 28 2025 17:32:51.
sql_load.h File 1276 bytes May 28 2025 17:32:51.
sql_locale.h File 2701 bytes May 28 2025 17:32:51.
sql_manager.h File 960 bytes May 28 2025 17:32:51.
sql_mode.h File 6735 bytes May 28 2025 17:32:51.
sql_parse.h File 8636 bytes May 28 2025 17:32:51.
sql_partition.h File 12072 bytes May 28 2025 17:32:51.
sql_partition_admin.h File 5940 bytes May 28 2025 17:32:51.
sql_plist.h File 7732 bytes May 28 2025 17:32:51.
sql_plugin.h File 7549 bytes May 28 2025 17:32:51.
sql_plugin_compat.h File 2237 bytes May 28 2025 17:32:51.
sql_prepare.h File 11409 bytes May 28 2025 17:32:51.
sql_priv.h File 18593 bytes May 28 2025 17:32:51.
sql_profile.h File 7816 bytes May 28 2025 17:32:51.
sql_reload.h File 1036 bytes May 28 2025 17:32:51.
sql_rename.h File 982 bytes May 28 2025 17:32:51.
sql_repl.h File 3045 bytes May 28 2025 17:32:51.
sql_schema.h File 3303 bytes May 28 2025 17:32:51.
sql_select.h File 88898 bytes May 28 2025 17:32:51.
sql_sequence.h File 5180 bytes May 28 2025 17:32:51.
sql_servers.h File 1777 bytes May 28 2025 17:32:51.
sql_show.h File 9616 bytes May 28 2025 17:32:51.
sql_signal.h File 3362 bytes May 28 2025 17:32:51.
sql_sort.h File 21967 bytes May 28 2025 17:32:51.
sql_statistics.h File 12454 bytes May 28 2025 17:32:51.
sql_string.h File 39773 bytes May 28 2025 17:32:51.
sql_table.h File 9612 bytes May 28 2025 17:32:51.
sql_tablespace.h File 956 bytes May 28 2025 17:32:51.
sql_test.h File 1589 bytes May 28 2025 17:32:51.
sql_time.h File 8374 bytes May 28 2025 17:32:51.
sql_trigger.h File 12332 bytes May 28 2025 17:32:51.
sql_truncate.h File 2079 bytes May 28 2025 17:32:51.
sql_tvc.h File 2418 bytes May 28 2025 17:32:51.
sql_type.h File 295437 bytes May 28 2025 17:32:51.
sql_type_fixedbin.h File 64320 bytes May 28 2025 17:32:51.
sql_type_fixedbin_storage.h File 5467 bytes May 28 2025 17:32:51.
sql_type_geom.h File 19086 bytes May 28 2025 17:32:51.
sql_type_int.h File 10001 bytes May 28 2025 17:32:51.
sql_type_json.h File 6155 bytes May 28 2025 17:32:51.
sql_type_real.h File 1257 bytes May 28 2025 17:32:51.
sql_type_string.h File 1629 bytes May 28 2025 17:32:51.
sql_udf.h File 4850 bytes May 28 2025 17:32:51.
sql_union.h File 1064 bytes May 28 2025 17:32:51.
sql_update.h File 1923 bytes May 28 2025 17:32:51.
sql_view.h File 2470 bytes May 28 2025 17:32:51.
sql_window.h File 6814 bytes May 28 2025 17:32:51.
ssl_compat.h File 3147 bytes May 28 2025 17:32:51.
strfunc.h File 2275 bytes May 28 2025 17:32:51.
structs.h File 26379 bytes May 28 2025 17:32:51.
sys_vars_shared.h File 2729 bytes May 28 2025 17:32:51.
t_ctype.h File 5639 bytes May 28 2025 17:32:51.
table.h File 115741 bytes May 28 2025 17:32:51.
table_cache.h File 4232 bytes May 28 2025 17:32:51.
thr_alarm.h File 2932 bytes May 28 2025 17:32:51.
thr_lock.h File 7350 bytes May 28 2025 17:32:51.
thr_malloc.h File 1202 bytes May 28 2025 17:32:51.
thr_timer.h File 1563 bytes May 28 2025 17:32:51.
thread_cache.h File 5905 bytes May 28 2025 17:32:51.
threadpool.h File 4810 bytes May 28 2025 17:32:51.
threadpool_generic.h File 3969 bytes May 28 2025 17:32:51.
threadpool_winsockets.h File 2290 bytes May 28 2025 17:32:51.
transaction.h File 1466 bytes May 28 2025 17:32:51.
tzfile.h File 5014 bytes May 28 2025 17:32:51.
tztime.h File 3397 bytes May 28 2025 17:32:51.
uniques.h File 4217 bytes May 28 2025 17:32:51.
unireg.h File 7716 bytes May 28 2025 17:32:51.
vers_string.h File 2534 bytes May 28 2025 17:32:51.
violite.h File 10086 bytes May 28 2025 17:32:51.
waiting_threads.h File 4532 bytes May 28 2025 17:32:51.
welcome_copyright_notice.h File 1218 bytes May 28 2025 17:32:51.
win_tzname_data.h File 6506 bytes May 28 2025 17:32:51.
winservice.h File 1194 bytes May 28 2025 17:32:51.
wqueue.h File 1565 bytes May 28 2025 17:32:51.
wsrep.h File 3308 bytes May 28 2025 17:32:51.
wsrep_applier.h File 2703 bytes May 28 2025 17:32:51.
wsrep_binlog.h File 3441 bytes May 28 2025 17:32:51.
wsrep_client_service.h File 2560 bytes May 28 2025 17:32:51.
wsrep_client_state.h File 1566 bytes May 28 2025 17:32:51.
wsrep_condition_variable.h File 1484 bytes May 28 2025 17:32:51.
wsrep_high_priority_service.h File 4912 bytes May 28 2025 17:32:51.
wsrep_mutex.h File 1216 bytes May 28 2025 17:32:51.
wsrep_mysqld.h File 21138 bytes May 28 2025 17:32:51.
wsrep_mysqld_c.h File 1227 bytes May 28 2025 17:32:51.
wsrep_on.h File 1718 bytes May 28 2025 17:32:51.
wsrep_priv.h File 1634 bytes May 28 2025 17:32:51.
wsrep_schema.h File 4943 bytes May 28 2025 17:32:51.
wsrep_server_service.h File 3631 bytes May 28 2025 17:32:51.
wsrep_server_state.h File 2285 bytes May 28 2025 17:32:51.
wsrep_sst.h File 3951 bytes May 28 2025 17:32:51.
wsrep_storage_service.h File 1809 bytes May 28 2025 17:32:51.
wsrep_thd.h File 11160 bytes May 28 2025 17:32:51.
wsrep_trans_observer.h File 18119 bytes May 28 2025 17:32:51.
wsrep_types.h File 997 bytes May 28 2025 17:32:51.
wsrep_utils.h File 9290 bytes May 28 2025 17:32:51.
wsrep_var.h File 4607 bytes May 28 2025 17:32:51.
wsrep_xid.h File 1549 bytes May 28 2025 17:32:51.
xa.h File 1845 bytes May 28 2025 17:32:51.

Reading File: //usr//include/mysql/server/private//sql_string.h

#ifndef SQL_STRING_INCLUDED
#define SQL_STRING_INCLUDED

/*
   Copyright (c) 2000, 2013, Oracle and/or its affiliates.
   Copyright (c) 2008, 2020, MariaDB Corporation.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335  USA */

/* This file is originally from the mysql distribution. Coded by monty */

#ifdef USE_PRAGMA_INTERFACE
#pragma interface			/* gcc class implementation */
#endif

#include "m_ctype.h"                            /* my_charset_bin */
#include <my_sys.h>              /* alloc_root, my_free, my_realloc */
#include "m_string.h"                           /* TRASH */
#include "sql_list.h"

class String;
#ifdef MYSQL_SERVER
extern PSI_memory_key key_memory_String_value;
#define STRING_PSI_MEMORY_KEY key_memory_String_value
#else
#define STRING_PSI_MEMORY_KEY PSI_NOT_INSTRUMENTED
#endif

typedef struct st_io_cache IO_CACHE;
typedef struct st_mem_root MEM_ROOT;
#define ASSERT_LENGTH(A) DBUG_ASSERT(str_length + (uint32) (A) <= Alloced_length)

#include "pack.h"
class Binary_string;
int sortcmp(const Binary_string *s, const Binary_string *t, CHARSET_INFO *cs);
int stringcmp(const Binary_string *s, const Binary_string *t);
String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
inline uint32 copy_and_convert(char *to, size_t to_length, CHARSET_INFO *to_cs,
                               const char *from, size_t from_length,
                               CHARSET_INFO *from_cs, uint *errors)
{
  return my_convert(to, (uint)to_length, to_cs, from, (uint)from_length,
                    from_cs, errors);
}


class String_copy_status: protected MY_STRCOPY_STATUS
{
public:
  const char *source_end_pos() const
  { return m_source_end_pos; }
  const char *well_formed_error_pos() const
  { return m_well_formed_error_pos; }
};


class Well_formed_prefix_status: public String_copy_status
{
public:
  Well_formed_prefix_status(CHARSET_INFO *cs,
                            const char *str, const char *end, size_t nchars)
  { cs->well_formed_char_length(str, end, nchars, this); }
};


class Well_formed_prefix: public Well_formed_prefix_status
{
  const char *m_str; // The beginning of the string
public:
  Well_formed_prefix(CHARSET_INFO *cs, const char *str, const char *end,
                     size_t nchars)
   :Well_formed_prefix_status(cs, str, end, nchars), m_str(str)
  { }
  Well_formed_prefix(CHARSET_INFO *cs, const char *str, size_t length,
                     size_t nchars)
   :Well_formed_prefix_status(cs, str, str + length, nchars), m_str(str)
  { }
  Well_formed_prefix(CHARSET_INFO *cs, const char *str, size_t length)
   :Well_formed_prefix_status(cs, str, str + length, length), m_str(str)
  { }
  Well_formed_prefix(CHARSET_INFO *cs, LEX_CSTRING str, size_t nchars)
   :Well_formed_prefix_status(cs, str.str, str.str + str.length, nchars),
    m_str(str.str)
  { }
  size_t length() const { return m_source_end_pos - m_str; }
};


class String_copier: public String_copy_status,
                     protected MY_STRCONV_STATUS
{
public:
  const char *cannot_convert_error_pos() const
  { return m_cannot_convert_error_pos; }
  const char *most_important_error_pos() const
  {
    return well_formed_error_pos() ? well_formed_error_pos() :
                                     cannot_convert_error_pos();
  }
  /*
    Convert a string between character sets.
    "dstcs" and "srccs" cannot be &my_charset_bin.
  */
  size_t convert_fix(CHARSET_INFO *dstcs, char *dst, size_t dst_length,
                     CHARSET_INFO *srccs, const char *src, size_t src_length,
                     size_t nchars)
  {
    return my_convert_fix(dstcs, dst, dst_length,
                          srccs, src, src_length, nchars, this, this);
  }
  /*
     Copy a string. Fix bad bytes/characters to '?'.
  */
  uint well_formed_copy(CHARSET_INFO *to_cs, char *to, size_t to_length,
                        CHARSET_INFO *from_cs, const char *from,
                        size_t from_length, size_t nchars);
  // Same as above, but without the "nchars" limit.
  uint well_formed_copy(CHARSET_INFO *to_cs, char *to, size_t to_length,
                        CHARSET_INFO *from_cs, const char *from,
                        size_t from_length)
  {
    return well_formed_copy(to_cs, to, to_length,
                            from_cs, from, from_length,
                            from_length /* No limit on "nchars"*/);
  }
};


size_t my_copy_with_hex_escaping(CHARSET_INFO *cs,
                                 char *dst, size_t dstlen,
                                 const char *src, size_t srclen);
uint convert_to_printable(char *to, size_t to_len,
                          const char *from, size_t from_len,
                          CHARSET_INFO *from_cs, size_t nbytes= 0);
size_t convert_to_printable_required_length(uint len);


class Charset
{
  CHARSET_INFO *m_charset;
public:
  Charset() :m_charset(&my_charset_bin) { }
  Charset(CHARSET_INFO *cs) :m_charset(cs) { }

  CHARSET_INFO *charset() const { return m_charset; }
  bool use_mb() const { return m_charset->use_mb(); }
  uint mbminlen() const { return m_charset->mbminlen; }
  uint mbmaxlen() const { return m_charset->mbmaxlen; }
  bool is_good_for_ft() const
  {
    // Binary and UCS2/UTF16/UTF32 are not supported
    return m_charset != &my_charset_bin && m_charset->mbminlen == 1;
  }

  size_t numchars(const char *str, const char *end) const
  {
    return m_charset->numchars(str, end);
  }
  size_t lengthsp(const char *str, size_t length) const
  {
    return m_charset->lengthsp(str, length);
  }
  size_t charpos(const char *str, const char *end, size_t pos) const
  {
    return m_charset->charpos(str, end, pos);
  }
  void set_charset(CHARSET_INFO *charset_arg)
  {
    m_charset= charset_arg;
  }
  void set_charset(const Charset &other)
  {
    m_charset= other.m_charset;
  }
  void swap(Charset &other)
  {
    swap_variables(CHARSET_INFO*, m_charset, other.m_charset);
  }
  bool same_encoding(const Charset &other) const
  {
    return my_charset_same(m_charset, other.m_charset);
  }
  /*
    Collation name without the character set name.
    For example, in case of "latin1_swedish_ci",
    this method returns "_swedish_ci".
  */
  LEX_CSTRING collation_specific_name() const;
  bool encoding_allows_reinterpret_as(CHARSET_INFO *cs) const;
  bool eq_collation_specific_names(CHARSET_INFO *cs) const;
  bool can_have_collate_clause() const
  {
    return m_charset != &my_charset_bin;
  }

  /*
    The MariaDB version when the last collation change happened,
    e.g. due to a bug fix. See functions below.
  */
  static ulong latest_mariadb_version_with_collation_change()
  {
    return 110002;
  }

  /*
    Check if the collation with the given ID changed its order
    since the given MariaDB version.
  */
  static bool collation_changed_order(ulong mysql_version, uint cs_number)
  {
    if ((mysql_version < 50048 &&
           (cs_number == 11 || /* ascii_general_ci - bug #29499, bug #27562 */
            cs_number == 41 || /* latin7_general_ci - bug #29461 */
            cs_number == 42 || /* latin7_general_cs - bug #29461 */
            cs_number == 20 || /* latin7_estonian_cs - bug #29461 */
            cs_number == 21 || /* latin2_hungarian_ci - bug #29461 */
            cs_number == 22 || /* koi8u_general_ci - bug #29461 */
            cs_number == 23 || /* cp1251_ukrainian_ci - bug #29461 */
            cs_number == 26)) || /* cp1250_general_ci - bug #29461 */
           (mysql_version < 50124 &&
           (cs_number == 33 || /* utf8mb3_general_ci - bug #27877 */
            cs_number == 35))) /* ucs2_general_ci - bug #27877 */
        return true;

    if (cs_number == 159 && /* ucs2_general_mysql500_ci - MDEV-30746 */
        ((mysql_version >= 100400 && mysql_version < 100429) ||
         (mysql_version >= 100500 && mysql_version < 100520) ||
         (mysql_version >= 100600 && mysql_version < 100613) ||
         (mysql_version >= 100700 && mysql_version < 100708) ||
         (mysql_version >= 100800 && mysql_version < 100808) ||
         (mysql_version >= 100900 && mysql_version < 100906) ||
         (mysql_version >= 101000 && mysql_version < 101004) ||
         (mysql_version >= 101100 && mysql_version < 101103) ||
         (mysql_version >= 110000 && mysql_version < 110002)))
      return true;
    return false;
  }

  /**
     Check if a collation has changed ID since the given version.
     Return the new ID.

     @param mysql_version
     @param cs_number     - collation ID

     @retval the new collation ID (or cs_number, if no change)
  */

  static uint upgrade_collation_id(ulong mysql_version, uint cs_number)
  {
    if (mysql_version >= 50300 && mysql_version <= 50399)
    {
      switch (cs_number) {
      case 149: return MY_PAGE2_COLLATION_ID_UCS2;   // ucs2_crotian_ci
      case 213: return MY_PAGE2_COLLATION_ID_UTF8;   // utf8_crotian_ci
      }
    }
    if ((mysql_version >= 50500 && mysql_version <= 50599) ||
        (mysql_version >= 100000 && mysql_version <= 100005))
    {
      switch (cs_number) {
      case 149: return MY_PAGE2_COLLATION_ID_UCS2;   // ucs2_crotian_ci
      case 213: return MY_PAGE2_COLLATION_ID_UTF8;   // utf8_crotian_ci
      case 214: return MY_PAGE2_COLLATION_ID_UTF32;  // utf32_croatian_ci
      case 215: return MY_PAGE2_COLLATION_ID_UTF16;  // utf16_croatian_ci
      case 245: return MY_PAGE2_COLLATION_ID_UTF8MB4;// utf8mb4_croatian_ci
      }
    }
    return cs_number;
  }

};


/**
   Storage for strings with both length and allocated length.
   Automatically grows on demand.
*/

class Binary_string: public Sql_alloc
{
protected:
  char *Ptr;
  uint32 str_length, Alloced_length, extra_alloc;
  bool alloced, thread_specific;
  void init_private_data()
  {
    Ptr= 0;
    Alloced_length= extra_alloc= str_length= 0;
    alloced= thread_specific= false;
  }
  inline void free_buffer()
  {
    if (alloced)
    {
      alloced=0;
      my_free(Ptr);
    }
  }
public:
  Binary_string()
  {
    init_private_data();
  }
  explicit Binary_string(size_t length_arg)
  {
    init_private_data();
    (void) real_alloc(length_arg);
  }
  /*
    NOTE: If one intend to use the c_ptr() method, the following two
    contructors need the size of memory for STR to be at least LEN+1 (to make
    room for zero termination).
  */
  Binary_string(const char *str, size_t len)
  {
    Ptr= (char*) str;
    str_length= (uint32) len;
    Alloced_length= 0;                          /* Memory cannot be written to */
    extra_alloc= 0;
    alloced= thread_specific= 0;
  }
  Binary_string(char *str, size_t len)
  {
    Ptr= str;
    str_length= Alloced_length= (uint32) len;
    extra_alloc= 0;
    alloced= thread_specific= 0;
  }
  explicit Binary_string(const Binary_string &str)
  {
    Ptr= str.Ptr;
    str_length= str.str_length;
    Alloced_length= str.Alloced_length;
    extra_alloc= 0;
    alloced= thread_specific= 0;
  }

  ~Binary_string()
  {
    free();
  }

  inline uint32 length() const { return str_length;}
  inline char& operator [] (size_t i) const { return Ptr[i]; }
  inline void length(size_t len) { str_length=(uint32)len ; }
  inline bool is_empty() const { return (str_length == 0); }
  inline const char *ptr() const { return Ptr; }
  inline const char *end() const { return Ptr + str_length; }
  bool has_8bit_bytes() const
  {
    for (const char *c= ptr(), *c_end= end(); c < c_end; c++)
    {
      if (!my_isascii(*c))
        return true;
    }
    return false;
  }

  bool bin_eq(const Binary_string *other) const
  {
    return length() == other->length() &&
           !memcmp(ptr(), other->ptr(), length());
  }

  /*
    PMG 2004.11.12
    This is a method that works the same as perl's "chop". It simply
    drops the last character of a string. This is useful in the case
    of the federated storage handler where I'm building a unknown
    number, list of values and fields to be used in a sql insert
    statement to be run on the remote server, and have a comma after each.
    When the list is complete, I "chop" off the trailing comma

    ex.
      String stringobj;
      stringobj.append("VALUES ('foo', 'fi', 'fo',");
      stringobj.chop();
      stringobj.append(")");

    In this case, the value of string was:

    VALUES ('foo', 'fi', 'fo',
    VALUES ('foo', 'fi', 'fo'
    VALUES ('foo', 'fi', 'fo')
  */
  inline void chop()
  {
    if (str_length)
    {
      str_length--;
      Ptr[str_length]= '\0';
      DBUG_ASSERT(strlen(Ptr) == str_length);
    }
  }

  // Returns offset to substring or -1
  int strstr(const Binary_string &search, uint32 offset=0) const;
  int strstr(const char *search, uint32 search_length, uint32 offset=0) const;
  // Returns offset to substring or -1
  int strrstr(const Binary_string &search, uint32 offset=0) const;

  /*
    The following append operations do not extend the strings and in production
    mode do NOT check that alloced memory!
    q_*** methods writes values of parameters itself
    qs_*** methods writes string representation of value
  */
  void q_append(const char c)
  {
    ASSERT_LENGTH(1);
    Ptr[str_length++] = c;
  }
  void q_append2b(const uint32 n)
  {
    ASSERT_LENGTH(2);
    int2store(Ptr + str_length, n);
    str_length += 2;
  }
  void q_append(const uint32 n)
  {
    ASSERT_LENGTH(4);
    int4store(Ptr + str_length, n);
    str_length += 4;
  }
  void q_append(double d)
  {
    ASSERT_LENGTH(8);
    float8store(Ptr + str_length, d);
    str_length += 8;
  }
  void q_append(double *d)
  {
    ASSERT_LENGTH(8);
    float8store(Ptr + str_length, *d);
    str_length += 8;
  }
  /*
    Append a wide character.
    The caller must have allocated at least cs->mbmaxlen bytes.
  */
  int q_append_wc(my_wc_t wc, CHARSET_INFO *cs)
  {
    int mblen;
    if ((mblen= cs->cset->wc_mb(cs, wc,
                                (uchar *) end(),
                                (uchar *) end() + cs->mbmaxlen)) > 0)
      str_length+= (uint32) mblen;
    return mblen;
  }
  void q_append(const char *data, size_t data_len)
  {
    ASSERT_LENGTH(data_len);
    if (data_len)
      memcpy(Ptr + str_length, data, data_len);
    DBUG_ASSERT(str_length <= UINT_MAX32 - data_len);
    str_length += (uint)data_len;
  }
  void q_append(const LEX_CSTRING *ls)
  {
    DBUG_ASSERT(ls->length < UINT_MAX32 &&
                ((ls->length == 0 && !ls->str) ||
                 ls->length == strlen(ls->str)));
    q_append(ls->str, (uint32) ls->length);
  }

  void write_at_position(uint32 position, uint32 value)
  {
    DBUG_ASSERT(str_length >= position + 4);
    int4store(Ptr + position,value);
  }

  void qs_append(const LEX_CSTRING *ls)
  {
    DBUG_ASSERT(ls->length < UINT_MAX32 &&
                ((ls->length == 0 && !ls->str) ||
                 ls->length == strlen(ls->str)));
    qs_append(ls->str, (uint32)ls->length);
  }
  void qs_append(const char *str, size_t len);
  void qs_append_hex(const char *str, uint32 len);
  void qs_append_hex_uint32(uint32 num);
  void qs_append(double d);
  void qs_append(const double *d);
  inline void qs_append(const char c)
  {
    ASSERT_LENGTH(1);
    Ptr[str_length]= c;
    str_length++;
  }
  void qs_append(int i);
  void qs_append(uint i)
  {
    qs_append((ulonglong)i);
  }
  void qs_append(ulong i)
  {
    qs_append((ulonglong)i);
  }
  void qs_append(ulonglong i);
  void qs_append(longlong i, int radix)
  {
    ASSERT_LENGTH(22);
    char *buff= Ptr + str_length;
    char *end= ll2str(i, buff, radix, 0);
    str_length+= (uint32) (end-buff);
  }

  /* Mark variable thread specific it it's not allocated already */
  inline void set_thread_specific()
  {
    if (!alloced)
      thread_specific= 1;
  }
  bool is_alloced() const { return alloced; }
  inline uint32 alloced_length() const { return Alloced_length;}
  inline uint32 extra_allocation() const { return extra_alloc;}
  inline void extra_allocation(size_t len) { extra_alloc= (uint32)len; }
  inline void mark_as_const() { Alloced_length= 0;}

  inline bool uses_buffer_owned_by(const Binary_string *s) const
  {
    return (s->alloced && Ptr >= s->Ptr && Ptr < s->Ptr + s->Alloced_length);
  }

  /* Swap two string objects. Efficient way to exchange data without memcpy. */
  void swap(Binary_string &s)
  {
    swap_variables(char *, Ptr, s.Ptr);
    swap_variables(uint32, str_length, s.str_length);
    swap_variables(uint32, Alloced_length, s.Alloced_length);
    swap_variables(bool, alloced, s.alloced);
  }

  /**
     Points the internal buffer to the supplied one. The old buffer is freed.
     @param str Pointer to the new buffer.
     @param arg_length Length of the new buffer in characters, excluding any
            null character.
     @note The new buffer will not be null terminated.
  */
  void set_alloced(char *str, size_t length, size_t alloced_length)
  {
    free_buffer();
    Ptr= str;
    str_length= (uint32) length;
    DBUG_ASSERT(alloced_length < UINT_MAX32);
    Alloced_length= (uint32) alloced_length;
  }
  inline void set(char *str, size_t arg_length)
  {
    set_alloced(str, arg_length, arg_length);
  }
  inline void set(const char *str, size_t length)
  {
    free_buffer();
    Ptr= (char*) str;
    str_length= (uint32) length;
    Alloced_length= 0;
  }

  void set(Binary_string &str, size_t offset, size_t length)
  {
    DBUG_ASSERT(&str != this);
    free_buffer();
    Ptr= str.Ptr + offset;
    str_length= (uint32) length;
    Alloced_length= 0;
    if (str.Alloced_length)
      Alloced_length= (uint32) (str.Alloced_length - offset);
  }
  LEX_CSTRING to_lex_cstring() const
  {
    LEX_CSTRING tmp= {Ptr, str_length};
    return tmp;
  }
  inline LEX_CSTRING *get_value(LEX_CSTRING *res) const
  {
    res->str=    Ptr;
    res->length= str_length;
    return res;
  }

  /* Take over handling of buffer from some other object */
  void reset(char *ptr_arg, size_t length_arg, size_t alloced_length_arg)
  {
    set_alloced(ptr_arg, length_arg, alloced_length_arg);
    alloced= ptr_arg != 0;
  }

  /* Forget about the buffer, let some other object handle it */
  char *release()
  {
    char *old= Ptr;
    init_private_data();
    return old;
  }

  /*
    This is used to set a new buffer for String.
    However if the String already has an allocated buffer, it will
    keep that one.
    It's not to be used to set the value or length of the string.
  */
  inline void set_buffer_if_not_allocated(char *str, size_t arg_length)
  {
    if (!alloced)
    {
      /*
        Following should really set str_length= 0, but some code may
        depend on that the String length is same as buffer length.
      */
      Ptr= str;
      str_length= Alloced_length= (uint32) arg_length;
    }
    /* One should set str_length before using it */
    MEM_UNDEFINED(&str_length, sizeof(str_length));
  }

  inline Binary_string& operator=(const Binary_string &s)
  {
    if (&s != this)
    {
      /*
        It is forbidden to do assignments like
        some_string = substring_of_that_string
      */
      DBUG_ASSERT(!s.uses_buffer_owned_by(this));
      set_alloced((char *) s.Ptr, s.str_length, s.Alloced_length);
    }
    return *this;
  }

  bool set_hex(ulonglong num);
  bool set_hex(const char *str, uint32 len);
  bool set_fcvt(double num, uint decimals);

  bool copy();                                  // Alloc string if not alloced
  bool copy(const Binary_string &s);            // Allocate new string
  bool copy(const char *s, size_t arg_length);	// Allocate new string
  bool copy_or_move(const char *s,size_t arg_length);

  /**
    Convert a string to a printable format.
    All non-convertable and control characters are replaced to 5-character
    sequences '\hhhh'.
  */
  bool copy_printable_hhhh(CHARSET_INFO *to_cs,
                           CHARSET_INFO *from_cs,
                           const char *from, size_t from_length);

  bool append_ulonglong(ulonglong val);
  bool append_longlong(longlong val);

  bool append(const char *s, size_t size)
  {
    if (!size)
      return false;
    if (realloc_with_extra_if_needed(str_length + size))
      return true;
    q_append(s, size);
    return false;
  }
  bool append(const LEX_CSTRING &s)
  {
    return append(s.str, s.length);
  }
  bool append(const Binary_string &s)
  {
    return append(s.ptr(), s.length());
  }
  bool append(IO_CACHE* file, uint32 arg_length);

  inline bool append_char(char chr)
  {
    if (str_length < Alloced_length)
    {
      Ptr[str_length++]= chr;
    }
    else
    {
      if (unlikely(realloc_with_extra(str_length + 1)))
	return true;
      Ptr[str_length++]= chr;
    }
    return false;
  }
  bool append_hex(const char *src, uint32 srclen)
  {
    for (const char *src_end= src + srclen ; src != src_end ; src++)
    {
      if (unlikely(append_char(_dig_vec_lower[((uchar) *src) >> 4])) ||
          unlikely(append_char(_dig_vec_lower[((uchar) *src) & 0x0F])))
        return true;
    }
    return false;
  }
  bool append_hex_uint32(uint32 num)
  {
    if (reserve(8))
      return true;
    qs_append_hex_uint32(num);
    return false;
  }
  bool append_with_step(const char *s, uint32 arg_length, uint32 step_alloc)
  {
    uint32 new_length= arg_length + str_length;
    if (new_length > Alloced_length &&
        unlikely(realloc(new_length + step_alloc)))
      return true;
    q_append(s, arg_length);
    return false;
  }

  inline char *c_ptr()
  {
    if (unlikely(!Ptr))
      return (char*) "";
    /*
      Here we assume that any buffer used to initalize String has
      an end \0 or have at least an accessable character at end.
      This is to handle the case of String("Hello",5) and
      String("hello",5) efficiently.

      We have two options here. To test for !Alloced_length or !alloced.
      Using "Alloced_length" is slightly safer so that we do not read
      from potentially unintialized memory (normally not dangerous but
      may give warnings in valgrind), but "alloced" is safer as there
      are less change to get memory loss from code that is using
      String((char*), length) or String.set((char*), length) and does
      not free things properly (and there is several places in the code
      where this happens and it is hard to find out if any of these will call
      c_ptr().
    */
    if (unlikely(!alloced && !Ptr[str_length]))
      return Ptr;
    if (str_length < Alloced_length)
    {
      Ptr[str_length]=0;
      return Ptr;
    }
    (void) realloc(str_length);               /* This will add end \0 */
    return Ptr;
  }
  /*
    One should use c_ptr() instead for most cases. This will be deleted soon,
    kept for compatiblity.
  */
  inline char *c_ptr_quick()
  {
    return c_ptr_safe();
  }
  /*
    This is to be used only in the case when one cannot use c_ptr().
    The cases are:
    - When one initializes String with an external buffer and length and
      buffer[length] could be uninitalized when c_ptr() is called.
    - When valgrind gives warnings about uninitialized memory with c_ptr().
  */
  inline char *c_ptr_safe()
  {
    if (Ptr && str_length < Alloced_length)
      Ptr[str_length]=0;
    else
      (void) realloc(str_length);
    return Ptr;
  }

  inline void free()
  {
    free_buffer();
    /*
      We have to clear the values as some Strings, like in Field, are
      reused after free(). Because of this we cannot use MEM_UNDEFINED() here.
    */
    Ptr= 0;
    str_length= 0;
    Alloced_length= extra_alloc= 0;
  }

  inline bool alloc(size_t arg_length)
  {
    /*
      Allocate if we need more space or if we don't have done any
      allocation yet (we don't want to have Ptr to be NULL for empty strings).

      Note that if arg_length == Alloced_length then we don't allocate.
      This ensures we don't do any extra allocations in protocol and String:int,
      but the string will not be automatically null terminated if c_ptr() is not
      called.
    */
    if (arg_length <= Alloced_length && Alloced_length)
      return 0;
    return real_alloc(arg_length);
  }
  bool real_alloc(size_t arg_length);  // Empties old string
  bool realloc_raw(size_t arg_length);
  bool realloc(size_t arg_length)
  {
    if (realloc_raw(arg_length+1))
      return TRUE;
    Ptr[arg_length]= 0; // This make other funcs shorter
    return FALSE;
  }
  bool realloc_with_extra(size_t arg_length)
  {
    if (extra_alloc < 4096)
      extra_alloc= extra_alloc*2+128;
    if (realloc_raw(arg_length + extra_alloc))
      return TRUE;
    Ptr[arg_length]=0;        // This make other funcs shorter
    return FALSE;
  }
  bool realloc_with_extra_if_needed(size_t arg_length)
  {
    if (arg_length < Alloced_length)
    {
      Ptr[arg_length]=0; // behave as if realloc was called.
      return 0;
    }
    return realloc_with_extra(arg_length);
  }
  // Shrink the buffer, but only if it is allocated on the heap.
  void shrink(size_t arg_length);

  void move(Binary_string &s)
  {
    set_alloced(s.Ptr, s.str_length, s.Alloced_length);
    extra_alloc= s.extra_alloc;
    alloced= s.alloced;
    thread_specific= s.thread_specific;
    s.alloced= 0;
  }
  bool fill(size_t max_length,char fill);
  /*
    Replace substring with string
    If wrong parameter or not enough memory, do nothing
  */
  bool replace(uint32 offset,uint32 arg_length, const char *to, uint32 length);
  bool replace(uint32 offset,uint32 arg_length, const Binary_string &to)
  {
    return replace(offset,arg_length,to.ptr(),to.length());
  }

  int reserve(size_t space_needed)
  {
    DBUG_ASSERT((ulonglong) str_length + space_needed < UINT_MAX32);
    return realloc(str_length + space_needed);
  }
  int reserve(size_t space_needed, size_t grow_by);

  inline char *prep_append(uint32 arg_length, uint32 step_alloc)
  {
    uint32 new_length= arg_length + str_length;
    if (new_length > Alloced_length)
    {
      if (unlikely(realloc(new_length + step_alloc)))
        return 0;
    }
    uint32 old_length= str_length;
    str_length+= arg_length;
    return Ptr + old_length;                  // Area to use
  }


  void q_net_store_length(ulonglong length)
  {
    DBUG_ASSERT(Alloced_length >= (str_length + net_length_size(length)));
    char *pos= (char *) net_store_length((uchar *)(Ptr + str_length), length);
    str_length= uint32(pos - Ptr);
  }
  void q_net_store_data(const uchar *from, size_t length)
  {
    DBUG_ASSERT(length < UINT_MAX32);
    DBUG_ASSERT(Alloced_length >= (str_length + length +
                                   net_length_size(length)));
    q_net_store_length(length);
    q_append((const char *)from, (uint32) length);
  }
};


class String: public Charset, public Binary_string
{
public:
  String() = default;
  String(size_t length_arg) :Binary_string(length_arg)
  { }
  /*
    NOTE: If one intend to use the c_ptr() method, the following two
    contructors need the size of memory for STR to be at least LEN+1 (to make
    room for zero termination).
  */
  String(const char *str, size_t len, CHARSET_INFO *cs)
   :Charset(cs), Binary_string(str, len)
  { }
  String(char *str, size_t len, CHARSET_INFO *cs)
   :Charset(cs), Binary_string(str, len)
  { }
  String(const String &str) = default;
  String(String &&str) noexcept
   :Charset(std::move(str)), Binary_string(std::move(str)){}

  void set(String &str,size_t offset,size_t arg_length)
  {
    Binary_string::set(str, offset, arg_length);
    set_charset(str);
  }
  inline void set(char *str,size_t arg_length, CHARSET_INFO *cs)
  {
    Binary_string::set(str, arg_length);
    set_charset(cs);
  }
  inline void set(const char *str,size_t arg_length, CHARSET_INFO *cs)
  {
    Binary_string::set(str, arg_length);
    set_charset(cs);
  }
  bool set_ascii(const char *str, size_t arg_length);
  inline void set_buffer_if_not_allocated(char *str,size_t arg_length,
                                          CHARSET_INFO *cs)
  {
    Binary_string::set_buffer_if_not_allocated(str, arg_length);
    set_charset(cs);
  }
  bool set_int(longlong num, bool unsigned_flag, CHARSET_INFO *cs);
  bool set(int num, CHARSET_INFO *cs) { return set_int(num, false, cs); }
  bool set(uint num, CHARSET_INFO *cs) { return set_int(num, true, cs); }
  bool set(long num, CHARSET_INFO *cs) { return set_int(num, false, cs); }
  bool set(ulong num, CHARSET_INFO *cs) { return set_int(num, true, cs); }
  bool set(longlong num, CHARSET_INFO *cs) { return set_int(num, false, cs); }
  bool set(ulonglong num, CHARSET_INFO *cs) { return set_int((longlong)num, true, cs); }
  bool set_real(double num,uint decimals, CHARSET_INFO *cs);
  bool set_fcvt(double num, uint decimals)
  {
    set_charset(&my_charset_latin1);
    return Binary_string::set_fcvt(num, decimals);
  }

  bool set_hex(ulonglong num)
  {
    set_charset(&my_charset_latin1);
    return Binary_string::set_hex(num);
  }
  bool set_hex(const char *str, uint32 len)
  {
    set_charset(&my_charset_latin1);
    return Binary_string::set_hex(str, len);
  }

  /* Take over handling of buffer from some other object */
  void reset(char *ptr_arg, size_t length_arg, size_t alloced_length_arg,
             CHARSET_INFO *cs)
  {
    Binary_string::reset(ptr_arg, length_arg, alloced_length_arg);
    set_charset(cs);
  }

  inline String& operator = (const String &s)
  {
    if (&s != this)
    {
      set_charset(s);
      Binary_string::operator=(s);
    }
    return *this;
  }

  bool copy()
  {
    return Binary_string::copy();
  }
  bool copy(const String &s)
  {
    set_charset(s);
    return Binary_string::copy(s);
  }
  bool copy(const char *s, size_t arg_length, CHARSET_INFO *cs)
  {
    set_charset(cs);
    return Binary_string::copy(s, arg_length);
  }
  bool copy_or_move(const char *s, size_t arg_length, CHARSET_INFO *cs)
  {
    set_charset(cs);
    return Binary_string::copy_or_move(s, arg_length);
  }
  static bool needs_conversion(size_t arg_length,
  			       CHARSET_INFO *cs_from, CHARSET_INFO *cs_to,
			       uint32 *offset);
  static bool needs_conversion_on_storage(size_t arg_length,
                                          CHARSET_INFO *cs_from,
                                          CHARSET_INFO *cs_to);
  bool copy_aligned(const char *s, size_t arg_length, size_t offset,
		    CHARSET_INFO *cs);
  bool set_or_copy_aligned(const char *s, size_t arg_length, CHARSET_INFO *cs);
  bool can_be_safely_converted_to(CHARSET_INFO *tocs) const
  {
    if (charset() == &my_charset_bin)
      return Well_formed_prefix(tocs, ptr(), length()).length() == length();
    String try_val;
    uint try_conv_error= 0;
    try_val.copy(ptr(), length(), charset(), tocs, &try_conv_error);
    return try_conv_error == 0;
  }
  bool copy(const char*s, size_t arg_length, CHARSET_INFO *csfrom,
	    CHARSET_INFO *csto, uint *errors);
  bool copy(const String *str, CHARSET_INFO *tocs, uint *errors)
  {
    return copy(str->ptr(), str->length(), str->charset(), tocs, errors);
  }
  bool copy(CHARSET_INFO *tocs,
            CHARSET_INFO *fromcs, const char *src, size_t src_length,
            size_t nchars, String_copier *copier)
  {
    if (unlikely(alloc(tocs->mbmaxlen * src_length)))
      return true;
    str_length= copier->well_formed_copy(tocs, Ptr, alloced_length(),
                                         fromcs, src, (uint) src_length,
                                         (uint) nchars);
    set_charset(tocs);
    return false;
  }
  // Append without character set conversion
  bool append(const String &s)
  {
    return Binary_string::append(s);
  }
  inline bool append(char chr)
  {
    return Binary_string::append_char(chr);
  }
  bool append_hex(const char *src, uint32 srclen)
  {
    return Binary_string::append_hex(src, srclen);
  }
  bool append_hex(const uchar *src, uint32 srclen)
  {
    return Binary_string::append_hex((const char*)src, srclen);
  }
  bool append_introducer_and_hex(const String *str)
  {
    return
      append('_')   ||
      append(str->charset()->cs_name) ||
      append(STRING_WITH_LEN(" 0x")) ||
      append_hex(str->ptr(), (uint32) str->length());
  }
  bool append(IO_CACHE* file, uint32 arg_length)
  {
    return Binary_string::append(file, arg_length);
  }
  inline bool append(const char *s, uint32 arg_length, uint32 step_alloc)
  {
    return append_with_step(s, arg_length, step_alloc);
  }

  // Append with optional character set conversion from ASCII (e.g. to UCS2)
  bool append(const LEX_STRING *ls)
  {
    DBUG_ASSERT(ls->length < UINT_MAX32 &&
                ((ls->length == 0 && !ls->str) ||
                 ls->length == strlen(ls->str)));
    return append(ls->str, (uint32) ls->length);
  }
  bool append(const LEX_CSTRING *ls)
  {
    DBUG_ASSERT(ls->length < UINT_MAX32 &&
                ((ls->length == 0 && !ls->str) ||
                 ls->length == strlen(ls->str)));
    return append(ls->str, (uint32) ls->length);
  }
  bool append(const LEX_CSTRING &ls)
  {
    return append(&ls);
  }
  bool append_name_value(const LEX_CSTRING &name,
                         const LEX_CSTRING &value,
                         uchar quot= '\0')
  {
    return
      append(name) ||
      append('=') ||
      (quot && append(quot)) ||
      append(value) ||
      (quot && append(quot));
  }
  bool append(const char *s, size_t size);
  bool append_parenthesized(long nr, int radix= 10);

  // Append with optional character set conversion from cs to charset()
  bool append(const char *s, size_t arg_length, CHARSET_INFO *cs);
  bool append(const LEX_CSTRING &s, CHARSET_INFO *cs)
  {
    return append(s.str, s.length, cs);
  }

  // Append a wide character
  bool append_wc(my_wc_t wc)
  {
    if (reserve(mbmaxlen()))
      return true;
    int mblen= q_append_wc(wc, charset());
    if (mblen > 0)
      return false;
    else if (mblen == MY_CS_ILUNI && wc != '?')
      return q_append_wc('?', charset()) <= 0;
    return true;
  }

  // Append a number with zero prefilling
  bool append_zerofill(uint num, uint width)
  {
    static const char zeros[15]= "00000000000000";
    char intbuff[15];
    uint length= (uint) (int10_to_str(num, intbuff, 10) - intbuff);
    if (length < width &&
        append(zeros, width - length, &my_charset_latin1))
      return true;
    return append(intbuff, length, &my_charset_latin1);
  }

  /*
    Append a bitmask in an uint32 with a translation into a
    C-style human readable representation, e.g.:
      0x05 -> "(flag04|flag01)"

    @param flags  - the flags to translate
    @param names  - an array of flag names
    @param count  - the number of available elements in "names"
  */
  bool append_flag32_names(uint32 flags, LEX_CSTRING names[], size_t count)
  {
    bool added= false;
    if (flags && append('('))
      return true;
    for (ulong i= 0; i <= 31; i++)
    {
      ulong bit= 31 - i;
      if (flags & (1 << bit))
      {
        if (added && append('|'))
          return true;
        if (bit < count ? append(names[bit]) : append('?'))
          return true;
        added= true;
      }
    }
    if (flags && append(')'))
      return true;
    return false;
  }

  void strip_sp();
  friend String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
  friend class Field;
  uint32 numchars() const
  {
    return (uint32) Charset::numchars(ptr(), end());
  }
  int charpos(longlong i, uint32 offset=0)
  {
    if (i <= 0)
      return (int) i;
    return (int) Charset::charpos(ptr() + offset, end(), (size_t) i);
  }
  size_t lengthsp() const
  {
    return Charset::lengthsp(Ptr, str_length);
  }

  void print(String *to) const;
  void print_with_conversion(String *to, CHARSET_INFO *cs) const;
  void print(String *to, CHARSET_INFO *cs) const
  {
    if (my_charset_same(charset(), cs))
      print(to);
    else
      print_with_conversion(to, cs);
  }

  static my_wc_t escaped_wc_for_single_quote(my_wc_t ch)
  {
    switch (ch)
    {
    case '\\':   return '\\';
    case '\0':   return '0';
    case '\'':   return '\'';
    case '\n':   return 'n';
    case '\r':   return 'r';
    case '\032': return 'Z';
    }
    return 0;
  }

  // Append for single quote using mb_wc/wc_mb Unicode conversion
  bool append_for_single_quote_using_mb_wc(const char *str, size_t length,
                                           CHARSET_INFO *cs);

  // Append for single quote with optional mb_wc/wc_mb conversion
  bool append_for_single_quote_opt_convert(const char *str,
                                           size_t length,
                                           CHARSET_INFO *cs)
  {
    return charset() == &my_charset_bin || cs == &my_charset_bin  ||
           my_charset_same(charset(), cs) ?
           append_for_single_quote(str, length) :
           append_for_single_quote_using_mb_wc(str, length, cs);
  }

  bool append_for_single_quote_opt_convert(const String &str)
  {
    return append_for_single_quote_opt_convert(str.ptr(),
                                               str.length(),
                                               str.charset());
  }

  bool append_for_single_quote(const char *st, size_t len);
  bool append_for_single_quote(const String *s)
  {
    return append_for_single_quote(s->ptr(), s->length());
  }

  void swap(String &s)
  {
    Charset::swap(s);
    Binary_string::swap(s);
  }

  uint well_formed_length() const
  {
    return (uint) Well_formed_prefix(charset(), ptr(), length()).length();
  }
  bool is_ascii() const
  {
    if (length() == 0)
      return TRUE;
    if (charset()->mbminlen > 1)
      return FALSE;
    return !has_8bit_bytes();
  }
  bool eq(const String *other, CHARSET_INFO *cs) const
  {
    return !sortcmp(this, other, cs);
  }
private:
  bool append_semi_hex(const char *s, uint len, CHARSET_INFO *cs);
};


// The following class is a backport from MySQL 5.6:
/**
  String class wrapper with a preallocated buffer of size buff_sz

  This class allows to replace sequences of:
     char buff[12345];
     String str(buff, sizeof(buff));
     str.length(0);
  with a simple equivalent declaration:
     StringBuffer<12345> str;
*/

template<size_t buff_sz>
class StringBuffer : public String
{
  char buff[buff_sz];

public:
  StringBuffer() : String(buff, buff_sz, &my_charset_bin) { length(0); }
  explicit StringBuffer(CHARSET_INFO *cs) : String(buff, buff_sz, cs)
  {
    length(0);
  }
  void set_buffer_if_not_allocated(CHARSET_INFO *cs)
  {
    if (!is_alloced())
    {
      Ptr= buff;
      Alloced_length= (uint32) buff_sz;
    }
    str_length= 0;                          /* Safety, not required */
    /* One should set str_length before using it */
    MEM_UNDEFINED(&str_length, sizeof(str_length));
    set_charset(cs);
  }
};


template<size_t buff_sz>
class BinaryStringBuffer : public Binary_string
{
  char buff[buff_sz];
public:
  BinaryStringBuffer() : Binary_string(buff, buff_sz) { length(0); }
};

static inline bool check_if_only_end_space(CHARSET_INFO *cs,
                                           const char *str,
                                           const char *end)
{
  return str + cs->scan(str, end, MY_SEQ_SPACES) == end;
}

int append_query_string(CHARSET_INFO *csinfo, String *to,
                        const char *str, size_t len, bool no_backslash);

#endif /* SQL_STRING_INCLUDED */

SILENT KILLER Tool