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

Change CHARSET_INFO character set and collaction names to LEX_CSTRING

Browse Source 
This change removed 68 explict strlen() calls from the code.

The following renames was done to ensure we don't use the old names
when merging code from earlier releases, as using the new variables
for print function could result in crashes:
- charset->csname renamed to charset->cs_name
- charset->name renamed to charset->coll_name

Almost everything where mechanical changes except:
- Changed to use the new Protocol::store(LEX_CSTRING..) when possible
- Changed to use field->store(LEX_CSTRING*, CHARSET_INFO*) when possible
- Changed to use String->append(LEX_CSTRING&) when possible

Other things:
- There where compiler issues with ensuring that all character set names
  points to the same string: gcc doesn't allow one to use integer constants
  when defining global structures (constant char * pointers works fine).
  To get around this, I declared defines for each character set name
  length.
This commit is contained in:
Monty 2020-08-22 02:08:59 +03:00 committed by Sergei Golubchik
parent b0910dddf5
commit a206658b98
78 changed files with 1019 additions and 1022 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
client/mariadb-conv.cc
View File

@ -344,7 +344,7 @@ private:
fflush(stdout);
fprintf(stderr,
"Illegal %s byte sequence at position %d\n",
m_fromcs->csname,
m_fromcs->cs_name.str,
(uint) (well_formed_error_pos() - from));
}
else if (cannot_convert_error_pos())
@ -352,7 +352,7 @@ private:
fflush(stdout);
fprintf(stderr,
"Conversion from %s to %s failed at position %d\n",
m_fromcs->csname, m_tocs->csname,
m_fromcs->cs_name.str, m_tocs->cs_name.str,
(uint) (cannot_convert_error_pos() - from));
}
}
@ -453,7 +453,7 @@ int main(int argc, char *argv[])
charset_info_to->mbminlen > 1)
{
fprintf(stderr, "--delimiter cannot be used with %s to %s conversion\n",
charset_info_from->csname, charset_info_to->csname);
charset_info_from->cs_name.str, charset_info_to->cs_name.str);
return 1;
}
if (conv.set_delimiter_unescape(opt.m_delimiter))

23
client/mysql.cc
View File

@ -3246,8 +3246,8 @@ com_charset(String *buffer __attribute__((unused)), char *line)
if (new_cs)
{
charset_info= new_cs;
mysql_set_character_set(&mysql, charset_info->csname);
default_charset= (char *)charset_info->csname;
mysql_set_character_set(&mysql, charset_info->cs_name.str);
default_charset= (char *)charset_info->cs_name.str;
put_info("Charset changed", INFO_INFO);
}
else put_info("Charset is not found", INFO_INFO);
@ -4736,6 +4736,8 @@ static int
sql_real_connect(char *host,char *database,char *user,char *password,
uint silent)
{
const char *charset_name;
if (connected)
{
connected= 0;
@ -4783,13 +4785,17 @@ sql_real_connect(char *host,char *database,char *user,char *password,
return -1; // Retryable
}
if (!(charset_info= get_charset_by_name(mysql.charset->name, MYF(MY_UTF8_IS_UTF8MB3))))
charset_name= IF_EMBEDDED(mysql.charset->coll_name.str,
mysql.charset->name);
charset_info= get_charset_by_name(charset_name, MYF(MY_UTF8_IS_UTF8MB3));
if (!charset_info)
{
put_info("Unknown default character set", INFO_ERROR);
char buff[128];
my_snprintf(buff, sizeof(buff)-1,
"Unknown default character set %s", charset_name);
put_info(buff, INFO_ERROR);
return 1;
}
connected=1;
#ifndef EMBEDDED_LIBRARY
mysql_options(&mysql, MYSQL_OPT_RECONNECT, &debug_info_flag);
@ -4928,8 +4934,9 @@ com_status(String *buffer __attribute__((unused)),
else
{
/* Probably pre-4.1 server */
tee_fprintf(stdout, "Client characterset:\t%s\n", charset_info->csname);
tee_fprintf(stdout, "Server characterset:\t%s\n", mysql.charset->csname);
tee_fprintf(stdout, "Client characterset:\t%s\n", charset_info->cs_name.str);
tee_fprintf(stdout, "Server characterset:\t%s\n",
mysql_character_set_name(&mysql));
}
#ifndef EMBEDDED_LIBRARY

10
client/mysqldump.c
View File

@ -1647,8 +1647,8 @@ static int switch_db_collation(FILE *sql_file,
fprintf(sql_file,
"ALTER DATABASE %s CHARACTER SET %s COLLATE %s %s\n",
(const char *) quoted_db_name,
(const char *) db_cl->csname,
(const char *) db_cl->name,
(const char *) db_cl->cs_name.str,
(const char *) db_cl->coll_name.str,
(const char *) delimiter);
*db_cl_altered= 1;
@ -1678,8 +1678,8 @@ static int restore_db_collation(FILE *sql_file,
fprintf(sql_file,
"ALTER DATABASE %s CHARACTER SET %s COLLATE %s %s\n",
(const char *) quoted_db_name,
(const char *) db_cl->csname,
(const char *) db_cl->name,
(const char *) db_cl->cs_name.str,
(const char *) db_cl->coll_name.str,
(const char *) delimiter);
return 0;
@ -4120,7 +4120,7 @@ static void dump_table(const char *table, const char *db, const uchar *hash_key,
dynstr_append_checked(&query_string, " /*!50138 CHARACTER SET ");
dynstr_append_checked(&query_string, default_charset == mysql_universal_client_charset ?
my_charset_bin.name : /* backward compatibility */
my_charset_bin.coll_name.str : /* backward compatibility */
default_charset);
dynstr_append_checked(&query_string, " */");

4
client/mysqltest.cc
View File

@ -6010,7 +6010,7 @@ void do_connect(struct st_command *command)
if (opt_compress || con_compress)
mysql_options(con_slot->mysql, MYSQL_OPT_COMPRESS, NullS);
mysql_options(con_slot->mysql, MYSQL_SET_CHARSET_NAME,
csname?csname: charset_info->csname);
csname ? csname : charset_info->cs_name.str);
if (opt_charsets_dir)
mysql_options(con_slot->mysql, MYSQL_SET_CHARSET_DIR,
opt_charsets_dir);
@ -9259,7 +9259,7 @@ int main(int argc, char **argv)
if (opt_compress)
mysql_options(con->mysql,MYSQL_OPT_COMPRESS,NullS);
mysql_options(con->mysql, MYSQL_SET_CHARSET_NAME,
charset_info->csname);
charset_info->cs_name.str);
if (opt_charsets_dir)
mysql_options(con->mysql, MYSQL_SET_CHARSET_DIR,
opt_charsets_dir);

5
include/m_ctype.h
View File

@ -22,6 +22,7 @@
#define _m_ctype_h
#include <my_attribute.h>
#include <m_string.h>
enum loglevel {
ERROR_LEVEL= 0,
@ -569,8 +570,8 @@ struct charset_info_st
uint primary_number;
uint binary_number;
uint state;
const char *csname;
const char *name;
LEX_CSTRING cs_name;
LEX_CSTRING coll_name;
const char *comment;
const char *tailoring;
const uchar *m_ctype;

2
include/my_sys.h
View File

@ -1052,7 +1052,7 @@ extern void free_charsets(void);
extern char *get_charsets_dir(char *buf);
static inline my_bool my_charset_same(CHARSET_INFO *cs1, CHARSET_INFO *cs2)
{
return (cs1->csname == cs2->csname);
return (cs1->cs_name.str == cs2->cs_name.str);
}
extern my_bool init_compiled_charsets(myf flags);
extern void add_compiled_collation(struct charset_info_st *cs);

6
libmysqld/libmysql.c
View File

@ -1114,15 +1114,15 @@ ulong STDCALL mysql_thread_id(MYSQL *mysql)
const char * STDCALL mysql_character_set_name(MYSQL *mysql)
{
return mysql->charset->csname;
return mysql->charset->cs_name.str;
}
void STDCALL mysql_get_character_set_info(MYSQL *mysql, MY_CHARSET_INFO *csinfo)
{
csinfo->number = mysql->charset->number;
csinfo->state = mysql->charset->state;
csinfo->csname = mysql->charset->csname;
csinfo->name = mysql->charset->name;
csinfo->csname = mysql->charset->cs_name.str;
csinfo->name = mysql->charset->coll_name.str;
csinfo->comment = mysql->charset->comment;
csinfo->mbminlen = mysql->charset->mbminlen;
csinfo->mbmaxlen = mysql->charset->mbmaxlen;

2
mysys/charset-def.c
View File

@ -468,7 +468,7 @@ my_bool init_compiled_charsets(myf flags __attribute__((unused)))
#endif /* HAVE_CHARSET_utf32 */
/* Copy compiled charsets */
for (cs=compiled_charsets; cs->name; cs++)
for (cs=compiled_charsets; cs->coll_name.str; cs++)
add_compiled_extra_collation((struct charset_info_st *) cs);
return FALSE;

94
mysys/charset.c
View File

@ -50,8 +50,8 @@ get_collation_number_internal(const char *name)
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if ( cs[0] && cs[0]->name &&
!my_strcasecmp(&my_charset_latin1, cs[0]->name, name))
if (cs[0] && cs[0]->coll_name.str &&
!my_strcasecmp(&my_charset_latin1, cs[0]->coll_name.str, name))
return cs[0]->number;
}
return 0;
@ -151,13 +151,23 @@ static int cs_copy_data(struct charset_info_st *to, CHARSET_INFO *from)
to->number= from->number ? from->number : to->number;
/* Don't replace csname if already set */
if (from->csname && !to->csname)
if (!(to->csname= my_once_strdup(from->csname,MYF(MY_WME))))
if (from->cs_name.str && !to->cs_name.str)
{
if (!(to->cs_name.str= my_once_memdup(from->cs_name.str,
from->cs_name.length + 1,
MYF(MY_WME))))
goto err;
to->cs_name.length= from->cs_name.length;
}
if (from->name)
if (!(to->name= my_once_strdup(from->name,MYF(MY_WME))))
if (from->coll_name.str)
{
if (!(to->coll_name.str= my_once_memdup(from->coll_name.str,
from->coll_name.length + 1,
MYF(MY_WME))))
goto err;
to->coll_name.length= from->coll_name.length;
}
if (from->comment)
if (!(to->comment= my_once_strdup(from->comment,MYF(MY_WME))))
@ -255,7 +265,7 @@ inherit_collation_data(struct charset_info_st *cs, CHARSET_INFO *refcs)
static my_bool simple_cs_is_full(CHARSET_INFO *cs)
{
return cs->number && cs->csname && cs->name &&
return cs->number && cs->cs_name.str && cs->coll_name.str &&
simple_8bit_charset_data_is_full(cs) &&
(simple_8bit_collation_data_is_full(cs) || cs->tailoring);
}
@ -308,8 +318,9 @@ copy_uca_collation(struct charset_info_st *to, CHARSET_INFO *from,
static int add_collation(struct charset_info_st *cs)
{
if (cs->name && (cs->number ||
(cs->number=get_collation_number_internal(cs->name))) &&
if (cs->coll_name.str &&
(cs->number ||
(cs->number=get_collation_number_internal(cs->coll_name.str))) &&
cs->number < array_elements(all_charsets))
{
struct charset_info_st *newcs;
@ -323,10 +334,10 @@ static int add_collation(struct charset_info_st *cs)
else
{
/* Don't allow change of csname */
if (newcs->csname && strcmp(newcs->csname, cs->csname))
if (newcs->cs_name.str && strcmp(newcs->cs_name.str, cs->cs_name.str))
{
my_error(EE_DUPLICATE_CHARSET, MYF(ME_WARNING),
cs->number, cs->csname, newcs->csname);
cs->number, cs->cs_name.str, newcs->cs_name.str);
/*
Continue parsing rest of Index.xml. We got an warning in the log
so the user can fix the wrong character set definition.
@ -351,7 +362,7 @@ static int add_collation(struct charset_info_st *cs)
newcs->caseup_multiply= newcs->casedn_multiply= 1;
newcs->levels_for_order= 1;
if (!strcmp(cs->csname,"ucs2") )
if (!strcmp(cs->cs_name.str,"ucs2") )
{
#if defined(HAVE_CHARSET_ucs2) && defined(HAVE_UCA_COLLATIONS)
copy_uca_collation(newcs, newcs->state & MY_CS_NOPAD ?
@ -361,7 +372,8 @@ static int add_collation(struct charset_info_st *cs)
newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED | MY_CS_NONASCII;
#endif
}
else if (!strcmp(cs->csname, "utf8") || !strcmp(cs->csname, "utf8mb3"))
else if (!strcmp(cs->cs_name.str, "utf8") ||
!strcmp(cs->cs_name.str, "utf8mb3"))
{
#if defined (HAVE_CHARSET_utf8mb3) && defined(HAVE_UCA_COLLATIONS)
copy_uca_collation(newcs, newcs->state & MY_CS_NOPAD ?
@ -373,7 +385,7 @@ static int add_collation(struct charset_info_st *cs)
return MY_XML_ERROR;
#endif
}
else if (!strcmp(cs->csname, "utf8mb4"))
else if (!strcmp(cs->cs_name.str, "utf8mb4"))
{
#if defined (HAVE_CHARSET_utf8mb4) && defined(HAVE_UCA_COLLATIONS)
copy_uca_collation(newcs, newcs->state & MY_CS_NOPAD ?
@ -384,7 +396,7 @@ static int add_collation(struct charset_info_st *cs)
newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED;
#endif
}
else if (!strcmp(cs->csname, "utf16"))
else if (!strcmp(cs->cs_name.str, "utf16"))
{
#if defined (HAVE_CHARSET_utf16) && defined(HAVE_UCA_COLLATIONS)
copy_uca_collation(newcs, newcs->state & MY_CS_NOPAD ?
@ -394,7 +406,7 @@ static int add_collation(struct charset_info_st *cs)
newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED | MY_CS_NONASCII;
#endif
}
else if (!strcmp(cs->csname, "utf32"))
else if (!strcmp(cs->cs_name.str, "utf32"))
{
#if defined (HAVE_CHARSET_utf32) && defined(HAVE_UCA_COLLATIONS)
copy_uca_collation(newcs, newcs->state & MY_CS_NOPAD ?
@ -432,17 +444,28 @@ static int add_collation(struct charset_info_st *cs)
if (cs->comment)
if (!(newcs->comment= my_once_strdup(cs->comment,MYF(MY_WME))))
return MY_XML_ERROR;
if (cs->csname && ! newcs->csname)
if (!(newcs->csname= my_once_strdup(cs->csname,MYF(MY_WME))))
if (cs->cs_name.str && ! newcs->cs_name.str)
{
if (!(newcs->cs_name.str= my_once_memdup(cs->cs_name.str,
cs->cs_name.length+1,
MYF(MY_WME))))
return MY_XML_ERROR;
if (cs->name)
if (!(newcs->name= my_once_strdup(cs->name,MYF(MY_WME))))
newcs->cs_name.length= cs->cs_name.length;
}
if (cs->coll_name.str)
{
if (!(newcs->coll_name.str= my_once_memdup(cs->coll_name.str,
cs->coll_name.length+1,
MYF(MY_WME))))
return MY_XML_ERROR;
newcs->coll_name.length= cs->coll_name.length;
}
}
cs->number= 0;
cs->primary_number= 0;
cs->binary_number= 0;
cs->name= NULL;
cs->coll_name.str= 0;
cs->coll_name.length= 0;
cs->state= 0;
cs->sort_order= NULL;
cs->tailoring= NULL;
@ -584,10 +607,11 @@ void add_compiled_collation(struct charset_info_st *cs)
{
#ifndef DBUG_OFF
CHARSET_INFO *org= (CHARSET_INFO*) my_hash_search(&charset_name_hash,
(uchar*) cs->csname,
strlen(cs->csname));
(uchar*) cs->cs_name.str,
cs->cs_name.length);
DBUG_ASSERT(org);
DBUG_ASSERT(org->csname == cs->csname);
DBUG_ASSERT(org->cs_name.str == cs->cs_name.str);
DBUG_ASSERT(org->cs_name.length == strlen(cs->cs_name.str));
#endif
}
}
@ -610,9 +634,9 @@ void add_compiled_extra_collation(struct charset_info_st *cs)
if ((my_hash_insert(&charset_name_hash, (uchar*) cs)))
{
CHARSET_INFO *org= (CHARSET_INFO*) my_hash_search(&charset_name_hash,
(uchar*) cs->csname,
strlen(cs->csname));
cs->csname= org->csname;
(uchar*) cs->cs_name.str,
cs->cs_name.length);
cs->cs_name= org->cs_name;
}
}
@ -672,8 +696,8 @@ static uchar *get_charset_key(const uchar *object,
my_bool not_used __attribute__((unused)))
{
CHARSET_INFO *cs= (CHARSET_INFO*) object;
*size= strlen(cs->csname);
return (uchar*) cs->csname;
*size= cs->cs_name.length;
return (uchar*) cs->cs_name.str;
}
static void init_available_charsets(void)
@ -756,8 +780,8 @@ get_charset_number_internal(const char *charset_name, uint cs_flags)
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if ( cs[0] && cs[0]->csname && (cs[0]->state & cs_flags) &&
!my_strcasecmp(&my_charset_latin1, cs[0]->csname, charset_name))
if ( cs[0] && cs[0]->cs_name.str && (cs[0]->state & cs_flags) &&
!my_strcasecmp(&my_charset_latin1, cs[0]->cs_name.str, charset_name))
return cs[0]->number;
}
return 0;
@ -787,8 +811,8 @@ const char *get_charset_name(uint charset_number)
{
CHARSET_INFO *cs= all_charsets[charset_number];
if (cs && (cs->number == charset_number) && cs->name)
return (char*) cs->name;
if (cs && (cs->number == charset_number) && cs->coll_name.str)
return cs->coll_name.str;
}
return "?"; /* this mimics find_type() */
@ -823,7 +847,7 @@ static CHARSET_INFO *find_collation_data_inheritance_source(CHARSET_INFO *cs, my
static CHARSET_INFO *find_charset_data_inheritance_source(CHARSET_INFO *cs)
{
uint refid= get_charset_number_internal(cs->csname, MY_CS_PRIMARY);
uint refid= get_charset_number_internal(cs->cs_name.str, MY_CS_PRIMARY);
return inheritance_source_by_id(cs, refid);
}
@ -853,7 +877,7 @@ get_internal_charset(MY_CHARSET_LOADER *loader, uint cs_number, myf flags)
if (!(cs->state & (MY_CS_COMPILED|MY_CS_LOADED))) /* if CS is not in memory */
{
MY_CHARSET_LOADER loader;
strxmov(get_charsets_dir(buf), cs->csname, ".xml", NullS);
strxmov(get_charsets_dir(buf), cs->cs_name.str, ".xml", NullS);
my_charset_loader_init_mysys(&loader);
my_read_charset_file(&loader, buf, flags);
}

2
mysys/mf_iocache.c
View File

@ -153,7 +153,7 @@ init_functions(IO_CACHE* info)
int init_io_cache_ext(IO_CACHE *info, File file, size_t cachesize,
enum cache_type type, my_off_t seek_offset,
pbool use_async_io, myf cache_myflags,
PSI_file_key file_key)
PSI_file_key file_key __attribute__((unused)))
{
size_t min_cache;
my_off_t pos;

8
plugin/qc_info/qc_info.cc
View File

@ -183,23 +183,21 @@ static int qc_info_fill_table(THD *thd, TABLE_LIST *tables,
cs_client= get_charset(flags.character_set_client_num, MYF(MY_WME));
if (likely(cs_client))
table->field[COLUMN_CHARACTER_SET_CLIENT]->
store(cs_client->csname, strlen(cs_client->csname), scs);
store(&cs_client->cs_name, scs);
else
table->field[COLUMN_CHARACTER_SET_CLIENT]->
store(STRING_WITH_LEN(unknown), scs);
cs_result= get_charset(flags.character_set_results_num, MYF(MY_WME));
if (likely(cs_result))
table->field[COLUMN_CHARACTER_SET_RESULT]->
store(cs_result->csname, strlen(cs_result->csname), scs);
table->field[COLUMN_CHARACTER_SET_RESULT]->store(&cs_result->cs_name, scs);
else
table->field[COLUMN_CHARACTER_SET_RESULT]->
store(STRING_WITH_LEN(unknown), scs);
collation= get_charset(flags.collation_connection_num, MYF(MY_WME));
if (likely(collation))
table->field[COLUMN_COLLATION]->
store(collation->name, strlen(collation->name), scs);
table->field[COLUMN_COLLATION]-> store(&collation->coll_name, scs);
else
table->field[COLUMN_COLLATION]-> store(STRING_WITH_LEN(unknown), scs);

3
plugin/user_variables/user_variables.cc
View File

@ -86,8 +86,7 @@ static int user_variables_fill(THD *thd, TABLE_LIST *tables, COND *cond)
if (var->charset())
{
field[3]->store(var->charset()->csname, strlen(var->charset()->csname),
system_charset_info);
field[3]->store(&var->charset()->cs_name, system_charset_info);
field[3]->set_notnull();
}
else

2
sql-common/client.c
View File

@ -3219,7 +3219,7 @@ my_bool mysql_reconnect(MYSQL *mysql)
strmov(mysql->net.sqlstate, tmp_mysql.net.sqlstate);
DBUG_RETURN(1);
}
if (mysql_set_character_set(&tmp_mysql, mysql->charset->csname))
if (mysql_set_character_set(&tmp_mysql, mysql->charset->cs_name.str))
{
DBUG_PRINT("error", ("mysql_set_character_set() failed"));
bzero((char*) &tmp_mysql.options,sizeof(tmp_mysql.options));

20
sql/event_db_repository.cc
View File

@ -341,31 +341,27 @@ mysql_event_fill_row(THD *thd,
}
fields[ET_FIELD_CHARACTER_SET_CLIENT]->set_notnull();
rs|= fields[ET_FIELD_CHARACTER_SET_CLIENT]->store(
thd->variables.character_set_client->csname,
strlen(thd->variables.character_set_client->csname),
system_charset_info);
rs|= fields[ET_FIELD_CHARACTER_SET_CLIENT]->
store(&thd->variables.character_set_client->cs_name,
system_charset_info);
fields[ET_FIELD_COLLATION_CONNECTION]->set_notnull();
rs|= fields[ET_FIELD_COLLATION_CONNECTION]->store(
thd->variables.collation_connection->name,
strlen(thd->variables.collation_connection->name),
system_charset_info);
rs|= fields[ET_FIELD_COLLATION_CONNECTION]->
store(&thd->variables.collation_connection->coll_name,
system_charset_info);
{
CHARSET_INFO *db_cl= get_default_db_collation(thd, et->dbname.str);
fields[ET_FIELD_DB_COLLATION]->set_notnull();
rs|= fields[ET_FIELD_DB_COLLATION]->store(db_cl->name,
strlen(db_cl->name),
rs|= fields[ET_FIELD_DB_COLLATION]->store(&db_cl->coll_name,
system_charset_info);
}
if (et->body_changed)
{
fields[ET_FIELD_BODY_UTF8]->set_notnull();
rs|= fields[ET_FIELD_BODY_UTF8]->store(sp->m_body_utf8.str,
sp->m_body_utf8.length,
rs|= fields[ET_FIELD_BODY_UTF8]->store(&sp->m_body_utf8,
system_charset_info);
}

9
sql/events.cc
View File

@ -740,14 +740,11 @@ send_show_create_event(THD *thd, Event_timed *et, Protocol *protocol)
protocol->store(tz_name->ptr(), tz_name->length(), system_charset_info);
protocol->store(show_str.ptr(), show_str.length(),
et->creation_ctx->get_client_cs());
protocol->store(et->creation_ctx->get_client_cs()->csname,
strlen(et->creation_ctx->get_client_cs()->csname),
protocol->store(&et->creation_ctx->get_client_cs()->cs_name,
system_charset_info);
protocol->store(et->creation_ctx->get_connection_cl()->name,
strlen(et->creation_ctx->get_connection_cl()->name),
protocol->store(&et->creation_ctx->get_connection_cl()->coll_name,
system_charset_info);
protocol->store(et->creation_ctx->get_db_cl()->name,
strlen(et->creation_ctx->get_db_cl()->name),
protocol->store(&et->creation_ctx->get_db_cl()->coll_name,
system_charset_info);
if (protocol->write())

4
sql/field.cc
View File

@ -7600,7 +7600,7 @@ void Field_string::sql_rpl_type(String *res) const
res->alloced_length(),
"char(%u octets) character set %s",
field_length,
charset()->csname);
charset()->cs_name.str);
res->length(length);
}
else
@ -8049,7 +8049,7 @@ void Field_varstring::sql_rpl_type(String *res) const
res->alloced_length(),
"varchar(%u octets) character set %s",
field_length,
charset()->csname);
charset()->cs_name.str);
res->length(length);
}
else

4
sql/handler.cc
View File

@ -7708,8 +7708,8 @@ bool HA_CREATE_INFO::check_conflicting_charset_declarations(CHARSET_INFO *cs)
{
my_error(ER_CONFLICTING_DECLARATIONS, MYF(0),
"CHARACTER SET ", default_table_charset ?
default_table_charset->csname : "DEFAULT",
"CHARACTER SET ", cs ? cs->csname : "DEFAULT");
default_table_charset->cs_name.str : "DEFAULT",
"CHARACTER SET ", cs ? cs->cs_name.str : "DEFAULT");
return true;
}
return false;

25
sql/item.cc
View File

@ -2463,7 +2463,7 @@ bool DTCollation::aggregate(const DTCollation &dt, uint flags)
set(dt);
return 0;
}
CHARSET_INFO *bin= get_charset_by_csname(collation->csname,
CHARSET_INFO *bin= get_charset_by_csname(collation->cs_name.str,
MY_CS_BINSORT,MYF(utf8_flag));
set(bin, DERIVATION_NONE);
}
@ -2477,8 +2477,8 @@ static
void my_coll_agg_error(DTCollation &c1, DTCollation &c2, const char *fname)
{
my_error(ER_CANT_AGGREGATE_2COLLATIONS,MYF(0),
c1.collation->name,c1.derivation_name(),
c2.collation->name,c2.derivation_name(),
c1.collation->coll_name.str, c1.derivation_name(),
c2.collation->coll_name.str, c2.derivation_name(),
fname);
}
@ -2488,10 +2488,10 @@ void my_coll_agg_error(DTCollation &c1, DTCollation &c2, DTCollation &c3,
const char *fname)
{
my_error(ER_CANT_AGGREGATE_3COLLATIONS,MYF(0),
c1.collation->name,c1.derivation_name(),
c2.collation->name,c2.derivation_name(),
c3.collation->name,c3.derivation_name(),
fname);
c1.collation->coll_name.str, c1.derivation_name(),
c2.collation->coll_name.str, c2.derivation_name(),
c3.collation->coll_name.str, c3.derivation_name(),
fname);
}
@ -3799,8 +3799,7 @@ void Item_string::print(String *str, enum_query_type query_type)
if (print_introducer)
{
str->append('_');
str->append(collation.collation->csname,
strlen(collation.collation->csname));
str->append(collation.collation->cs_name);
}
str->append('\'');
@ -6381,7 +6380,7 @@ String *Item::check_well_formed_result(String *str, bool send_error)
if (send_error)
{
my_error(ER_INVALID_CHARACTER_STRING, MYF(0),
cs->csname, hexbuf);
cs->cs_name.str, hexbuf);
return 0;
}
if (thd->is_strict_mode())
@ -6395,7 +6394,7 @@ String *Item::check_well_formed_result(String *str, bool send_error)
}
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
ER_INVALID_CHARACTER_STRING,
ER_THD(thd, ER_INVALID_CHARACTER_STRING), cs->csname,
ER_THD(thd, ER_INVALID_CHARACTER_STRING), cs->cs_name.str,
hexbuf);
}
return str;
@ -6420,7 +6419,7 @@ String_copier_for_item::copy_with_warn(CHARSET_INFO *dstcs, String *dst,
ER_INVALID_CHARACTER_STRING,
ER_THD(m_thd, ER_INVALID_CHARACTER_STRING),
srccs == &my_charset_bin ?
dstcs->csname : srccs->csname,
dstcs->cs_name.str : srccs->cs_name.str,
err.ptr());
return false;
}
@ -6433,7 +6432,7 @@ String_copier_for_item::copy_with_warn(CHARSET_INFO *dstcs, String *dst,
push_warning_printf(m_thd, Sql_condition::WARN_LEVEL_WARN,
ER_CANNOT_CONVERT_CHARACTER,
ER_THD(m_thd, ER_CANNOT_CONVERT_CHARACTER),
srccs->csname, buf, dstcs->csname);
srccs->cs_name.str, buf, dstcs->cs_name.str);
return false;
}
return false;

4
sql/item.h
View File

@ -5349,9 +5349,9 @@ public:
tmp.derivation == DERIVATION_NONE)
{
my_error(ER_CANT_AGGREGATE_2COLLATIONS,MYF(0),
(*a)->collation.collation->name,
(*a)->collation.collation->coll_name.str,
(*a)->collation.derivation_name(),
(*b)->collation.collation->name,
(*b)->collation.collation->coll_name.str,
(*b)->collation.derivation_name(),
func_name());
return true;

20
sql/item_strfunc.cc
View File

@ -2940,8 +2940,7 @@ void Item_func_char::print(String *str, enum_query_type query_type)
if (collation.collation != &my_charset_bin)
{
str->append(STRING_WITH_LEN(" using "));
str->append(collation.collation->csname,
strlen(collation.collation->csname));
str->append(collation.collation->cs_name);
}
str->append(')');
}
@ -3534,8 +3533,7 @@ void Item_func_conv_charset::print(String *str, enum_query_type query_type)
str->append(STRING_WITH_LEN("convert("));
args[0]->print(str, query_type);
str->append(STRING_WITH_LEN(" using "));
str->append(collation.collation->csname,
strlen(collation.collation->csname));
str->append(collation.collation->cs_name);
str->append(')');
}
@ -3554,7 +3552,8 @@ bool Item_func_set_collation::fix_length_and_dec()
if (!my_charset_same(args[0]->collation.collation, m_set_collation))
{
my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0),
m_set_collation->name, args[0]->collation.collation->csname);
m_set_collation->coll_name.str,
args[0]->collation.collation->cs_name.str);
return TRUE;
}
collation.set(m_set_collation, DERIVATION_EXPLICIT,
@ -3575,7 +3574,7 @@ void Item_func_set_collation::print(String *str, enum_query_type query_type)
{
args[0]->print_parenthesised(str, query_type, precedence());
str->append(STRING_WITH_LEN(" collate "));
str->append(m_set_collation->name, strlen(m_set_collation->name));
str->append(m_set_collation->coll_name);
}
String *Item_func_charset::val_str(String *str)
@ -3585,7 +3584,7 @@ String *Item_func_charset::val_str(String *str)
CHARSET_INFO *cs= args[0]->charset_for_protocol();
null_value= 0;
str->copy(cs->csname, (uint) strlen(cs->csname),
str->copy(cs->cs_name.str, cs->cs_name.length,
&my_charset_latin1, collation.collation, &dummy_errors);
return str;
}
@ -3597,8 +3596,8 @@ String *Item_func_collation::val_str(String *str)
CHARSET_INFO *cs= args[0]->charset_for_protocol();
null_value= 0;
str->copy(cs->name, (uint) strlen(cs->name),
&my_charset_latin1, collation.collation, &dummy_errors);
str->copy(cs->coll_name.str, cs->coll_name.length, &my_charset_latin1,
collation.collation, &dummy_errors);
return str;
}
@ -4633,8 +4632,7 @@ void Item_func_dyncol_create::print_arguments(String *str,
if (defs[i].cs)
{
str->append(STRING_WITH_LEN(" charset "));
const char *cs= defs[i].cs->csname;
str->append(cs, strlen(cs));
str->append(defs[i].cs->cs_name);
str->append(' ');
}
break;

2
sql/item_timefunc.cc
View File

@ -2287,7 +2287,7 @@ void Item_char_typecast::print(String *str, enum_query_type query_type)
if (cast_cs)
{
str->append(STRING_WITH_LEN(" charset "));
str->append(cast_cs->csname, strlen(cast_cs->csname));
str->append(cast_cs->cs_name);
}
str->append(')');
}

2
sql/item_xmlfunc.cc
View File

@ -2792,7 +2792,7 @@ bool Item_xml_str_func::fix_fields(THD *thd, Item **ref)
/* UCS2 is not supported */
my_printf_error(ER_UNKNOWN_ERROR,
"Character set '%s' is not supported by XPATH",
MYF(0), collation.collation->csname);
MYF(0), collation.collation->cs_name.str);
return true;
}

2
sql/json_table.cc
View File

@ -914,7 +914,7 @@ int Json_table_column::print(THD *thd, Field **f, String *str)
if (str->append(column_type) ||
((*f)->has_charset() && m_explicit_cs &&
(str->append(STRING_WITH_LEN(" CHARSET ")) ||
str->append(m_explicit_cs->csname, strlen(m_explicit_cs->csname)))) ||
str->append(&m_explicit_cs->cs_name))) ||
str->append(m_column_type == PATH ? &path : &exists_path) ||
print_path(str, &m_path))
return 1;

7
sql/log_event_client.cc
View File

@ -1951,7 +1951,7 @@ bool Query_log_event::print_query_header(IO_CACHE* file,
{
/* for mysql client */
if (my_b_printf(file, "/*!\\C %s */%s\n",
cs_info->csname, print_event_info->delimiter))
cs_info->cs_name.str, print_event_info->delimiter))
goto err;
}
if (my_b_printf(file,"SET "
@ -2502,7 +2502,7 @@ bool User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
}
else
error= my_b_printf(&cache, ":=_%s %s COLLATE `%s`%s\n",
cs->csname, hex_str, cs->name,
cs->cs_name.str, hex_str, cs->coll_name.str,
print_event_info->delimiter);
my_free(hex_str);
if (unlikely(error))
@ -3563,7 +3563,8 @@ void Table_map_log_event::print_columns(IO_CACHE *file,
// Print column character set, except in text columns with binary collation
if (cs != NULL &&
(is_enum_or_set_type(real_type) || cs->number != my_charset_bin.number))
my_b_printf(file, " CHARSET %s COLLATE %s", cs->csname, cs->name);
my_b_printf(file, " CHARSET %s COLLATE %s", cs->cs_name.str,
cs->coll_name.str);
if (i != m_colcnt - 1) my_b_printf(file, ",\n# ");
}
my_b_printf(file, ")");

4
sql/log_event_server.cc
View File

@ -4215,7 +4215,7 @@ void User_var_log_event::pack_info(Protocol* protocol)
char *beg, *end;
if (user_var_append_name_part(protocol->thd, &buf, name, name_len) ||
buf.append('_') ||
buf.append(cs->csname, strlen(cs->csname)) ||
buf.append(cs->cs_name) ||
buf.append(' '))
return;
old_len= buf.length();
@ -4226,7 +4226,7 @@ void User_var_log_event::pack_info(Protocol* protocol)
end= str_to_hex(beg, val, val_len);
buf.length(old_len + (end - beg));
if (buf.append(STRING_WITH_LEN(" COLLATE ")) ||
buf.append(cs->name, strlen(cs->name)))
buf.append(cs->coll_name))
return;
}
protocol->store(buf.ptr(), buf.length(), &my_charset_bin);

8
sql/mysqld.cc
View File

@ -4148,7 +4148,7 @@ static int init_common_variables()
{
sql_print_error(ER_DEFAULT(ER_COLLATION_CHARSET_MISMATCH),
default_collation_name,
default_charset_info->csname);
default_charset_info->cs_name.str);
return 1;
}
default_charset_info= default_collation;
@ -4166,8 +4166,8 @@ static int init_common_variables()
{
sql_print_warning("'%s' can not be used as client character set. "
"'%s' will be used as default client character set.",
default_charset_info->csname,
my_charset_latin1.csname);
default_charset_info->cs_name.str,
my_charset_latin1.cs_name.str);
global_system_variables.collation_connection= &my_charset_latin1;
global_system_variables.character_set_results= &my_charset_latin1;
global_system_variables.character_set_client= &my_charset_latin1;
@ -7512,7 +7512,7 @@ static void usage(void)
MYF(utf8_flag | MY_WME))))
exit(1);
if (!default_collation_name)
default_collation_name= (char*) default_charset_info->name;
default_collation_name= (char*) default_charset_info->coll_name.str;
print_version();
puts(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000"));
puts("Starts the MariaDB database server.\n");

5
sql/protocol.h
View File

@ -99,11 +99,6 @@ public:
bool send_result_set_row(List<Item> *row_items);
bool store(I_List<i_string> *str_list);
/* This will be deleted in future commit */
bool store(const char *from, CHARSET_INFO *cs)
{
return store_string_or_null(from, cs);
}
bool store_string_or_null(const char *from, CHARSET_INFO *cs);
bool store_warning(const char *from, size_t length);
String *storage_packet() { return packet; }

2
sql/set_var.cc
View File

@ -1033,7 +1033,7 @@ int set_var_collation_client::check(THD *thd)
if (!is_supported_parser_charset(character_set_client))
{
my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "character_set_client",
character_set_client->csname);
character_set_client->cs_name.str);
return 1;
}
return 0;

14
sql/slave.cc
View File

@ -2030,7 +2030,8 @@ maybe it is a *VERY OLD MASTER*.");
(master_res= mysql_store_result(mysql)) &&
(master_row= mysql_fetch_row(master_res)))
{
if (strcmp(master_row[0], global_system_variables.collation_server->name))
if (strcmp(master_row[0],
global_system_variables.collation_server->coll_name.str))
{
errmsg= "The slave I/O thread stops because master and slave have \
different values for the COLLATION_SERVER global variable. The values must \
@ -7205,16 +7206,16 @@ static int connect_to_master(THD* thd, MYSQL* mysql, Master_info* mi,
charset, then set client charset to 'latin1' (default client charset).
*/
if (is_supported_parser_charset(default_charset_info))
mysql_options(mysql, MYSQL_SET_CHARSET_NAME, default_charset_info->csname);
mysql_options(mysql, MYSQL_SET_CHARSET_NAME, default_charset_info->cs_name.str);
else
{
sql_print_information("'%s' can not be used as client character set. "
"'%s' will be used as default client character set "
"while connecting to master.",
default_charset_info->csname,
default_client_charset_info->csname);
default_charset_info->cs_name.str,
default_client_charset_info->cs_name.str);
mysql_options(mysql, MYSQL_SET_CHARSET_NAME,
default_client_charset_info->csname);
default_client_charset_info->cs_name.str);
}
/* This one is not strictly needed but we have it here for completeness */
@ -7361,7 +7362,8 @@ MYSQL *rpl_connect_master(MYSQL *mysql)
}
#endif
mysql_options(mysql, MYSQL_SET_CHARSET_NAME, default_charset_info->csname);
mysql_options(mysql, MYSQL_SET_CHARSET_NAME,
default_charset_info->cs_name.str);
/* This one is not strictly needed but we have it here for completeness */
mysql_options(mysql, MYSQL_SET_CHARSET_DIR, (char *) charsets_dir);

23
sql/sp.cc
View File

@ -1075,14 +1075,12 @@ sp_returns_type(THD *thd, String &result, const sp_head *sp)
if (field->has_charset())
{
const char *name= field->charset()->csname;
result.append(STRING_WITH_LEN(" CHARSET "));
result.append(name, strlen(name));
result.append(field->charset()->cs_name);
if (!(field->charset()->state & MY_CS_PRIMARY))
{
name= field->charset()->name;
result.append(STRING_WITH_LEN(" COLLATE "));
result.append(name, strlen(name));
result.append(field->charset()->coll_name);
}
}
@ -1428,22 +1426,19 @@ Sp_handler::sp_create_routine(THD *thd, const sp_head *sp) const
table->field[MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT]->set_notnull();
store_failed= store_failed ||
table->field[MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT]->store(
thd->charset()->csname,
strlen(thd->charset()->csname),
system_charset_info);
table->field[MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT]->
store(&thd->charset()->cs_name, system_charset_info);
table->field[MYSQL_PROC_FIELD_COLLATION_CONNECTION]->set_notnull();
store_failed= store_failed ||
table->field[MYSQL_PROC_FIELD_COLLATION_CONNECTION]->store(
thd->variables.collation_connection->name,
strlen(thd->variables.collation_connection->name),
system_charset_info);
table->field[MYSQL_PROC_FIELD_COLLATION_CONNECTION]->
store(&thd->variables.collation_connection->coll_name,
system_charset_info);
table->field[MYSQL_PROC_FIELD_DB_COLLATION]->set_notnull();
store_failed= store_failed ||
table->field[MYSQL_PROC_FIELD_DB_COLLATION]->store(
db_cs->name, strlen(db_cs->name), system_charset_info);
table->field[MYSQL_PROC_FIELD_DB_COLLATION]->
store(&db_cs->coll_name, system_charset_info);
table->field[MYSQL_PROC_FIELD_BODY_UTF8]->set_notnull();
store_failed= store_failed ||

9
sql/sp_head.cc
View File

@ -3110,9 +3110,12 @@ sp_head::show_create_routine(THD *thd, const Sp_handler *sph)
protocol->store_null();
protocol->store(m_creation_ctx->get_client_cs()->csname, system_charset_info);
protocol->store(m_creation_ctx->get_connection_cl()->name, system_charset_info);
protocol->store(m_creation_ctx->get_db_cl()->name, system_charset_info);
protocol->store(&m_creation_ctx->get_client_cs()->cs_name,
system_charset_info);
protocol->store(&m_creation_ctx->get_connection_cl()->coll_name,
system_charset_info);
protocol->store(&m_creation_ctx->get_db_cl()->coll_name,
system_charset_info);
err_status= protocol->write();

7
sql/sql_class.cc
View File

@ -2344,7 +2344,7 @@ bool THD::convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
{
my_error(ER_BAD_DATA, MYF(0),
ErrConvString(from, from_length, from_cs).ptr(),
to_cs->csname);
to_cs->cs_name.str);
DBUG_RETURN(true);
}
DBUG_RETURN(false);
@ -2396,7 +2396,8 @@ public:
if (most_important_error_pos())
{
ErrConvString err(src, src_length, &my_charset_bin);
my_error(ER_INVALID_CHARACTER_STRING, MYF(0), srccs->csname, err.ptr());
my_error(ER_INVALID_CHARACTER_STRING, MYF(0), srccs->cs_name.str,
err.ptr());
return true;
}
return false;
@ -2464,7 +2465,7 @@ bool THD::check_string_for_wellformedness(const char *str,
if (wlen < length)
{
ErrConvString err(str, length, &my_charset_bin);
my_error(ER_INVALID_CHARACTER_STRING, MYF(0), cs->csname, err.ptr());
my_error(ER_INVALID_CHARACTER_STRING, MYF(0), cs->cs_name.str, err.ptr());
return true;
}
return false;

2
sql/sql_connect.cc
View File

@ -798,7 +798,7 @@ bool thd_init_client_charset(THD *thd, uint cs_number)
{
/* Disallow non-supported parser character sets: UCS2, UTF16, UTF32 */
my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "character_set_client",
cs->csname);
cs->cs_name.str);
return true;
}
thd->org_charset= cs;

4
sql/sql_db.cc
View File

@ -506,9 +506,9 @@ static bool write_db_opt(THD *thd, const char *path,
{
ulong length;
length= (ulong) (strxnmov(buf, sizeof(buf)-1, "default-character-set=",
create->default_table_charset->csname,
create->default_table_charset->cs_name.str,
"\ndefault-collation=",
create->default_table_charset->name,
create->default_table_charset->coll_name.str,
"\n", NullS) - buf);
if (create->schema_comment)

2
sql/sql_load.cc
View File

@ -867,7 +867,7 @@ static bool write_execute_load_query_log_event(THD *thd, const sql_exchange* ex,
*/
qualify_db= db_arg;
}
lle.print_query(thd, FALSE, (const char *) ex->cs?ex->cs->csname:NULL,
lle.print_query(thd, FALSE, (const char*) ex->cs ? ex->cs->cs_name.str : NULL,
&query_str, &fname_start, &fname_end, qualify_db);
/*

5
sql/sql_parse.cc
View File

@ -10444,7 +10444,8 @@ merge_charset_and_collation(CHARSET_INFO *cs, CHARSET_INFO *cl)
{
if (!my_charset_same(cs, cl))
{
my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0), cl->name, cs->csname);
my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0), cl->coll_name.str,
cs->cs_name.str);
return NULL;
}
return cl;
@ -10456,7 +10457,7 @@ merge_charset_and_collation(CHARSET_INFO *cs, CHARSET_INFO *cl)
*/
CHARSET_INFO *find_bin_collation(CHARSET_INFO *cs)
{
const char *csname= cs->csname;
const char *csname= cs->cs_name.str;
THD *thd= current_thd;
myf utf8_flag= thd->get_utf8_flag();

119
sql/sql_show.cc
View File

@ -1333,11 +1333,11 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list)
buffer.set_charset(table_list->view_creation_ctx->get_client_cs());
protocol->store(&buffer);
protocol->store(table_list->view_creation_ctx->get_client_cs()->csname,
protocol->store(&table_list->view_creation_ctx->get_client_cs()->cs_name,
system_charset_info);
protocol->store(table_list->view_creation_ctx->get_connection_cl()->name,
system_charset_info);
protocol->store(&table_list->view_creation_ctx->get_connection_cl()->
coll_name, system_charset_info);
}
else
protocol->store(&buffer);
@ -1440,13 +1440,11 @@ bool mysqld_show_create_db(THD *thd, LEX_CSTRING *dbname,
{
buffer.append(STRING_WITH_LEN(" /*!40100"));
buffer.append(STRING_WITH_LEN(" DEFAULT CHARACTER SET "));
buffer.append(create.default_table_charset->csname,
strlen(create.default_table_charset->csname));
buffer.append(create.default_table_charset->cs_name);
if (!(create.default_table_charset->state & MY_CS_PRIMARY))
{
buffer.append(STRING_WITH_LEN(" COLLATE "));
buffer.append(create.default_table_charset->name,
strlen(create.default_table_charset->name));
buffer.append(create.default_table_charset->coll_name);
}
buffer.append(STRING_WITH_LEN(" */"));
}
@ -1902,13 +1900,11 @@ static void add_table_options(THD *thd, TABLE *table,
(create_info_arg->used_fields & HA_CREATE_USED_DEFAULT_CHARSET))
{
packet->append(STRING_WITH_LEN(" DEFAULT CHARSET="));
packet->append(share->table_charset->csname,
strlen(share->table_charset->csname));
packet->append(share->table_charset->cs_name);
if (!(share->table_charset->state & MY_CS_PRIMARY))
{
packet->append(STRING_WITH_LEN(" COLLATE="));
packet->append(table->s->table_charset->name,
strlen(table->s->table_charset->name));
packet->append(table->s->table_charset->coll_name);
}
}
}
@ -2190,8 +2186,7 @@ int show_create_table_ex(THD *thd, TABLE_LIST *table_list,
if (field->charset() != share->table_charset)
{
packet->append(STRING_WITH_LEN(" CHARACTER SET "));
packet->append(field->charset()->csname,
strlen(field->charset()->csname));
packet->append(field->charset()->cs_name);
}
/*
For string types dump collation name only if
@ -2205,7 +2200,7 @@ int show_create_table_ex(THD *thd, TABLE_LIST *table_list,
field->charset() != field->vcol_info->expr->collation.collation))
{
packet->append(STRING_WITH_LEN(" COLLATE "));
packet->append(field->charset()->name, strlen(field->charset()->name));
packet->append(field->charset()->coll_name);
}
}
@ -5309,9 +5304,9 @@ bool store_schema_schemata(THD* thd, TABLE *table, LEX_CSTRING *db_name,
{
restore_record(table, s->default_values);
table->field[0]->store(STRING_WITH_LEN("def"), system_charset_info);
table->field[1]->store(db_name->str, db_name->length, system_charset_info);
table->field[2]->store(cs->csname, strlen(cs->csname), system_charset_info);
table->field[3]->store(cs->name, strlen(cs->name), system_charset_info);
table->field[1]->store(db_name, system_charset_info);
table->field[2]->store(&cs->cs_name, system_charset_info);
table->field[3]->store(&cs->coll_name, system_charset_info);
if (schema_comment)
table->field[5]->store(schema_comment->str, schema_comment->length,
system_charset_info);
@ -5598,13 +5593,15 @@ static int get_schema_tables_record(THD *thd, TABLE_LIST *tables,
if (str.length())
table->field[19]->store(str.ptr()+1, str.length()-1, cs);
tmp_buff= (share->table_charset ?
share->table_charset->name : "default");
table->field[17]->store(tmp_buff, strlen(tmp_buff), cs);
LEX_CSTRING tmp_str;
if (share->table_charset)
tmp_str= share->table_charset->coll_name;
else
tmp_str= { STRING_WITH_LEN("default") };
table->field[17]->store(&tmp_str, cs);
if (share->comment.str)
table->field[20]->store(share->comment.str, share->comment.length, cs);
table->field[20]->store(&share->comment, cs);
/* Collect table info from the storage engine */
@ -5825,12 +5822,10 @@ static void store_column_type(TABLE *table, Field *field, CHARSET_INFO *cs,
if (field->has_charset())
{
/* CHARACTER_SET_NAME column*/
tmp_buff= field->charset()->csname;
table->field[offset + 6]->store(tmp_buff, strlen(tmp_buff), cs);
table->field[offset + 6]->store(&field->charset()->cs_name, cs);
table->field[offset + 6]->set_notnull();
/* COLLATION_NAME column */
tmp_buff= field->charset()->name;
table->field[offset + 7]->store(tmp_buff, strlen(tmp_buff), cs);
table->field[offset + 7]->store(&field->charset()->coll_name, cs);
table->field[offset + 7]->set_notnull();
}
}
@ -6117,12 +6112,12 @@ int fill_schema_charsets(THD *thd, TABLE_LIST *tables, COND *cond)
(tmp_cs->state & MY_CS_AVAILABLE) &&
!(tmp_cs->state & MY_CS_HIDDEN) &&
!(wild && wild[0] &&
wild_case_compare(scs, tmp_cs->csname,wild)))
wild_case_compare(scs, tmp_cs->cs_name.str,wild)))
{
const char *comment;
restore_record(table, s->default_values);
table->field[0]->store(tmp_cs->csname, strlen(tmp_cs->csname), scs);
table->field[1]->store(tmp_cs->name, strlen(tmp_cs->name), scs);
table->field[0]->store(&tmp_cs->cs_name, scs);
table->field[1]->store(&tmp_cs->coll_name, scs);
comment= tmp_cs->comment ? tmp_cs->comment : "";
table->field[2]->store(comment, strlen(comment), scs);
table->field[3]->store((longlong) tmp_cs->mbmaxlen, TRUE);
@ -6234,12 +6229,13 @@ int fill_schema_collation(THD *thd, TABLE_LIST *tables, COND *cond)
!my_charset_same(tmp_cs, tmp_cl))
continue;
if (!(wild && wild[0] &&
wild_case_compare(scs, tmp_cl->name,wild)))
wild_case_compare(scs, tmp_cl->coll_name.str, wild)))
{
const char *tmp_buff;
restore_record(table, s->default_values);
table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs);
table->field[0]->store(tmp_cl->coll_name.str, tmp_cl->coll_name.length,
scs);
table->field[1]->store(&tmp_cl->cs_name, scs);
table->field[2]->store((longlong) tmp_cl->number, TRUE);
tmp_buff= (tmp_cl->state & MY_CS_PRIMARY) ? "Yes" : "";
table->field[3]->store(tmp_buff, strlen(tmp_buff), scs);
@ -6279,8 +6275,8 @@ int fill_schema_coll_charset_app(THD *thd, TABLE_LIST *tables, COND *cond)
!my_charset_same(tmp_cs,tmp_cl))
continue;
restore_record(table, s->default_values);
table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs);
table->field[0]->store(&tmp_cl->coll_name, scs);
table->field[1]->store(&tmp_cl->cs_name, scs);
if (schema_table_store_record(thd, table))
return 1;
}
@ -6883,15 +6879,10 @@ static int get_schema_views_record(THD *thd, TABLE_LIST *tables,
else
table->field[7]->store(STRING_WITH_LEN("INVOKER"), cs);
table->field[8]->store(tables->view_creation_ctx->get_client_cs()->csname,
strlen(tables->view_creation_ctx->
get_client_cs()->csname), cs);
table->field[9]->store(tables->view_creation_ctx->
get_connection_cl()->name,
strlen(tables->view_creation_ctx->
get_connection_cl()->name), cs);
table->field[8]->store(&tables->view_creation_ctx->get_client_cs()->cs_name,
cs);
table->field[9]->store(&tables->view_creation_ctx->
get_connection_cl()->coll_name, cs);
table->field[10]->store(view_algorithm(tables), cs);
if (schema_table_store_record(thd, table))
@ -7094,12 +7085,9 @@ static bool store_trigger(THD *thd, Trigger *trigger,
sql_mode_string_representation(thd, trigger->sql_mode, &sql_mode_rep);
table->field[17]->store(sql_mode_rep.str, sql_mode_rep.length, cs);
table->field[18]->store(definer_buffer.str, definer_buffer.length, cs);
table->field[19]->store(trigger->client_cs_name.str,
trigger->client_cs_name.length, cs);
table->field[20]->store(trigger->connection_cl_name.str,
trigger->connection_cl_name.length, cs);
table->field[21]->store(trigger->db_cl_name.str,
trigger->db_cl_name.length, cs);
table->field[19]->store(&trigger->client_cs_name, cs);
table->field[20]->store(&trigger->connection_cl_name, cs);
table->field[21]->store(&trigger->db_cl_name, cs);
return schema_table_store_record(thd, table);
}
@ -7786,22 +7774,15 @@ copy_event_to_schema_table(THD *thd, TABLE *sch_table, TABLE *event_table)
store(et.comment.str, et.comment.length, scs);
sch_table->field[ISE_CLIENT_CS]->set_notnull();
sch_table->field[ISE_CLIENT_CS]->store(
et.creation_ctx->get_client_cs()->csname,
strlen(et.creation_ctx->get_client_cs()->csname),
scs);
sch_table->field[ISE_CLIENT_CS]->store(&et.creation_ctx->get_client_cs()->
cs_name, scs);
sch_table->field[ISE_CONNECTION_CL]->set_notnull();
sch_table->field[ISE_CONNECTION_CL]->store(
et.creation_ctx->get_connection_cl()->name,
strlen(et.creation_ctx->get_connection_cl()->name),
scs);
sch_table->field[ISE_CONNECTION_CL]->store(&et.creation_ctx->
get_connection_cl()->coll_name,
scs);
sch_table->field[ISE_DB_CL]->set_notnull();
sch_table->field[ISE_DB_CL]->store(
et.creation_ctx->get_db_cl()->name,
strlen(et.creation_ctx->get_db_cl()->name),
scs);
sch_table->field[ISE_DB_CL]->store(&et.creation_ctx->get_db_cl()->coll_name,
scs);
if (schema_table_store_record(thd, sch_table))
DBUG_RETURN(1);
@ -9841,17 +9822,11 @@ static bool show_create_trigger_impl(THD *thd, Trigger *trigger)
trg_sql_original_stmt.length,
trg_client_cs);
p->store(trigger->client_cs_name.str,
trigger->client_cs_name.length,
system_charset_info);
p->store(&trigger->client_cs_name, system_charset_info);
p->store(trigger->connection_cl_name.str,
trigger->connection_cl_name.length,
system_charset_info);
p->store(&trigger->connection_cl_name, system_charset_info);
p->store(trigger->db_cl_name.str,
trigger->db_cl_name.length,
system_charset_info);
p->store(&trigger->db_cl_name, system_charset_info);
if (trigger->create_time)
{

4
sql/sql_string.h
View File

@ -183,7 +183,7 @@ public:
}
bool same_encoding(const Charset &other) const
{
return !strcmp(m_charset->csname, other.m_charset->csname);
return my_charset_same(m_charset, other.m_charset);
}
/*
Collation name without the character set name.
@ -936,7 +936,7 @@ public:
{
return
append('_') ||
append(str->charset()->csname, strlen(str->charset()->csname)) ||
append(str->charset()->cs_name) ||
append(STRING_WITH_LEN(" 0x")) ||
append_hex(str->ptr(), (uint32) str->length());
}

4
sql/sql_table.cc
View File

@ -4658,13 +4658,13 @@ bool validate_comment_length(THD *thd, LEX_CSTRING *comment, size_t max_len,
if (thd->is_strict_mode())
{
my_error(ER_INVALID_CHARACTER_STRING, MYF(0),
system_charset_info->csname, comment->str);
system_charset_info->cs_name.str, comment->str);
DBUG_RETURN(true);
}
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
ER_INVALID_CHARACTER_STRING,
ER_THD(thd, ER_INVALID_CHARACTER_STRING),
system_charset_info->csname, comment->str);
system_charset_info->cs_name.str, comment->str);
comment->length= tmp_len;
DBUG_RETURN(false);
}

17
sql/sql_trigger.cc
View File

@ -937,11 +937,9 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables,
- connection collation contains pair {character set, collation};
- database collation contains pair {character set, collation};
*/
lex_string_set(&trigger->client_cs_name, thd->charset()->csname);
lex_string_set(&trigger->connection_cl_name,
thd->variables.collation_connection->name);
lex_string_set(&trigger->db_cl_name,
get_default_db_collation(thd, tables->db.str)->name);
trigger->client_cs_name= thd->charset()->cs_name;
trigger->connection_cl_name= thd->variables.collation_connection->coll_name;
trigger->db_cl_name= get_default_db_collation(thd, tables->db.str)->coll_name;
/* Add trigger in it's correct place */
add_trigger(lex->trg_chistics.event,
@ -1505,12 +1503,9 @@ bool Table_triggers_list::check_n_load(THD *thd, const LEX_CSTRING *db,
lex.raw_trg_on_table_name_begin);
/* Copy pointers to character sets to make trigger easier to use */
lex_string_set(&trigger->client_cs_name,
creation_ctx->get_client_cs()->csname);
lex_string_set(&trigger->connection_cl_name,
creation_ctx->get_connection_cl()->name);
lex_string_set(&trigger->db_cl_name,
creation_ctx->get_db_cl()->name);
trigger->client_cs_name= creation_ctx->get_client_cs()->cs_name;
trigger->connection_cl_name= creation_ctx->get_connection_cl()->coll_name;
trigger->db_cl_name= creation_ctx->get_db_cl()->coll_name;
/* event can only be TRG_EVENT_MAX in case of fatal parse errors */
if (lex.trg_chistics.event != TRG_EVENT_MAX)

32
sql/sql_type.cc
View File

@ -6231,17 +6231,15 @@ String *Type_handler::
StringBuffer<STRING_BUFFER_USUAL_SIZE> buf(result->charset());
CHARSET_INFO *cs= thd->variables.character_set_client;
const char *res_cs_name= result->charset()->csname;
const char *collation_name= item->collation.collation->name;
buf.append('_');
buf.append(res_cs_name, strlen(res_cs_name));
buf.append(result->charset()->cs_name);
if (cs->escape_with_backslash_is_dangerous)
buf.append(' ');
append_query_string(cs, &buf, result->ptr(), result->length(),
thd->variables.sql_mode & MODE_NO_BACKSLASH_ESCAPES);
buf.append(STRING_WITH_LEN(" COLLATE '"));
buf.append(collation_name, strlen(collation_name));
buf.append(item->collation.collation->coll_name);
buf.append('\'');
str->copy(buf);
@ -9382,33 +9380,27 @@ LEX_CSTRING Charset::collation_specific_name() const
for character sets and collations, so a collation
name not necessarily starts with the character set name.
*/
LEX_CSTRING retval;
size_t csname_length= strlen(m_charset->csname);
if (strncmp(m_charset->name, m_charset->csname, csname_length))
{
retval.str= NULL;
retval.length= 0;
return retval;
}
const char *ptr= m_charset->name + csname_length;
retval.str= ptr;
retval.length= strlen(ptr);
return retval;
size_t cs_name_length= m_charset->cs_name.length;
if (strncmp(m_charset->coll_name.str, m_charset->cs_name.str,
cs_name_length))
return {NULL, 0};
const char *ptr= m_charset->coll_name.str + cs_name_length;
return {ptr, m_charset->coll_name.length - cs_name_length };
}
bool
Charset::encoding_allows_reinterpret_as(const CHARSET_INFO *cs) const
{
if (!strcmp(m_charset->csname, cs->csname))
if (my_charset_same(m_charset, cs))
return true;
if (!strcmp(m_charset->csname, MY_UTF8MB3) &&
!strcmp(cs->csname, MY_UTF8MB4))
if (!strcmp(m_charset->cs_name.str, MY_UTF8MB3) &&
!strcmp(cs->cs_name.str, MY_UTF8MB4))
return true;
/*
Originally we allowed here instat ALTER for ASCII-to-LATIN1
Originally we allowed here instant ALTER for ASCII-to-LATIN1
and UCS2-to-UTF16, but this was wrong:
- MariaDB's ascii is not a subset for 8-bit character sets
like latin1, because it allows storing bytes 0x80..0xFF as

7
sql/sql_view.cc
View File

@ -1094,11 +1094,10 @@ loop_out:
frm-file.
*/
lex_string_set(&view->view_client_cs_name,
view->view_creation_ctx->get_client_cs()->csname);
view->view_client_cs_name= view->view_creation_ctx->get_client_cs()->cs_name;
lex_string_set(&view->view_connection_cl_name,
view->view_creation_ctx->get_connection_cl()->name);
view->view_connection_cl_name=
view->view_creation_ctx->get_connection_cl()->coll_name;
if (!thd->make_lex_string(&view->view_body_utf8, is_query.ptr(),
is_query.length()))

10
sql/sql_yacc.yy
View File

@ -202,7 +202,7 @@ void _CONCAT_UNDERSCORED(turn_parser_debug_on,yyparse)()
{ \
if (unlikely(Lex->charset && !my_charset_same(Lex->charset,X))) \
my_yyabort_error((ER_COLLATION_CHARSET_MISMATCH, MYF(0), \
X->name,Lex->charset->csname)); \
X->coll_name.str,Lex->charset->cs_name.str)); \
Lex->charset= X; \
} \
} while(0)
@ -6581,7 +6581,7 @@ attribute:
{
if (unlikely(Lex->charset && !my_charset_same(Lex->charset,$2)))
my_yyabort_error((ER_COLLATION_CHARSET_MISMATCH, MYF(0),
$2->name,Lex->charset->csname));
$2->coll_name.str, Lex->charset->cs_name.str));
Lex->last_field->charset= $2;
}
| serial_attribute
@ -6799,7 +6799,7 @@ binary:
{
if (!my_charset_same(Lex->charset, $1))
my_yyabort_error((ER_COLLATION_CHARSET_MISMATCH, MYF(0),
Lex->charset->name, $1->csname));
Lex->charset->coll_name.str, $1->cs_name.str));
}
| collate { }
;
@ -7882,7 +7882,7 @@ alter_list_item:
$5= $5 ? $5 : $4;
if (unlikely(!my_charset_same($4,$5)))
my_yyabort_error((ER_COLLATION_CHARSET_MISMATCH, MYF(0),
$5->name, $4->csname));
$5->coll_name.str, $4->cs_name.str));
if (unlikely(Lex->create_info.add_alter_list_item_convert_to_charset($5)))
MYSQL_YYABORT;
Lex->alter_info.flags|= ALTER_CONVERT_TO;
@ -16757,7 +16757,7 @@ option_value_no_option_type:
if (unlikely(!my_charset_same(cs2, cs3)))
{
my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0),
cs3->name, cs2->csname);
cs3->coll_name.str, cs2->cs_name.str);
MYSQL_YYABORT;
}
set_var_collation_client *var;

20
sql/sys_vars.cc
View File

@ -789,12 +789,12 @@ static Sys_var_struct Sys_character_set_system(
"character_set_system", "The character set used by the server "
"for storing identifiers",
READ_ONLY GLOBAL_VAR(system_charset_info), NO_CMD_LINE,
offsetof(CHARSET_INFO, csname), DEFAULT(0));
offsetof(CHARSET_INFO, cs_name.str), DEFAULT(0));
static Sys_var_struct Sys_character_set_server(
"character_set_server", "The default character set",
SESSION_VAR(collation_server), NO_CMD_LINE,
offsetof(CHARSET_INFO, csname), DEFAULT(&default_charset_info),
offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&default_charset_info),
NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_charset_not_null));
static bool check_charset_db(sys_var *self, THD *thd, set_var *var)
@ -809,7 +809,7 @@ static Sys_var_struct Sys_character_set_database(
"character_set_database",
"The character set used by the default database",
SESSION_VAR(collation_database), NO_CMD_LINE,
offsetof(CHARSET_INFO, csname), DEFAULT(&default_charset_info),
offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&default_charset_info),
NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_charset_db));
static bool check_cs_client(sys_var *self, THD *thd, set_var *var)
@ -833,7 +833,7 @@ static Sys_var_struct Sys_character_set_client(
"character_set_client", "The character set for statements "
"that arrive from the client",
NO_SET_STMT SESSION_VAR(character_set_client), NO_CMD_LINE,
offsetof(CHARSET_INFO, csname), DEFAULT(&default_charset_info),
offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&default_charset_info),
NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_cs_client),
ON_UPDATE(fix_thd_charset));
// for check changing
@ -844,7 +844,7 @@ static Sys_var_struct Sys_character_set_connection(
"literals that do not have a character set introducer and for "
"number-to-string conversion",
NO_SET_STMT SESSION_VAR(collation_connection), NO_CMD_LINE,
offsetof(CHARSET_INFO, csname), DEFAULT(&default_charset_info),
offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&default_charset_info),
NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_charset_not_null),
ON_UPDATE(fix_thd_charset));
// for check changing
@ -854,7 +854,7 @@ static Sys_var_struct Sys_character_set_results(
"character_set_results", "The character set used for returning "
"query results to the client",
SESSION_VAR(character_set_results), NO_CMD_LINE,
offsetof(CHARSET_INFO, csname), DEFAULT(&default_charset_info),
offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&default_charset_info),
NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_charset));
// for check changing
export sys_var *Sys_character_set_results_ptr= &Sys_character_set_results;
@ -862,7 +862,7 @@ export sys_var *Sys_character_set_results_ptr= &Sys_character_set_results;
static Sys_var_struct Sys_character_set_filesystem(
"character_set_filesystem", "The filesystem character set",
NO_SET_STMT SESSION_VAR(character_set_filesystem), NO_CMD_LINE,
offsetof(CHARSET_INFO, csname), DEFAULT(&character_set_filesystem),
offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&character_set_filesystem),
NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_charset_not_null),
ON_UPDATE(fix_thd_charset));
@ -908,7 +908,7 @@ static Sys_var_struct Sys_collation_connection(
"collation_connection", "The collation of the connection "
"character set",
NO_SET_STMT SESSION_VAR(collation_connection), NO_CMD_LINE,
offsetof(CHARSET_INFO, name), DEFAULT(&default_charset_info),
offsetof(CHARSET_INFO, coll_name.str), DEFAULT(&default_charset_info),
NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_collation_not_null),
ON_UPDATE(fix_thd_charset));
@ -924,13 +924,13 @@ static Sys_var_struct Sys_collation_database(
"collation_database", "The collation of the database "
"character set",
SESSION_VAR(collation_database), NO_CMD_LINE,
offsetof(CHARSET_INFO, name), DEFAULT(&default_charset_info),
offsetof(CHARSET_INFO, coll_name.str), DEFAULT(&default_charset_info),
NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_collation_db));
static Sys_var_struct Sys_collation_server(
"collation_server", "The server default collation",
SESSION_VAR(collation_server), NO_CMD_LINE,
offsetof(CHARSET_INFO, name), DEFAULT(&default_charset_info),
offsetof(CHARSET_INFO, coll_name.str), DEFAULT(&default_charset_info),
NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_collation_not_null));
static Sys_var_uint Sys_column_compression_threshold(

9
sql/table.cc
View File

@ -2580,8 +2580,9 @@ int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
{
// 3.23 or 4.0 string
myf utf8_flag= thd->get_utf8_flag();
if (!(attr.charset= get_charset_by_csname(share->table_charset->csname,
MY_CS_BINSORT,
if (!(attr.charset= get_charset_by_csname(share->table_charset->
cs_name.str,
MY_CS_BINSORT,
MYF(utf8_flag))))
attr.charset= &my_charset_bin;
}
@ -5187,7 +5188,7 @@ Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
error= TRUE;
}
else if (field_def->cset.str &&
strcmp(field->charset()->csname, field_def->cset.str))
strcmp(field->charset()->cs_name.str, field_def->cset.str))
{
report_error(0, "Incorrect definition of table %s.%s: "
"expected the type of column '%s' at position %d "
@ -5195,7 +5196,7 @@ Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
"character set '%s'.", table->s->db.str,
table->alias.c_ptr(),
field_def->name.str, i, field_def->cset.str,
field->charset()->csname);
field->charset()->cs_name.str);
error= TRUE;
}
}

8
sql/wsrep_sst.cc
View File

@ -1526,10 +1526,10 @@ static int sst_flush_tables(THD* thd)
if (!is_supported_parser_charset(current_charset))
{
/* Do not use non-supported parser character sets */
WSREP_WARN("Current client character set is non-supported parser character set: %s", current_charset->csname);
WSREP_WARN("Current client character set is non-supported parser character set: %s", current_charset->cs_name.str);
thd->variables.character_set_client= &my_charset_latin1;
WSREP_WARN("For SST temporally setting character set to : %s",
my_charset_latin1.csname);
my_charset_latin1.cs_name.str);
}
if (run_sql_command(thd, "FLUSH TABLES WITH READ LOCK"))
@ -1628,10 +1628,10 @@ static void sst_disallow_writes (THD* thd, bool yes)
if (!is_supported_parser_charset(current_charset))
{
/* Do not use non-supported parser character sets */
WSREP_WARN("Current client character set is non-supported parser character set: %s", current_charset->csname);
WSREP_WARN("Current client character set is non-supported parser character set: %s", current_charset->cs_name.str);
thd->variables.character_set_client= &my_charset_latin1;
WSREP_WARN("For SST temporally setting character set to : %s",
my_charset_latin1.csname);
my_charset_latin1.cs_name.str);
}
snprintf (query_str, query_max, "SET GLOBAL innodb_disallow_writes=%d",

7
storage/connect/ha_connect.cc
View File

@ -1443,7 +1443,7 @@ PCSZ ha_connect::GetStringOption(PCSZ opname, PCSZ sdef)
: table->s->table_charset;
if (chif)
opval= (char*)chif->csname;
opval= (char*)chif->cs_name.str;
} else
opval= GetStringTableOption(xp->g, options, opname, NULL);
@ -1607,7 +1607,7 @@ void *ha_connect::GetColumnOption(PGLOBAL g, void *field, PCOLINFO pcf)
// Now get column information
pcf->Name= (char*)fp->field_name.str;
chset = (char*)fp->charset()->name;
chset= (char*)fp->charset()->coll_name.str;
if (fop && fop->special) {
pcf->Fieldfmt= (char*)fop->special;
@ -5591,8 +5591,7 @@ static int init_table_share(THD* thd,
if (create_info->default_table_charset) {
oom|= sql->append(' ');
oom|= sql->append(STRING_WITH_LEN("CHARSET="));
oom|= sql->append(create_info->default_table_charset->csname,
strlen(create_info->default_table_charset->csname));
oom|= sql->append(create_info->default_table_charset->cs_name);
if (oom)
return HA_ERR_OUT_OF_MEM;

2
storage/connect/tabutil.cpp
View File

@ -285,7 +285,7 @@ PQRYRES TabColumns(PGLOBAL g, THD *thd, const char *db,
crp->Kdata->SetValue((fmt) ? fmt : (char*) "", i);
crp = crp->Next; // New (charset)
fld = (char *)fp->charset()->name;
fld = (char *)fp->charset()->coll_name.str;
crp->Kdata->SetValue(fld, i);
// Add this item

2
storage/federated/ha_federated.cc
View File

@ -3143,7 +3143,7 @@ int ha_federated::real_connect()
*/
/* this sets the csname like 'set names utf8' */
mysql_options(mysql,MYSQL_SET_CHARSET_NAME,
this->table->s->table_charset->csname);
this->table->s->table_charset->cs_name.str);
sql_query.length(0);
if (!mysql_real_connect(mysql,

4
storage/federatedx/ha_federatedx.cc
View File

@ -1523,7 +1523,7 @@ static void fill_server(MEM_ROOT *mem_root, FEDERATEDX_SERVER *server,
server->password= NULL;
if (table_charset)
server->csname= strdup_root(mem_root, table_charset->csname);
server->csname= strdup_root(mem_root, table_charset->cs_name.str);
DBUG_VOID_RETURN;
}
@ -3648,7 +3648,7 @@ int ha_federatedx::discover_assisted(handlerton *hton, THD* thd,
return HA_WRONG_CREATE_OPTION;
mysql_init(&mysql);
mysql_options(&mysql, MYSQL_SET_CHARSET_NAME, cs->csname);
mysql_options(&mysql, MYSQL_SET_CHARSET_NAME, cs->cs_name.str);
mysql_options(&mysql, MYSQL_OPT_USE_THREAD_SPECIFIC_MEMORY, (char*)&my_true);
if (!mysql_real_connect(&mysql, tmp_share.hostname, tmp_share.username,

46
storage/mroonga/lib/mrn_encoding.cpp
View File

@ -42,50 +42,50 @@ namespace mrn {
{
if (!cs[0])
continue;
if (!strcmp(cs[0]->csname, "utf8mb3"))
if (!strcmp(cs[0]->cs_name.str, "utf8mb3"))
{
DBUG_PRINT("info", ("mroonga: %s is %s [%p]",
cs[0]->name, cs[0]->csname, cs[0]->cset));
cs[0]->coll_name.str, cs[0]->cs_name.str, cs[0]->cset));
if (!mrn_charset_utf8)
mrn_charset_utf8 = cs[0];
else if (mrn_charset_utf8->cset != cs[0]->cset)
DBUG_ASSERT(0);
continue;
}
if (!strcmp(cs[0]->csname, "utf8mb4"))
if (!strcmp(cs[0]->cs_name.str, "utf8mb4"))
{
DBUG_PRINT("info", ("mroonga: %s is %s [%p]",
cs[0]->name, cs[0]->csname, cs[0]->cset));
cs[0]->coll_name.str, cs[0]->cs_name.str, cs[0]->cset));
if (!mrn_charset_utf8mb4)
mrn_charset_utf8mb4 = cs[0];
else if (mrn_charset_utf8mb4->cset != cs[0]->cset)
DBUG_ASSERT(0);
continue;
}
if (!strcmp(cs[0]->csname, "binary"))
if (!strcmp(cs[0]->cs_name.str, "binary"))
{
DBUG_PRINT("info", ("mroonga: %s is %s [%p]",
cs[0]->name, cs[0]->csname, cs[0]->cset));
cs[0]->coll_name.str, cs[0]->cs_name.str, cs[0]->cset));
if (!mrn_charset_binary)
mrn_charset_binary = cs[0];
else if (mrn_charset_binary->cset != cs[0]->cset)
DBUG_ASSERT(0);
continue;
}
if (!strcmp(cs[0]->csname, "ascii"))
if (!strcmp(cs[0]->cs_name.str, "ascii"))
{
DBUG_PRINT("info", ("mroonga: %s is %s [%p]",
cs[0]->name, cs[0]->csname, cs[0]->cset));
cs[0]->coll_name.str, cs[0]->cs_name.str, cs[0]->cset));
if (!mrn_charset_ascii)
mrn_charset_ascii = cs[0];
else if (mrn_charset_ascii->cset != cs[0]->cset)
DBUG_ASSERT(0);
continue;
}
if (!strcmp(cs[0]->csname, "latin1"))
if (!strcmp(cs[0]->cs_name.str, "latin1"))
{
DBUG_PRINT("info", ("mroonga: %s is %s [%p]",
cs[0]->name, cs[0]->csname, cs[0]->cset));
cs[0]->coll_name.str, cs[0]->cs_name.str, cs[0]->cset));
if (!mrn_charset_latin1_1)
mrn_charset_latin1_1 = cs[0];
else if (mrn_charset_latin1_1->cset != cs[0]->cset)
@ -97,50 +97,50 @@ namespace mrn {
}
continue;
}
if (!strcmp(cs[0]->csname, "cp932"))
if (!strcmp(cs[0]->cs_name.str, "cp932"))
{
DBUG_PRINT("info", ("mroonga: %s is %s [%p]",
cs[0]->name, cs[0]->csname, cs[0]->cset));
cs[0]->coll_name.str, cs[0]->cs_name.str, cs[0]->cset));
if (!mrn_charset_cp932)
mrn_charset_cp932 = cs[0];
else if (mrn_charset_cp932->cset != cs[0]->cset)
DBUG_ASSERT(0);
continue;
}
if (!strcmp(cs[0]->csname, "sjis"))
if (!strcmp(cs[0]->cs_name.str, "sjis"))
{
DBUG_PRINT("info", ("mroonga: %s is %s [%p]",
cs[0]->name, cs[0]->csname, cs[0]->cset));
cs[0]->coll_name.str, cs[0]->cs_name.str, cs[0]->cset));
if (!mrn_charset_sjis)
mrn_charset_sjis = cs[0];
else if (mrn_charset_sjis->cset != cs[0]->cset)
DBUG_ASSERT(0);
continue;
}
if (!strcmp(cs[0]->csname, "eucjpms"))
if (!strcmp(cs[0]->cs_name.str, "eucjpms"))
{
DBUG_PRINT("info", ("mroonga: %s is %s [%p]",
cs[0]->name, cs[0]->csname, cs[0]->cset));
cs[0]->coll_name.str, cs[0]->cs_name.str, cs[0]->cset));
if (!mrn_charset_eucjpms)
mrn_charset_eucjpms = cs[0];
else if (mrn_charset_eucjpms->cset != cs[0]->cset)
DBUG_ASSERT(0);
continue;
}
if (!strcmp(cs[0]->csname, "ujis"))
if (!strcmp(cs[0]->cs_name.str, "ujis"))
{
DBUG_PRINT("info", ("mroonga: %s is %s [%p]",
cs[0]->name, cs[0]->csname, cs[0]->cset));
cs[0]->coll_name.str, cs[0]->cs_name.str, cs[0]->cset));
if (!mrn_charset_ujis)
mrn_charset_ujis = cs[0];
else if (mrn_charset_ujis->cset != cs[0]->cset)
DBUG_ASSERT(0);
continue;
}
if (!strcmp(cs[0]->csname, "koi8r"))
if (!strcmp(cs[0]->cs_name.str, "koi8r"))
{
DBUG_PRINT("info", ("mroonga: %s is %s [%p]",
cs[0]->name, cs[0]->csname, cs[0]->cset));
cs[0]->coll_name.str, cs[0]->cs_name.str, cs[0]->cset));
if (!mrn_charset_koi8r)
mrn_charset_koi8r = cs[0];
else if (mrn_charset_koi8r->cset != cs[0]->cset)
@ -148,7 +148,7 @@ namespace mrn {
continue;
}
DBUG_PRINT("info", ("mroonga: %s[%s][%p] is not supported",
cs[0]->name, cs[0]->csname, cs[0]->cset));
cs[0]->coll_name.str, cs[0]->cs_name.str, cs[0]->cset));
}
DBUG_VOID_RETURN;
}
@ -161,8 +161,8 @@ namespace mrn {
const char *name = "<null>";
const char *csname = "<null>";
if (charset) {
name = charset->name;
csname = charset->csname;
name = charset->coll_name.str;
csname = charset->cs_name.str;
}
error = ER_MRN_CHARSET_NOT_SUPPORT_NUM;
my_printf_error(error,

18
storage/mroonga/lib/mrn_field_normalizer.cpp
View File

@ -39,9 +39,9 @@ namespace mrn {
DBUG_PRINT("info",
("mroonga: result_type = %u", field_->result_type()));
DBUG_PRINT("info",
("mroonga: charset->name = %s", field_->charset()->name));
("mroonga: charset->name = %s", field_->charset()->coll_name.str));
DBUG_PRINT("info",
("mroonga: charset->csname = %s", field_->charset()->csname));
("mroonga: charset->csname = %s", field_->charset()->cs_name.str));
DBUG_PRINT("info",
("mroonga: charset->state = %u", field_->charset()->state));
bool need_normalize_p;
@ -108,14 +108,14 @@ namespace mrn {
const CHARSET_INFO *charset_info = field_->charset();
const char *normalizer_name = NULL;
const char *default_normalizer_name = "NormalizerAuto";
if ((strcmp(charset_info->name, "utf8mb3_general_ci") == 0) ||
(strcmp(charset_info->name, "utf8mb4_general_ci") == 0)) {
if ((strcmp(charset_info->coll_name.str, "utf8mb3_general_ci") == 0) ||
(strcmp(charset_info->coll_name.str, "utf8mb4_general_ci") == 0)) {
normalizer_name = "NormalizerMySQLGeneralCI";
} else if ((strcmp(charset_info->name, "utf8mb3_unicode_ci") == 0) ||
(strcmp(charset_info->name, "utf8mb4_unicode_ci") == 0)) {
} else if ((strcmp(charset_info->coll_name.str, "utf8mb3_unicode_ci") == 0) ||
(strcmp(charset_info->coll_name.str, "utf8mb4_unicode_ci") == 0)) {
normalizer_name = "NormalizerMySQLUnicodeCI";
} else if ((strcmp(charset_info->name, "utf8mb3_unicode_520_ci") == 0) ||
(strcmp(charset_info->name, "utf8mb4_unicode_520_ci") == 0)) {
} else if ((strcmp(charset_info->coll_name.str, "utf8mb3_unicode_520_ci") == 0) ||
(strcmp(charset_info->coll_name.str, "utf8mb4_unicode_520_ci") == 0)) {
normalizer_name = "NormalizerMySQLUnicode520CI";
}
@ -129,7 +129,7 @@ namespace mrn {
"Install groonga-normalizer-mysql normalizer. "
"%s is used as fallback.",
normalizer_name,
charset_info->name,
charset_info->coll_name.str,
default_normalizer_name);
push_warning(thread_, MRN_SEVERITY_WARNING,
HA_ERR_UNSUPPORTED, error_message);

2
storage/mroonga/udf/mrn_udf_snippet.cpp
View File

@ -82,7 +82,7 @@ static my_bool mrn_snippet_prepare(st_mrn_snip_info *snip_info, UDF_ARGS *args,
}
if (!mrn::encoding::set_raw(ctx, cs)) {
snprintf(message, MYSQL_ERRMSG_SIZE,
"Unsupported charset: <%s>", cs->name);
"Unsupported charset: <%s>", cs->coll_name.str);
goto error;
}

2
storage/rocksdb/rdb_datadic.cc
View File

@ -3417,7 +3417,7 @@ bool Rdb_field_packing::setup(const Rdb_key_def *const key_descr,
sql_print_warning(
"RocksDB: you're trying to create an index "
"with a multi-level collation %s",
cs->name);
cs->cs_name.str);
// NO_LINT_DEBUG
sql_print_warning(
"MyRocks will handle this collation internally "

10
storage/spider/spd_db_conn.cc
View File

@ -929,7 +929,7 @@ int spider_db_set_names_internal(
) {
if (
spider_db_before_query(conn, need_mon) ||
conn->db_conn->set_character_set(share->access_charset->csname)
conn->db_conn->set_character_set(share->access_charset->cs_name.str)
) {
DBUG_RETURN(spider_db_errorno(conn));
}
@ -2730,8 +2730,8 @@ int spider_db_append_charset_name_before_string(
spider_string *str,
CHARSET_INFO *cs
) {
const char *csname = cs->csname;
uint csname_length = strlen(csname);
const char *csname = cs->cs_name.str;
uint csname_length = cs->cs_name.length;
DBUG_ENTER("spider_db_append_charset_name_before_string");
if (str->reserve(SPIDER_SQL_UNDERSCORE_LEN + csname_length))
{
@ -3089,7 +3089,7 @@ int spider_db_fetch_row(
Time_zone *saved_time_zone = thd->variables.time_zone;
DBUG_ENTER("spider_db_fetch_row");
DBUG_PRINT("info", ("spider field_name %s", SPIDER_field_name_str(field)));
DBUG_PRINT("info", ("spider fieldcharset %s", field->charset()->csname));
DBUG_PRINT("info", ("spider fieldcharset %s", field->charset()->cs_name.str));
thd->variables.time_zone = UTC;
@ -11305,7 +11305,7 @@ int spider_db_udf_direct_sql_set_names(
if (
(
spider_db_before_query(conn, &need_mon) ||
conn->db_conn->set_character_set(trx->udf_access_charset->csname)
conn->db_conn->set_character_set(trx->udf_access_charset->cs_name.str)
) &&
(error_num = spider_db_errorno(conn))
) {

20
storage/spider/spd_db_mysql.cc
View File

@ -6890,11 +6890,11 @@ int spider_db_mbase_util::open_item_func(
(Item_func_conv_charset *)item_func;
CHARSET_INFO *conv_charset =
item_func_conv_charset->SPIDER_Item_func_conv_charset_conv_charset;
uint cset_length = strlen(conv_charset->csname);
uint cset_length = conv_charset->cs_name.length;
if (str->reserve(SPIDER_SQL_USING_LEN + cset_length))
DBUG_RETURN(HA_ERR_OUT_OF_MEM);
str->q_append(SPIDER_SQL_USING_STR, SPIDER_SQL_USING_LEN);
str->q_append(conv_charset->csname, cset_length);
str->q_append(conv_charset->cs_name.str, cset_length);
}
}
}
@ -7036,8 +7036,8 @@ int spider_db_mbase_util::append_escaped_util(
) {
DBUG_ENTER("spider_db_mbase_util::append_escaped_util");
DBUG_PRINT("info",("spider this=%p", this));
DBUG_PRINT("info",("spider from=%s", from->charset()->csname));
DBUG_PRINT("info",("spider to=%s", to->charset()->csname));
DBUG_PRINT("info",("spider from=%s", from->charset()->cs_name.str));
DBUG_PRINT("info",("spider to=%s", to->charset()->cs_name.str));
to->append_escape_string(from->ptr(), from->length());
DBUG_RETURN(0);
}
@ -9051,11 +9051,11 @@ int spider_mbase_handler::append_key_column_types(
if (field->has_charset())
{
CHARSET_INFO *cs = field->charset();
uint coll_length = strlen(cs->name);
uint coll_length = cs->coll_name.length;
if (str->reserve(SPIDER_SQL_COLLATE_LEN + coll_length))
DBUG_RETURN(HA_ERR_OUT_OF_MEM);
str->q_append(SPIDER_SQL_COLLATE_STR, SPIDER_SQL_COLLATE_LEN);
str->q_append(cs->name, coll_length);
str->q_append(cs->coll_name.str, coll_length);
}
if (str->reserve(SPIDER_SQL_COMMA_LEN))
@ -9304,8 +9304,8 @@ int spider_mbase_handler::append_create_tmp_bka_table(
THD *thd = spider->wide_handler->trx->thd;
char *bka_engine = spider_param_bka_engine(thd, share->bka_engine);
uint bka_engine_length = strlen(bka_engine),
cset_length = strlen(table_charset->csname),
coll_length = strlen(table_charset->name);
cset_length = table_charset->cs_name.length,
coll_length = table_charset->coll_name.length;
DBUG_ENTER("spider_mbase_handler::append_create_tmp_bka_table");
if (str->reserve(SPIDER_SQL_CREATE_TMP_LEN + tmp_table_name_length +
SPIDER_SQL_OPEN_PAREN_LEN + SPIDER_SQL_ID_LEN + SPIDER_SQL_ID_TYPE_LEN +
@ -9327,9 +9327,9 @@ int spider_mbase_handler::append_create_tmp_bka_table(
str->q_append(SPIDER_SQL_ENGINE_STR, SPIDER_SQL_ENGINE_LEN);
str->q_append(bka_engine, bka_engine_length);
str->q_append(SPIDER_SQL_DEF_CHARSET_STR, SPIDER_SQL_DEF_CHARSET_LEN);
str->q_append(table_charset->csname, cset_length);
str->q_append(table_charset->cs_name.str, cset_length);
str->q_append(SPIDER_SQL_COLLATE_STR, SPIDER_SQL_COLLATE_LEN);
str->q_append(table_charset->name, coll_length);
str->q_append(table_charset->coll_name.str, coll_length);
str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
DBUG_RETURN(0);
}

8
storage/spider/spd_table.cc
View File

@ -10050,8 +10050,8 @@ int spider_discover_table_structure(
} else {
table_charset = system_charset_info;
}
uint csnamelen = strlen(table_charset->csname);
uint collatelen = strlen(table_charset->name);
uint csnamelen = table_charset->cs_name.length;
uint collatelen = table_charset->coll_name.length;
if (str.reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_DEFAULT_CHARSET_LEN +
csnamelen + SPIDER_SQL_COLLATE_LEN + collatelen +
SPIDER_SQL_CONNECTION_LEN + SPIDER_SQL_VALUE_QUOTE_LEN +
@ -10061,9 +10061,9 @@ int spider_discover_table_structure(
}
str.q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
str.q_append(SPIDER_SQL_DEFAULT_CHARSET_STR, SPIDER_SQL_DEFAULT_CHARSET_LEN);
str.q_append(table_charset->csname, csnamelen);
str.q_append(table_charset->cs_name.str, csnamelen);
str.q_append(SPIDER_SQL_COLLATE_STR, SPIDER_SQL_COLLATE_LEN);
str.q_append(table_charset->name, collatelen);
str.q_append(table_charset->coll_name.str, collatelen);
str.q_append(SPIDER_SQL_COMMENT_STR, SPIDER_SQL_COMMENT_LEN);
str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
str.append_escape_string(share->comment.str, share->comment.length);

17
strings/ctype-big5.c
View File

@ -33,6 +33,7 @@
#ifdef HAVE_CHARSET_big5
const char charset_name_big5[]= "big5";
#define charset_name_big5_length (sizeof(charset_name_big5) -1)
/*
Support for Chinese(BIG5) characters, by jou@nematic.ieo.nctu.edu.tw
@ -6809,8 +6810,8 @@ struct charset_info_st my_charset_big5_chinese_ci=
{
1,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM, /* state */
charset_name_big5, /* cs name */
"big5_chinese_ci", /* name */
{ charset_name_big5, charset_name_big5_length }, /* cs name */
{ STRING_WITH_LEN("big5_chinese_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_big5,
@ -6842,8 +6843,8 @@ struct charset_info_st my_charset_big5_bin=
{
84,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT, /* state */
charset_name_big5, /* cs name */
"big5_bin", /* name */
{ charset_name_big5, charset_name_big5_length }, /* cs name */
{ STRING_WITH_LEN("big5_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_big5,
@ -6875,8 +6876,8 @@ struct charset_info_st my_charset_big5_chinese_nopad_ci=
{
MY_NOPAD_ID(1),0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_NOPAD, /* state */
charset_name_big5, /* cs name */
"big5_chinese_nopad_ci", /* name */
{ charset_name_big5, charset_name_big5_length }, /* cs name */
{ STRING_WITH_LEN("big5_chinese_nopad_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_big5,
@ -6908,8 +6909,8 @@ struct charset_info_st my_charset_big5_nopad_bin=
{
MY_NOPAD_ID(84),0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_NOPAD, /* state */
charset_name_big5, /* cs name */
"big5_nopad_bin", /* name */
{ charset_name_big5, charset_name_big5_length }, /* cs name */
{ STRING_WITH_LEN("big5_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_big5,

5
strings/ctype-bin.c
View File

@ -24,6 +24,7 @@
#include <m_ctype.h>
const char charset_name_binary[]= "binary";
#define charset_name_binary_length (sizeof(charset_name_binary)-1)
static const uchar ctype_bin[]=
{
@ -570,8 +571,8 @@ struct charset_info_st my_charset_bin =
{
63,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_PRIMARY|MY_CS_NOPAD,/* state */
charset_name_binary, /* cs name */
"binary", /* name */
{ charset_name_binary, charset_name_binary_length}, /* cs name */
{ STRING_WITH_LEN("binary")}, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_bin, /* ctype */

17
strings/ctype-cp932.c
View File

@ -23,6 +23,7 @@
#ifdef HAVE_CHARSET_cp932
const char charset_name_cp932[]= "cp932";
#define charset_name_cp932_length (sizeof(charset_name_cp932)-1)
/*
* This comment is parsed by configure to create ctype.c,
@ -34765,8 +34766,8 @@ struct charset_info_st my_charset_cp932_japanese_ci=
{
95,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM, /* state */
charset_name_cp932, /* cs name */
"cp932_japanese_ci", /* name */
{ charset_name_cp932, charset_name_cp932_length }, /* cs name */
{ STRING_WITH_LEN("cp932_japanese_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_cp932,
@ -34797,8 +34798,8 @@ struct charset_info_st my_charset_cp932_bin=
{
96,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT, /* state */
charset_name_cp932, /* cs name */
"cp932_bin", /* name */
{ charset_name_cp932, charset_name_cp932_length }, /* cs name */
{ STRING_WITH_LEN("cp932_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_cp932,
@ -34830,8 +34831,8 @@ struct charset_info_st my_charset_cp932_japanese_nopad_ci=
{
MY_NOPAD_ID(95),0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_NOPAD, /* state */
charset_name_cp932, /* cs name */
"cp932_japanese_nopad_ci",/* name */
{ charset_name_cp932, charset_name_cp932_length }, /* cs name */
{ STRING_WITH_LEN("cp932_japanese_nopad_ci") },/* name */
"", /* comment */
NULL, /* tailoring */
ctype_cp932,
@ -34862,8 +34863,8 @@ struct charset_info_st my_charset_cp932_nopad_bin=
{
MY_NOPAD_ID(96),0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_NOPAD, /* state */
charset_name_cp932, /* cs name */
"cp932_nopad_bin", /* name */
{ charset_name_cp932, charset_name_cp932_length }, /* cs name */
{ STRING_WITH_LEN("cp932_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_cp932,

4
strings/ctype-czech.c
View File

@ -625,8 +625,8 @@ struct charset_info_st my_charset_latin2_czech_ci =
2,0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_CSSORT|
MY_CS_STRNXFRM_BAD_NWEIGHTS|MY_CS_NON1TO1, /* state */
charset_name_latin2, /* cs name */
"latin2_czech_cs", /* name */
{ charset_name_latin2, charset_name_latin2_length}, /* cs_name */
{ STRING_WITH_LEN("latin2_czech_cs")}, /* col_name */
"", /* comment */
NULL, /* tailoring */
ctype_czech,

17
strings/ctype-euc_kr.c
View File

@ -32,6 +32,7 @@
#ifdef HAVE_CHARSET_euckr
const char charset_name_euckr[]= "euckr";
#define charset_name_euckr_length sizeof(charset_name_euckr)-1
static const uchar ctype_euc_kr[257] =
{
@ -10055,8 +10056,8 @@ struct charset_info_st my_charset_euckr_korean_ci=
{
19,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY, /* state */
charset_name_euckr, /* cs name */
"euckr_korean_ci", /* name */
{ charset_name_euckr, charset_name_euckr_length }, /* cs name */
{ STRING_WITH_LEN("euckr_korean_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_euc_kr,
@ -10088,8 +10089,8 @@ struct charset_info_st my_charset_euckr_bin=
{
85,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT, /* state */
charset_name_euckr, /* cs name */
"euckr_bin", /* name */
{ charset_name_euckr, charset_name_euckr_length }, /* cs name */
{ STRING_WITH_LEN("euckr_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_euc_kr,
@ -10121,8 +10122,8 @@ struct charset_info_st my_charset_euckr_korean_nopad_ci=
{
MY_NOPAD_ID(19),0,0,/* number */
MY_CS_COMPILED|MY_CS_NOPAD, /* state */
charset_name_euckr, /* cs name */
"euckr_korean_nopad_ci", /* name */
{ charset_name_euckr, charset_name_euckr_length }, /* cs name */
{ STRING_WITH_LEN("euckr_korean_nopad_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_euc_kr,
@ -10154,8 +10155,8 @@ struct charset_info_st my_charset_euckr_nopad_bin=
{
MY_NOPAD_ID(85),0,0,/* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_NOPAD, /* state */
charset_name_euckr, /* cs name */
"euckr_nopad_bin", /* name */
{ charset_name_euckr, charset_name_euckr_length }, /* cs name */
{ STRING_WITH_LEN("euckr_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_euc_kr,

18
strings/ctype-eucjpms.c
View File

@ -34,7 +34,7 @@ ctype-ujis.c file.
#ifdef HAVE_CHARSET_eucjpms
const char charset_name_eucjpms[]= "eucjpms";
#define charset_name_eucjpms_length (sizeof(charset_name_eucjpms) - 1)
static const uchar ctype_eucjpms[257] =
{
@ -67595,8 +67595,8 @@ struct charset_info_st my_charset_eucjpms_japanese_ci=
{
97,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY, /* state */
charset_name_eucjpms, /* cs name */
"eucjpms_japanese_ci", /* name */
{ charset_name_eucjpms, charset_name_eucjpms_length }, /* csname */
{ STRING_WITH_LEN("eucjpms_japanese_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_eucjpms,
@ -67628,8 +67628,8 @@ struct charset_info_st my_charset_eucjpms_bin=
{
98,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT, /* state */
charset_name_eucjpms, /* cs name */
"eucjpms_bin", /* name */
{ charset_name_eucjpms, charset_name_eucjpms_length }, /* csname */
{ STRING_WITH_LEN("eucjpms_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_eucjpms,
@ -67661,8 +67661,8 @@ struct charset_info_st my_charset_eucjpms_japanese_nopad_ci=
{
MY_NOPAD_ID(97),0,0, /* number */
MY_CS_COMPILED|MY_CS_NOPAD,/* state */
charset_name_eucjpms, /* cs name */
"eucjpms_japanese_nopad_ci", /* name */
{ charset_name_eucjpms, charset_name_eucjpms_length }, /* csname */
{ STRING_WITH_LEN("eucjpms_japanese_nopad_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_eucjpms,
@ -67694,8 +67694,8 @@ struct charset_info_st my_charset_eucjpms_nopad_bin=
{
MY_NOPAD_ID(98),0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_NOPAD, /* state */
charset_name_eucjpms, /* cs name */
"eucjpms_nopad_bin", /* name */
{ charset_name_eucjpms, charset_name_eucjpms_length }, /* csname */
{ STRING_WITH_LEN("eucjpms_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_eucjpms,

434
strings/ctype-extra.c
View File

File diff suppressed because it is too large Load Diff

17
strings/ctype-gb2312.c
View File

@ -30,6 +30,7 @@
#ifdef HAVE_CHARSET_gb2312
const char charset_name_gb2312[]= "gb2312";
#define charset_name_gb2312_length sizeof(charset_name_gb2312)-1
static const uchar ctype_gb2312[257] =
{
@ -6461,8 +6462,8 @@ struct charset_info_st my_charset_gb2312_chinese_ci=
{
24,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY, /* state */
charset_name_gb2312, /* cs name */
"gb2312_chinese_ci",/* name */
{ charset_name_gb2312, charset_name_gb2312_length}, /* cs name */
{ STRING_WITH_LEN("gb2312_chinese_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_gb2312,
@ -6494,8 +6495,8 @@ struct charset_info_st my_charset_gb2312_bin=
{
86,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT, /* state */
charset_name_gb2312, /* cs name */
"gb2312_bin", /* name */
{ charset_name_gb2312, charset_name_gb2312_length}, /* cs name */
{ STRING_WITH_LEN("gb2312_bin") }, /* col name */
"", /* comment */
NULL, /* tailoring */
ctype_gb2312,
@ -6527,8 +6528,8 @@ struct charset_info_st my_charset_gb2312_chinese_nopad_ci=
{
MY_NOPAD_ID(24),0,0,/* number */
MY_CS_COMPILED|MY_CS_NOPAD, /* state */
charset_name_gb2312, /* cs name */
"gb2312_chinese_nopad_ci",/* name */
{ charset_name_gb2312, charset_name_gb2312_length}, /* cs name */
{ STRING_WITH_LEN("gb2312_chinese_nopad_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_gb2312,
@ -6560,8 +6561,8 @@ struct charset_info_st my_charset_gb2312_nopad_bin=
{
MY_NOPAD_ID(86),0,0,/* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_NOPAD, /* state */
charset_name_gb2312, /* cs name */
"gb2312_nopad_bin", /* name */
{ charset_name_gb2312, charset_name_gb2312_length}, /* cs name */
{ STRING_WITH_LEN("gb2312_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_gb2312,

17
strings/ctype-gbk.c
View File

@ -32,6 +32,7 @@
#ifdef HAVE_CHARSET_gbk
const char charset_name_gbk[]= "gbk";
#define charset_name_gbk_length (sizeof(charset_name_gbk) -1)
/* Support for Chinese(GBK) characters, by hewei@mail.ied.ac.cn */
@ -10742,8 +10743,8 @@ struct charset_info_st my_charset_gbk_chinese_ci=
{
28,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM, /* state */
charset_name_gbk, /* cs name */
"gbk_chinese_ci", /* name */
{ charset_name_gbk, charset_name_gbk_length }, /* cs name */
{ STRING_WITH_LEN("gbk_chinese_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_gbk,
@ -10774,8 +10775,8 @@ struct charset_info_st my_charset_gbk_bin=
{
87,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT, /* state */
charset_name_gbk, /* cs name */
"gbk_bin", /* name */
{ charset_name_gbk, charset_name_gbk_length }, /* cs name */
{ STRING_WITH_LEN("gbk_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_gbk,
@ -10807,8 +10808,8 @@ struct charset_info_st my_charset_gbk_chinese_nopad_ci=
{
MY_NOPAD_ID(28),0,0,/* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_NOPAD, /* state */
charset_name_gbk, /* cs name */
"gbk_chinese_nopad_ci",/* name */
{ charset_name_gbk, charset_name_gbk_length }, /* cs name */
{ STRING_WITH_LEN("gbk_chinese_nopad_ci") },/* name */
"", /* comment */
NULL, /* tailoring */
ctype_gbk,
@ -10839,8 +10840,8 @@ struct charset_info_st my_charset_gbk_nopad_bin=
{
MY_NOPAD_ID(87),0,0,/* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_NOPAD, /* state */
charset_name_gbk, /* cs name */
"gbk_nopad_bin", /* name */
{ charset_name_gbk, charset_name_gbk_length }, /* cs name */
{ STRING_WITH_LEN("gbk_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_gbk,

21
strings/ctype-latin1.c
View File

@ -19,6 +19,7 @@
#include <m_ctype.h>
const char charset_name_latin1[]= "latin1";
#define charset_name_latin1_length sizeof(charset_name_latin1)-1
static const uchar ctype_latin1[] = {
0,
@ -433,8 +434,8 @@ struct charset_info_st my_charset_latin1=
{
8,0,0, /* number */
MY_CS_COMPILED | MY_CS_PRIMARY, /* state */
charset_name_latin1, /* cs name */
"latin1_swedish_ci", /* name */
{ charset_name_latin1, charset_name_latin1_length }, /* cs_name */
{ STRING_WITH_LEN("latin1_swedish_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_latin1,
@ -466,8 +467,8 @@ struct charset_info_st my_charset_latin1_nopad=
{
MY_NOPAD_ID(8),0,0, /* number */
MY_CS_COMPILED | MY_CS_NOPAD, /* state */
charset_name_latin1, /* cs name */
"latin1_swedish_nopad_ci", /* name */
{ charset_name_latin1, charset_name_latin1_length }, /* cs_name */
{ STRING_WITH_LEN("latin1_swedish_nopad_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_latin1,
@ -744,8 +745,8 @@ struct charset_info_st my_charset_latin1_german2_ci=
{
31,0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_NON1TO1, /* state */
charset_name_latin1, /* cs name */
"latin1_german2_ci", /* name */
{ charset_name_latin1, charset_name_latin1_length}, /* cs_name */
{ STRING_WITH_LEN("latin1_german2_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_latin1,
@ -777,8 +778,8 @@ struct charset_info_st my_charset_latin1_bin=
{
47,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT, /* state */
charset_name_latin1, /* cs name */
"latin1_bin", /* name */
{ charset_name_latin1, charset_name_latin1_length}, /* cs_name */
{ STRING_WITH_LEN("latin1_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_latin1,
@ -810,8 +811,8 @@ struct charset_info_st my_charset_latin1_nopad_bin=
{
MY_NOPAD_ID(47),0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_NOPAD,/* state */
charset_name_latin1, /* cs name */
"latin1_nopad_bin", /* name */
{ charset_name_latin1, charset_name_latin1_length}, /* cs_name */
{ STRING_WITH_LEN("latin1_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_latin1,

17
strings/ctype-sjis.c
View File

@ -23,6 +23,7 @@
#ifdef HAVE_CHARSET_sjis
const char charset_name_sjis[]= "sjis";
#define charset_name_sjis_length (sizeof(charset_name_sjis)-1)
/*
* This comment is parsed by configure to create ctype.c,
@ -34153,8 +34154,8 @@ struct charset_info_st my_charset_sjis_japanese_ci=
{
13,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM|MY_CS_NONASCII, /* state */
charset_name_sjis, /* cs name */
"sjis_japanese_ci", /* name */
{ charset_name_sjis, charset_name_sjis_length }, /* cs name */
{ STRING_WITH_LEN("sjis_japanese_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_sjis,
@ -34185,8 +34186,8 @@ struct charset_info_st my_charset_sjis_bin=
{
88,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_NONASCII, /* state */
charset_name_sjis, /* cs name */
"sjis_bin", /* name */
{ charset_name_sjis, charset_name_sjis_length }, /* cs name */
{ STRING_WITH_LEN("sjis_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_sjis,
@ -34218,8 +34219,8 @@ struct charset_info_st my_charset_sjis_japanese_nopad_ci=
{
MY_NOPAD_ID(13),0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_NONASCII|MY_CS_NOPAD, /* state */
charset_name_sjis, /* cs name */
"sjis_japanese_nopad_ci", /* name */
{ charset_name_sjis, charset_name_sjis_length }, /* cs name */
{ STRING_WITH_LEN("sjis_japanese_nopad_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_sjis,
@ -34250,8 +34251,8 @@ struct charset_info_st my_charset_sjis_nopad_bin=
{
MY_NOPAD_ID(88),0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_NONASCII|MY_CS_NOPAD, /* state */
charset_name_sjis, /* cs name */
"sjis_nopad_bin", /* name */
{ charset_name_sjis, charset_name_sjis_length }, /* cs name */
{ STRING_WITH_LEN("sjis_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_sjis,

17
strings/ctype-tis620.c
View File

@ -41,6 +41,7 @@
#ifdef HAVE_CHARSET_tis620
const char charset_name_tis620[]= "tis620";
#define charset_name_tis620_length sizeof(charset_name_tis620)-1
#define M L_MIDDLE
#define U L_UPPER
@ -918,8 +919,8 @@ struct charset_info_st my_charset_tis620_thai_ci=
{
18,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM|MY_CS_NON1TO1, /* state */
charset_name_tis620, /* cs name */
"tis620_thai_ci", /* name */
{ charset_name_tis620, charset_name_tis620_length }, /* cs name */
{ STRING_WITH_LEN("tis620_thai_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_tis620,
@ -950,8 +951,8 @@ struct charset_info_st my_charset_tis620_bin=
{
89,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT, /* state */
charset_name_tis620, /* cs name */
"tis620_bin", /* name */
{ charset_name_tis620, charset_name_tis620_length }, /* cs name */
{ STRING_WITH_LEN("tis620_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_tis620,
@ -983,8 +984,8 @@ struct charset_info_st my_charset_tis620_thai_nopad_ci=
{
MY_NOPAD_ID(18),0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_NON1TO1|MY_CS_NOPAD, /* state */
charset_name_tis620, /* cs name */
"tis620_thai_nopad_ci",/* name */
{ charset_name_tis620, charset_name_tis620_length }, /* cs name */
{ STRING_WITH_LEN("tis620_thai_nopad_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_tis620,
@ -1016,8 +1017,8 @@ struct charset_info_st my_charset_tis620_nopad_bin=
{
MY_NOPAD_ID(89),0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_NOPAD, /* state */
charset_name_tis620, /* cs name */
"tis620_nopad_bin", /* name */
{ charset_name_tis620, charset_name_tis620_length }, /* cs name */
{ STRING_WITH_LEN("tis620_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_tis620,

584
strings/ctype-uca.c
View File

File diff suppressed because it is too large Load Diff

69
strings/ctype-ucs2.c
View File

@ -1281,6 +1281,7 @@ my_uni_utf16(CHARSET_INFO *cs __attribute__((unused)),
#ifdef HAVE_CHARSET_utf16
const char charset_name_utf16le[]= "utf16le";
#define charset_name_utf16le_length (sizeof(charset_name_utf16le)-1)
static inline void
my_tolower_utf16(MY_UNICASE_INFO *uni_plane, my_wc_t *wc)
@ -1602,8 +1603,8 @@ struct charset_info_st my_charset_utf16_general_ci=
{
54,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
charset_name_utf16, /* cs name */
"utf16_general_ci", /* name */
{ charset_name_utf16, charset_name_utf16_length }, /* cs name */
{ STRING_WITH_LEN("utf16_general_ci") }, /* name */
"UTF-16 Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -1635,8 +1636,8 @@ struct charset_info_st my_charset_utf16_bin=
{
55,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
charset_name_utf16, /* cs name */
"utf16_bin", /* name */
{ charset_name_utf16, charset_name_utf16_length }, /* cs name */
{ STRING_WITH_LEN("utf16_bin") }, /* name */
"UTF-16 Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -1668,8 +1669,8 @@ struct charset_info_st my_charset_utf16_general_nopad_ci=
{
MY_NOPAD_ID(54),0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII|MY_CS_NOPAD,
charset_name_utf16, /* cs name */
"utf16_general_nopad_ci", /* name */
{ charset_name_utf16, charset_name_utf16_length }, /* cs name */
{ STRING_WITH_LEN("utf16_general_nopad_ci") }, /* name */
"UTF-16 Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -1702,8 +1703,8 @@ struct charset_info_st my_charset_utf16_nopad_bin=
MY_NOPAD_ID(55),0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII|
MY_CS_NOPAD,
charset_name_utf16, /* cs name */
"utf16_nopad_bin", /* name */
{ charset_name_utf16, charset_name_utf16_length}, /* cs name */
{ STRING_WITH_LEN("utf16_nopad_bin") }, /* name */
"UTF-16 Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -1943,8 +1944,8 @@ struct charset_info_st my_charset_utf16le_general_ci=
{
56,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
charset_name_utf16le, /* cs name */
"utf16le_general_ci",/* name */
{ charset_name_utf16le, charset_name_utf16le_length },
{ STRING_WITH_LEN("utf16le_general_ci") },/* name */
"UTF-16LE Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -1976,8 +1977,8 @@ struct charset_info_st my_charset_utf16le_bin=
{
62,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
charset_name_utf16le, /* cs name */
"utf16le_bin", /* name */
{ charset_name_utf16le, charset_name_utf16le_length },
{ STRING_WITH_LEN("utf16le_bin") }, /* name */
"UTF-16LE Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -2009,8 +2010,8 @@ struct charset_info_st my_charset_utf16le_general_nopad_ci=
{
MY_NOPAD_ID(56),0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII|MY_CS_NOPAD,
charset_name_utf16le, /* cs name */
"utf16le_general_nopad_ci",/* name */
{ charset_name_utf16le, charset_name_utf16le_length },
{ STRING_WITH_LEN("utf16le_general_nopad_ci") }, /* name */
"UTF-16LE Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -2043,8 +2044,8 @@ struct charset_info_st my_charset_utf16le_nopad_bin=
MY_NOPAD_ID(62),0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII|
MY_CS_NOPAD,
charset_name_utf16le, /* cs name */
"utf16le_nopad_bin", /* name */
{ charset_name_utf16le, charset_name_utf16le_length },
{ STRING_WITH_LEN("utf16le_nopad_bin") }, /* name */
"UTF-16LE Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -2769,8 +2770,8 @@ struct charset_info_st my_charset_utf32_general_ci=
{
60,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
charset_name_utf32, /* cs name */
"utf32_general_ci", /* name */
{ charset_name_utf32, charset_name_utf32_length }, /* cs name */
{ STRING_WITH_LEN("utf32_general_ci") }, /* name */
"UTF-32 Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -2802,8 +2803,8 @@ struct charset_info_st my_charset_utf32_bin=
{
61,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
charset_name_utf32, /* cs name */
"utf32_bin", /* name */
{ charset_name_utf32, charset_name_utf32_length }, /* cs name */
{ STRING_WITH_LEN("utf32_bin") }, /* name */
"UTF-32 Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -2835,8 +2836,8 @@ struct charset_info_st my_charset_utf32_general_nopad_ci=
{
MY_NOPAD_ID(60),0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII|MY_CS_NOPAD,
charset_name_utf32, /* cs name */
"utf32_general_nopad_ci", /* name */
{ charset_name_utf32, charset_name_utf32_length }, /* cs name */
{ STRING_WITH_LEN("utf32_general_nopad_ci") }, /* name */
"UTF-32 Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -2869,8 +2870,8 @@ struct charset_info_st my_charset_utf32_nopad_bin=
MY_NOPAD_ID(61),0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII|
MY_CS_NOPAD,
charset_name_utf32, /* cs name */
"utf32_nopad_bin", /* name */
{ charset_name_utf32, charset_name_utf32_length }, /* cs name */
{ STRING_WITH_LEN("utf32_nopad_bin") }, /* name */
"UTF-32 Unicode", /* comment */
NULL, /* tailoring */
NULL, /* ctype */
@ -3360,8 +3361,8 @@ struct charset_info_st my_charset_ucs2_general_ci=
{
35,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII,
charset_name_ucs2, /* cs name */
"ucs2_general_ci", /* name */
{ charset_name_ucs2, charset_name_ucs2_length}, /* cs name */
{ STRING_WITH_LEN("ucs2_general_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_ucs2, /* ctype */
@ -3393,8 +3394,8 @@ struct charset_info_st my_charset_ucs2_general_mysql500_ci=
{
159, 0, 0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII, /* state */
charset_name_ucs2, /* cs name */
"ucs2_general_mysql500_ci", /* name */
{ charset_name_ucs2, charset_name_ucs2_length }, /* cs name */
{ STRING_WITH_LEN("ucs2_general_mysql500_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_ucs2, /* ctype */
@ -3426,8 +3427,8 @@ struct charset_info_st my_charset_ucs2_bin=
{
90,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_UNICODE|MY_CS_NONASCII,
charset_name_ucs2, /* cs name */
"ucs2_bin", /* name */
{ charset_name_ucs2, charset_name_ucs2_length }, /* cs name */
{ STRING_WITH_LEN("ucs2_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_ucs2, /* ctype */
@ -3459,8 +3460,8 @@ struct charset_info_st my_charset_ucs2_general_nopad_ci=
{
MY_NOPAD_ID(35),0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NONASCII|MY_CS_NOPAD,
charset_name_ucs2, /* cs name */
"ucs2_general_nopad_ci", /* name */
{ charset_name_ucs2, charset_name_ucs2_length }, /* cs name */
{ STRING_WITH_LEN("ucs2_general_nopad_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_ucs2, /* ctype */
@ -3492,8 +3493,8 @@ struct charset_info_st my_charset_ucs2_nopad_bin=
{
MY_NOPAD_ID(90),0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_UNICODE|MY_CS_NONASCII|MY_CS_NOPAD,
charset_name_ucs2, /* cs name */
"ucs2_nopad_bin", /* name */
{ charset_name_ucs2, charset_name_ucs2_length }, /* cs name */
{ STRING_WITH_LEN("ucs2_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_ucs2, /* ctype */

17
strings/ctype-ujis.c
View File

@ -33,6 +33,7 @@
#ifdef HAVE_CHARSET_ujis
const char charset_name_ujis[]= "ujis";
#define charset_name_ujis_length (sizeof(charset_name_ujis) - 1)
static const uchar ctype_ujis[257] =
{
@ -67338,8 +67339,8 @@ struct charset_info_st my_charset_ujis_japanese_ci=
{
12,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY, /* state */
charset_name_ujis, /* cs name */
"ujis_japanese_ci", /* name */
{ charset_name_ujis, charset_name_ujis_length }, /* csname */
{ STRING_WITH_LEN("ujis_japanese_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_ujis,
@ -67371,8 +67372,8 @@ struct charset_info_st my_charset_ujis_bin=
{
91,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT, /* state */
charset_name_ujis, /* cs name */
"ujis_bin", /* name */
{ charset_name_ujis, charset_name_ujis_length }, /* csname */
{ STRING_WITH_LEN("ujis_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_ujis,
@ -67404,8 +67405,8 @@ struct charset_info_st my_charset_ujis_japanese_nopad_ci=
{
MY_NOPAD_ID(12),0,0,/* number */
MY_CS_COMPILED|MY_CS_NOPAD, /* state */
charset_name_ujis, /* cs name */
"ujis_japanese_nopad_ci", /* name */
{ charset_name_ujis, charset_name_ujis_length }, /* csname */
{ STRING_WITH_LEN("ujis_japanese_nopad_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_ujis,
@ -67437,8 +67438,8 @@ struct charset_info_st my_charset_ujis_nopad_bin=
{
MY_NOPAD_ID(91),0,0,/* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_NOPAD, /* state */
charset_name_ujis, /* cs name */
"ujis_nopad_bin", /* name */
{ charset_name_ujis, charset_name_ujis_length }, /* csname */
{ STRING_WITH_LEN("ujis_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_ujis,

40
strings/ctype-utf8.c
View File

@ -5473,8 +5473,8 @@ struct charset_info_st my_charset_utf8mb3_general_ci=
{
33,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM|MY_CS_UNICODE, /* state */
charset_name_utf8mb3, /* cs name */
MY_UTF8MB3 "_general_ci", /* name */
{ charset_name_utf8mb3, charset_name_utf8mb3_length }, /* cs name */
{ STRING_WITH_LEN(MY_UTF8MB3 "_general_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_utf8mb3, /* ctype */
@ -5506,8 +5506,8 @@ struct charset_info_st my_charset_utf8mb3_general_mysql500_ci=
{
223,0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE, /* state */
charset_name_utf8mb3, /* cs name */
MY_UTF8MB3 "_general_mysql500_ci", /* name */
{ charset_name_utf8mb3, charset_name_utf8mb3_length }, /* cs name */
{ STRING_WITH_LEN(MY_UTF8MB3 "_general_mysql500_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_utf8mb3, /* ctype */
@ -5539,8 +5539,8 @@ struct charset_info_st my_charset_utf8mb3_bin=
{
83,0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_BINSORT|MY_CS_UNICODE, /* state */
charset_name_utf8mb3, /* cs name */
MY_UTF8MB3 "_bin", /* name */
{ charset_name_utf8mb3, charset_name_utf8mb3_length }, /* cs name */
{ STRING_WITH_LEN(MY_UTF8MB3 "_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_utf8mb3, /* ctype */
@ -5572,8 +5572,8 @@ struct charset_info_st my_charset_utf8mb3_general_nopad_ci=
{
MY_NOPAD_ID(33),0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_NOPAD, /* state */
charset_name_utf8mb3, /* cs name */
MY_UTF8MB3 "_general_nopad_ci", /* name */
{ charset_name_utf8mb3, charset_name_utf8mb3_length }, /* cs name */
{ STRING_WITH_LEN(MY_UTF8MB3 "_general_nopad_ci") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_utf8mb3, /* ctype */
@ -5605,8 +5605,8 @@ struct charset_info_st my_charset_utf8mb3_nopad_bin=
{
MY_NOPAD_ID(83),0,0,/* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_BINSORT|MY_CS_UNICODE|MY_CS_NOPAD,
charset_name_utf8mb3, /* cs name */
MY_UTF8MB3 "_nopad_bin", /* name */
{ charset_name_utf8mb3, charset_name_utf8mb3_length }, /* cs name */
{ STRING_WITH_LEN(MY_UTF8MB3 "_nopad_bin") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_utf8mb3, /* ctype */
@ -7120,8 +7120,8 @@ struct charset_info_st my_charset_filename=
{
17,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_HIDDEN|MY_CS_NONASCII,
"filename", /* cs name */
"filename", /* name */
{ STRING_WITH_LEN("filename") }, /* cs name */
{ STRING_WITH_LEN("filename") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_utf8mb3, /* ctype */
@ -7809,8 +7809,8 @@ struct charset_info_st my_charset_utf8mb4_general_ci=
{
45,0,0, /* number */
MY_CS_COMPILED|MY_CS_PRIMARY|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_UNICODE_SUPPLEMENT, /* state */
charset_name_utf8mb4, /* cs name */
MY_UTF8MB4_GENERAL_CI,/* name */
{ charset_name_utf8mb4, charset_name_utf8mb4_length}, /* cs name */
{ STRING_WITH_LEN(MY_UTF8MB4_GENERAL_CI) }, /* name */
"UTF-8 Unicode", /* comment */
NULL, /* tailoring */
ctype_utf8mb4, /* ctype */
@ -7843,8 +7843,8 @@ struct charset_info_st my_charset_utf8mb4_bin=
46,0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_STRNXFRM|MY_CS_UNICODE|
MY_CS_UNICODE_SUPPLEMENT, /* state */
charset_name_utf8mb4, /* cs name */
MY_UTF8MB4_BIN, /* name */
{ charset_name_utf8mb4, charset_name_utf8mb4_length }, /* cs name */
{ STRING_WITH_LEN(MY_UTF8MB4_BIN) }, /* name */
"UTF-8 Unicode", /* comment */
NULL, /* tailoring */
ctype_utf8mb4, /* ctype */
@ -7877,8 +7877,8 @@ struct charset_info_st my_charset_utf8mb4_general_nopad_ci=
MY_NOPAD_ID(45),0,0,/* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_UNICODE|MY_CS_UNICODE_SUPPLEMENT|
MY_CS_NOPAD, /* state */
charset_name_utf8mb4, /* cs name */
MY_UTF8MB4_GENERAL_NOPAD_CI,/* name */
{ charset_name_utf8mb4, charset_name_utf8mb4_length }, /* cs name */
{ STRING_WITH_LEN(MY_UTF8MB4_GENERAL_NOPAD_CI) }, /* name */
"UTF-8 Unicode", /* comment */
NULL, /* tailoring */
ctype_utf8mb4, /* ctype */
@ -7911,8 +7911,8 @@ struct charset_info_st my_charset_utf8mb4_nopad_bin=
MY_NOPAD_ID(46),0,0, /* number */
MY_CS_COMPILED|MY_CS_BINSORT|MY_CS_STRNXFRM|MY_CS_UNICODE|
MY_CS_UNICODE_SUPPLEMENT|MY_CS_NOPAD, /* state */
charset_name_utf8mb4, /* cs name */
MY_UTF8MB4_NOPAD_BIN, /* name */
{ charset_name_utf8mb4, charset_name_utf8mb4_length }, /* cs name */
{ STRING_WITH_LEN(MY_UTF8MB4_NOPAD_BIN) }, /* name */
"UTF-8 Unicode", /* comment */
NULL, /* tailoring */
ctype_utf8mb4, /* ctype */

5
strings/ctype-win1250ch.c
View File

@ -53,6 +53,7 @@
#ifdef HAVE_CHARSET_cp1250
const char charset_name_cp1250[]= "cp1250";
#define charset_name_cp1250_length (sizeof(charset_name_cp1250) -1)
static const uint16 tab_cp1250_uni[256]={
0,0x0001,0x0002,0x0003,0x0004,0x0005,0x0006,0x0007,
@ -691,8 +692,8 @@ struct charset_info_st my_charset_cp1250_czech_ci =
34,0,0, /* number */
MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_CSSORT|
MY_CS_STRNXFRM_BAD_NWEIGHTS|MY_CS_NON1TO1, /* state */
charset_name_cp1250, /* cs name */
"cp1250_czech_cs", /* name */
{ charset_name_cp1250, charset_name_cp1250_length }, /* cs name */
{ STRING_WITH_LEN("cp1250_czech_cs") }, /* name */
"", /* comment */
NULL, /* tailoring */
ctype_win1250ch,

7
strings/ctype.c
View File

@ -35,7 +35,6 @@
http://oss.software.ibm.com/icu/userguide/Collate_Customization.html
*/
const char charset_name_latin2[]= "latin2";
const char charset_name_utf8mb3[]= "utf8mb3";
const char charset_name_utf16[]= "utf16";
@ -609,10 +608,12 @@ static int cs_value(MY_XML_PARSER *st,const char *attr, size_t len)
i->cs.primary_number= strtol(attr,(char**)NULL,10);
break;
case _CS_COLNAME:
i->cs.name=mstr(i->name,attr,len,MY_CS_NAME_SIZE-1);
i->cs.coll_name.str= mstr(i->name,attr,len,MY_CS_NAME_SIZE-1);
i->cs.coll_name.length= strlen(i->cs.coll_name.str);
break;
case _CS_CSNAME:
i->cs.csname=mstr(i->csname,attr,len,MY_CS_NAME_SIZE-1);
i->cs.cs_name.str= mstr(i->csname,attr,len,MY_CS_NAME_SIZE-1);
i->cs.cs_name.length= strlen(i->cs.cs_name.str);
break;
case _CS_CSDESCRIPT:
i->cs.comment=mstr(i->comment,attr,len,MY_CS_CSDESCR_SIZE-1);

7
strings/strings_def.h
View File

@ -132,11 +132,16 @@ int my_wc_to_printable_8bit(CHARSET_INFO *cs, my_wc_t wc,
/* Some common character set names */
extern const char charset_name_latin2[];
#define charset_name_latin2_length 6
extern const char charset_name_utf8mb3[];
#define charset_name_utf8mb3_length 7
extern const char charset_name_utf16[];
#define charset_name_utf16_length 5
extern const char charset_name_utf32[];
#define charset_name_utf32_length 5
extern const char charset_name_ucs2[];
extern const char charset_name_ucs2[];
#define charset_name_ucs2_length 4
extern const char charset_name_utf8mb4[];
#define charset_name_utf8mb4_length 7
#endif /*STRINGS_DEF_INCLUDED */

2
unittest/mysys/ma_dyncol-t.c
View File

@ -236,7 +236,7 @@ void test_value_single_string(const char *string, size_t len,
err:
ok(rc, "'%s' - '%s' %u %u-%s", string,
res.x.string.value.str, (uint)res.x.string.value.length,
(uint)res.x.string.charset->number, res.x.string.charset->name);
(uint)res.x.string.charset->number, res.x.string.charset->coll_name.str);
/* cleanup */
val.x.string.value.str= NULL; // we did not allocated it
mariadb_dyncol_free(&str);

7
unittest/strings/strings-t.c
View File

@ -31,7 +31,8 @@ test_like_range_for_charset(CHARSET_INFO *cs, const char *src, size_t src_len)
my_ci_like_range(cs, src, src_len, '\\', '_', '%',
sizeof(min_str), min_str, max_str, &min_len, &max_len);
diag("min_len=%d\tmax_len=%d\t%s", (int) min_len, (int) max_len, cs->name);
diag("min_len=%d\tmax_len=%d\t%s", (int) min_len, (int) max_len,
cs->coll_name.str);
min_well_formed_len= my_well_formed_length(cs,
min_str, min_str + min_len,
10000, &error);
@ -632,7 +633,7 @@ strcollsp(CHARSET_INFO *cs, const STRNNCOLL_PARAM *param)
str2hex(ahex, sizeof(ahex), p->a, p->alen);
str2hex(bhex, sizeof(bhex), p->b, p->blen);
diag("%-20s %-10s %-10s %10d %10d%s",
cs->name, ahex, bhex, p->res, res,
cs->coll_name.str, ahex, bhex, p->res, res,
eqres(res, p->res) ? "" : " FAILED");
if (!eqres(res, p->res))
{
@ -772,7 +773,7 @@ int main()
if (test_like_range_for_charset(cs, "abc%", 4))
{
++failed;
diag("Failed for %s", cs->name);
diag("Failed for %s", cs->coll_name.str);
}
}
ok(failed == 0, "Testing my_like_range_xxx() functions");