database/mariadb-connector-c
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-connector-c.git synced 2025-08-07 02:42:49 +03:00
Code Activity

Merge from 10.0 dynamic column implemenetation:

Browse Source 
- functions which operate with numeric keys now have suffix _num
        - Fixes for MDEV 4993-4995
This commit is contained in:
holzboote@googlemail.com
2013-09-20 14:48:20 +02:00
parent b382649f50
commit 73f30d2a83
10 changed files with 404 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
include/ma_dyncol.h
View File

@@ -130,11 +130,11 @@ dynamic_column_get(DYNAMIC_COLUMN *org, uint column_nr,
/* new functions */ /* new functions */
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_create_many(DYNAMIC_COLUMN *str, mariadb_dyncol_create_many_num(DYNAMIC_COLUMN *str,
uint column_count, uint column_count,
uint *column_numbers, uint *column_numbers,
DYNAMIC_COLUMN_VALUE *values, DYNAMIC_COLUMN_VALUE *values,
my_bool new_string); my_bool new_string);
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_create_many_named(DYNAMIC_COLUMN *str, mariadb_dyncol_create_many_named(DYNAMIC_COLUMN *str,
uint column_count, uint column_count,
@@ -144,10 +144,10 @@ mariadb_dyncol_create_many_named(DYNAMIC_COLUMN *str,
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_update_many(DYNAMIC_COLUMN *str, mariadb_dyncol_update_many_num(DYNAMIC_COLUMN *str,
uint add_column_count, uint add_column_count,
uint *column_keys, uint *column_keys,
DYNAMIC_COLUMN_VALUE *values); DYNAMIC_COLUMN_VALUE *values);
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_update_many_named(DYNAMIC_COLUMN *str, mariadb_dyncol_update_many_named(DYNAMIC_COLUMN *str,
uint add_column_count, uint add_column_count,
@@ -156,13 +156,13 @@ mariadb_dyncol_update_many_named(DYNAMIC_COLUMN *str,
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_exists(DYNAMIC_COLUMN *org, uint column_nr); mariadb_dyncol_exists_num(DYNAMIC_COLUMN *org, uint column_nr);
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_exists_named(DYNAMIC_COLUMN *str, MYSQL_LEX_STRING *name); mariadb_dyncol_exists_named(DYNAMIC_COLUMN *str, MYSQL_LEX_STRING *name);
/* List of not NULL columns */ /* List of not NULL columns */
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_list(DYNAMIC_COLUMN *str, uint *count, uint **nums); mariadb_dyncol_list_num(DYNAMIC_COLUMN *str, uint *count, uint **nums);
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_list_named(DYNAMIC_COLUMN *str, uint *count, mariadb_dyncol_list_named(DYNAMIC_COLUMN *str, uint *count,
MYSQL_LEX_STRING **names); MYSQL_LEX_STRING **names);
@@ -171,8 +171,8 @@ mariadb_dyncol_list_named(DYNAMIC_COLUMN *str, uint *count,
if the column do not exists it is NULL if the column do not exists it is NULL
*/ */
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_get(DYNAMIC_COLUMN *org, uint column_nr, mariadb_dyncol_get_num(DYNAMIC_COLUMN *org, uint column_nr,
DYNAMIC_COLUMN_VALUE *store_it_here); DYNAMIC_COLUMN_VALUE *store_it_here);
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_get_named(DYNAMIC_COLUMN *str, MYSQL_LEX_STRING *name, mariadb_dyncol_get_named(DYNAMIC_COLUMN *str, MYSQL_LEX_STRING *name,
DYNAMIC_COLUMN_VALUE *store_it_here); DYNAMIC_COLUMN_VALUE *store_it_here);

5
include/mysql.h
View File

@@ -52,6 +52,7 @@ typedef int my_socket;
#include "mysql_com.h" #include "mysql_com.h"
#include "mysql_version.h" #include "mysql_version.h"
#include "my_list.h" #include "my_list.h"
#include "m_ctype.h"
#ifndef ST_USED_MEM_DEFINED #ifndef ST_USED_MEM_DEFINED
#define ST_USED_MEM_DEFINED #define ST_USED_MEM_DEFINED
@@ -449,6 +450,10 @@ const char * STDCALL mysql_get_client_info(void);
unsigned long STDCALL mysql_get_client_version(void); unsigned long STDCALL mysql_get_client_version(void);
my_bool STDCALL mariadb_connection(MYSQL *mysql); my_bool STDCALL mariadb_connection(MYSQL *mysql);
const char * STDCALL mysql_get_server_name(MYSQL *mysql); const char * STDCALL mysql_get_server_name(MYSQL *mysql);
CHARSET_INFO * STDCALL mysql_get_charset_by_name(const char *csname);
CHARSET_INFO * STDCALL mysql_get_charset_by_nr(uint csnr);
size_t STDCALL mariadb_convert_string(const char *from, size_t *from_len, CHARSET_INFO *from_cs,
char *to, size_t *to_len, CHARSET_INFO *to_cs, int *errorcode);
#include <my_stmt.h> #include <my_stmt.h>

8
libmariadb/charset.c
View File

@@ -26,7 +26,7 @@ CHARSET_INFO *my_charset_bin= (CHARSET_INFO *)&compiled_charsets[32];
CHARSET_INFO *my_charset_latin1= (CHARSET_INFO *)&compiled_charsets[5]; CHARSET_INFO *my_charset_latin1= (CHARSET_INFO *)&compiled_charsets[5];
CHARSET_INFO *my_charset_utf8_general_ci= (CHARSET_INFO *)&compiled_charsets[21]; CHARSET_INFO *my_charset_utf8_general_ci= (CHARSET_INFO *)&compiled_charsets[21];
CHARSET_INFO *get_charset_by_nr(uint cs_number) CHARSET_INFO * STDCALL mysql_get_charset_by_nr(uint cs_number)
{ {
int i= 0; int i= 0;
@@ -41,7 +41,7 @@ my_bool set_default_charset(uint cs, myf flags)
CHARSET_INFO *new_charset; CHARSET_INFO *new_charset;
DBUG_ENTER("set_default_charset"); DBUG_ENTER("set_default_charset");
DBUG_PRINT("enter",("character set: %d",(int) cs)); DBUG_PRINT("enter",("character set: %d",(int) cs));
new_charset = get_charset_by_nr(cs); new_charset = mysql_get_charset_by_nr(cs);
if (!new_charset) if (!new_charset)
{ {
DBUG_PRINT("error",("Couldn't set default character set")); DBUG_PRINT("error",("Couldn't set default character set"));
@@ -51,7 +51,7 @@ my_bool set_default_charset(uint cs, myf flags)
DBUG_RETURN(FALSE); DBUG_RETURN(FALSE);
} }
CHARSET_INFO *get_charset_by_name(const char *cs_name) CHARSET_INFO * STDCALL mysql_get_charset_by_name(const char *cs_name)
{ {
int i= 0; int i= 0;
@@ -66,7 +66,7 @@ my_bool set_default_charset_by_name(const char *cs_name, myf flags)
CHARSET_INFO *new_charset; CHARSET_INFO *new_charset;
DBUG_ENTER("set_default_charset_by_name"); DBUG_ENTER("set_default_charset_by_name");
DBUG_PRINT("enter",("character set: %s", cs_name)); DBUG_PRINT("enter",("character set: %s", cs_name));
new_charset = get_charset_by_name(cs_name); new_charset = mysql_get_charset_by_name(cs_name);
if (!new_charset) if (!new_charset)
{ {
DBUG_PRINT("error",("Couldn't set default character set")); DBUG_PRINT("error",("Couldn't set default character set"));

13
libmariadb/libmariadb_exports.def
View File

@@ -106,15 +106,18 @@ EXPORTS
mysql_stmt_more_results mysql_stmt_more_results
mariadb_connection mariadb_connection
mysql_get_server_name mysql_get_server_name
mariadb_dyncol_create_many mysql_get_charset_by_name
mysql_get_charset_by_nr
mariadb_convert_string
mariadb_dyncol_create_many_num
mariadb_dyncol_create_many_named mariadb_dyncol_create_many_named
mariadb_dyncol_update_many mariadb_dyncol_update_many_num
mariadb_dyncol_update_many_named mariadb_dyncol_update_many_named
mariadb_dyncol_exists mariadb_dyncol_exists_num
mariadb_dyncol_exists_named mariadb_dyncol_exists_named
mariadb_dyncol_list mariadb_dyncol_list_num
mariadb_dyncol_list_named mariadb_dyncol_list_named
mariadb_dyncol_get mariadb_dyncol_get_num
mariadb_dyncol_get_named mariadb_dyncol_get_named
mariadb_dyncol_has_names mariadb_dyncol_has_names
mariadb_dyncol_check mariadb_dyncol_check

81
libmariadb/ma_dyncol.c
View File

@@ -75,10 +75,10 @@ uint32 copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
CHARSET_INFO *from_cs, uint *errors); CHARSET_INFO *from_cs, uint *errors);
#else #else
size_t mariadb_time_to_string(const MYSQL_TIME *tm, char *time_str, size_t len, extern size_t mariadb_time_to_string(const MYSQL_TIME *tm, char *time_str, size_t len,
unsigned int digits); unsigned int digits);
size_t convert_string(const char *from, size_t *from_len, CHARSET_INFO *from_cs, extern STDCALL size_t mariadb_convert_string(const char *from, size_t *from_len, CHARSET_INFO *from_cs,
char *to, size_t *to_len, CHARSET_INFO *to_cs); char *to, size_t *to_len, CHARSET_INFO *to_cs, int *errorcode);
#endif #endif
/* /*
Flag byte bits Flag byte bits
@@ -1110,7 +1110,11 @@ dynamic_column_string_read(DYNAMIC_COLUMN_VALUE *store_it_here,
uint charset_nr= (uint)dynamic_column_var_uint_get(data, length, &len); uint charset_nr= (uint)dynamic_column_var_uint_get(data, length, &len);
if (len == 0) /* Wrong packed number */ if (len == 0) /* Wrong packed number */
return ER_DYNCOL_FORMAT; return ER_DYNCOL_FORMAT;
#ifndef LIBMARIADB
store_it_here->x.string.charset= get_charset_by_nr(charset_nr); store_it_here->x.string.charset= get_charset_by_nr(charset_nr);
#else
store_it_here->x.string.charset= mysql_get_charset_by_nr(charset_nr);
#endif
if (store_it_here->x.string.charset == NULL) if (store_it_here->x.string.charset == NULL)
return ER_DYNCOL_UNKNOWN_CHARSET; return ER_DYNCOL_UNKNOWN_CHARSET;
data+= len; data+= len;
@@ -1643,15 +1647,22 @@ dynamic_new_column_store(DYNAMIC_COLUMN *str,
if (!(columns_order= malloc(sizeof(void*)*column_count))) if (!(columns_order= malloc(sizeof(void*)*column_count)))
return ER_DYNCOL_RESOURCE; return ER_DYNCOL_RESOURCE;
if (new_str) if (new_str || str->str == 0)
{ {
if (dynamic_column_init_named(str, if (column_count)
fmt->fixed_hdr + {
hdr->header_size + if (dynamic_column_init_named(str,
hdr->nmpool_size + fmt->fixed_hdr +
hdr->data_size + hdr->header_size +
DYNCOL_SYZERESERVE)) hdr->nmpool_size +
goto err; hdr->data_size +
DYNCOL_SYZERESERVE))
goto err;
}
else
{
dynamic_column_initialize(str);
}
} }
else else
{ {
@@ -1856,11 +1867,11 @@ dynamic_column_create_many(DYNAMIC_COLUMN *str,
*/ */
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_create_many(DYNAMIC_COLUMN *str, mariadb_dyncol_create_many_num(DYNAMIC_COLUMN *str,
uint column_count, uint column_count,
uint *column_numbers, uint *column_numbers,
DYNAMIC_COLUMN_VALUE *values, DYNAMIC_COLUMN_VALUE *values,
my_bool new_string) my_bool new_string)
{ {
DBUG_ENTER("mariadb_dyncol_create_many"); DBUG_ENTER("mariadb_dyncol_create_many");
DBUG_RETURN(dynamic_column_create_many_internal_fmt(str, column_count, DBUG_RETURN(dynamic_column_create_many_internal_fmt(str, column_count,
@@ -2217,8 +2228,8 @@ dynamic_column_get(DYNAMIC_COLUMN *str, uint column_nr,
} }
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_get(DYNAMIC_COLUMN *str, uint column_nr, mariadb_dyncol_get_num(DYNAMIC_COLUMN *str, uint column_nr,
DYNAMIC_COLUMN_VALUE *store_it_here) DYNAMIC_COLUMN_VALUE *store_it_here)
{ {
return dynamic_column_get_internal(str, store_it_here, column_nr, NULL); return dynamic_column_get_internal(str, store_it_here, column_nr, NULL);
} }
@@ -2342,13 +2353,7 @@ err:
*/ */
enum enum_dyncol_func_result enum enum_dyncol_func_result
dynamic_column_exists(DYNAMIC_COLUMN *str, uint column_nr) mariadb_dyncol_exists_num(DYNAMIC_COLUMN *str, uint column_nr)
{
return dynamic_column_exists_internal(str, column_nr, NULL);
}
enum enum_dyncol_func_result
mariadb_dyncol_exists(DYNAMIC_COLUMN *str, uint column_nr)
{ {
return dynamic_column_exists_internal(str, column_nr, NULL); return dynamic_column_exists_internal(str, column_nr, NULL);
} }
@@ -2457,14 +2462,14 @@ dynamic_column_list(DYNAMIC_COLUMN *str, DYNAMIC_ARRAY *array_of_uint)
@return ER_DYNCOL_* return code @return ER_DYNCOL_* return code
*/ */
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_list(DYNAMIC_COLUMN *str, uint *count, uint **nums) mariadb_dyncol_list_num(DYNAMIC_COLUMN *str, uint *count, uint **nums)
{ {
DYN_HEADER header; DYN_HEADER header;
uchar *read; uchar *read;
uint i; uint i;
enum enum_dyncol_func_result rc; enum enum_dyncol_func_result rc;
(*nums)= 0; /* In case of errors */ (*nums)= 0; (*count)= 0; /* In case of errors */
if (str->length == 0) if (str->length == 0)
return ER_DYNCOL_OK; /* no columns */ return ER_DYNCOL_OK; /* no columns */
@@ -3275,10 +3280,10 @@ dynamic_column_update_many(DYNAMIC_COLUMN *str,
} }
enum enum_dyncol_func_result enum enum_dyncol_func_result
mariadb_dyncol_update_many(DYNAMIC_COLUMN *str, mariadb_dyncol_update_many_num(DYNAMIC_COLUMN *str,
uint add_column_count, uint add_column_count,
uint *column_numbers, uint *column_numbers,
DYNAMIC_COLUMN_VALUE *values) DYNAMIC_COLUMN_VALUE *values)
{ {
return dynamic_column_update_many_fmt(str, add_column_count, column_numbers, return dynamic_column_update_many_fmt(str, add_column_count, column_numbers,
values, FALSE); values, FALSE);
@@ -3887,6 +3892,8 @@ mariadb_dyncol_val_str(DYNAMIC_STRING *str, DYNAMIC_COLUMN_VALUE *val,
{ {
#ifndef LIBMARIADB #ifndef LIBMARIADB
uint dummy_errors; uint dummy_errors;
#else
int dummy_errors;
#endif #endif
if (!quote) if (!quote)
{ {
@@ -3899,8 +3906,8 @@ mariadb_dyncol_val_str(DYNAMIC_STRING *str, DYNAMIC_COLUMN_VALUE *val,
val->x.string.charset, val->x.string.charset,
&dummy_errors); &dummy_errors);
#else #else
convert_string(from, &len, val->x.string.charset, mariadb_convert_string(from, &len, val->x.string.charset,
str->str, (size_t *)&bufflen, cs); str->str, (size_t *)&bufflen, cs, &dummy_errors);
#endif #endif
return ER_DYNCOL_OK; return ER_DYNCOL_OK;
} }
@@ -3913,8 +3920,8 @@ mariadb_dyncol_val_str(DYNAMIC_STRING *str, DYNAMIC_COLUMN_VALUE *val,
val->x.string.charset, val->x.string.charset,
&dummy_errors); &dummy_errors);
#else #else
convert_string(from, &len, val->x.string.charset, mariadb_convert_string(from, &len, val->x.string.charset,
alloc, (size_t *)&bufflen, cs); alloc, (size_t *)&bufflen, cs, &dummy_errors);
#endif #endif
from= alloc; from= alloc;
} }
@@ -4391,6 +4398,10 @@ mariadb_dyncol_column_count(DYNAMIC_COLUMN *str, uint *column_count)
DYN_HEADER header; DYN_HEADER header;
enum enum_dyncol_func_result rc; enum enum_dyncol_func_result rc;
(*column_count)= 0;
if (str->length == 0)
return ER_DYNCOL_OK;
if ((rc= init_read_hdr(&header, str)) < 0) if ((rc= init_read_hdr(&header, str)) < 0)
return rc; return rc;
*column_count= header.column_count; *column_count= header.column_count;

23
libmariadb/my_charset.c
View File

@@ -555,12 +555,14 @@ const CHARSET_INFO compiled_charsets[] =
{ 53, 1, "macroman", "macroman_bin", "", "MACINTOSH", 1, 1, NULL, NULL}, { 53, 1, "macroman", "macroman_bin", "", "MACINTOSH", 1, 1, NULL, NULL},
{ 54, 1, "utf16", "utf16_general_ci", "UTF_16 Unicode", "UTF16", 2, 4, mysql_mbcharlen_utf16, check_mb_utf16}, { 54, 1, "utf16", "utf16_general_ci", "UTF_16 Unicode", "UTF16", 2, 4, mysql_mbcharlen_utf16, check_mb_utf16},
{ 55, 1, "utf16", "utf16_bin", "UTF-16 Unicode", "UTF16", 2, 4, mysql_mbcharlen_utf16, check_mb_utf16}, { 55, 1, "utf16", "utf16_bin", "UTF-16 Unicode", "UTF16", 2, 4, mysql_mbcharlen_utf16, check_mb_utf16},
{ 56, 1, "utf16le", "utf16_general_ci", "UTF_16LE Unicode", "UTF16LE", 2, 4, mysql_mbcharlen_utf16, check_mb_utf16},
{ 58, 1, "cp1257", "cp1257_bin", "", "CP1257", 1, 1, NULL, NULL}, { 58, 1, "cp1257", "cp1257_bin", "", "CP1257", 1, 1, NULL, NULL},
#ifdef USED_TO_BE_SO_BEFORE_MYSQL_5_5 #ifdef USED_TO_BE_SO_BEFORE_MYSQL_5_5
{ 60, 1, "armascii8", "armascii8_bin", "", "ARMSCII-8", 1, 1, NULL, NULL}, { 60, 1, "armascii8", "armascii8_bin", "", "ARMSCII-8", 1, 1, NULL, NULL},
#endif #endif
{ 60, 1, "utf32", "utf32_general_ci", "UTF-32 Unicode", "UTF32", 4, 4, mysql_mbcharlen_utf32, check_mb_utf32}, { 60, 1, "utf32", "utf32_general_ci", "UTF-32 Unicode", "UTF32", 4, 4, mysql_mbcharlen_utf32, check_mb_utf32},
{ 61, 1, "utf32", "utf32_bin", "UTF-32 Unicode", "UTF32", 4, 4, mysql_mbcharlen_utf32, check_mb_utf32}, { 61, 1, "utf32", "utf32_bin", "UTF-32 Unicode", "UTF32", 4, 4, mysql_mbcharlen_utf32, check_mb_utf32},
{ 62, 1, "utf16le", "utf16_bin", "UTF_16LE Unicode", "UTF16LE", 2, 4, mysql_mbcharlen_utf16, check_mb_utf16},
{ 65, 1, "ascii", "ascii_bin", "", "ASCII", 1, 1, NULL, NULL}, { 65, 1, "ascii", "ascii_bin", "", "ASCII", 1, 1, NULL, NULL},
{ 66, 1, "cp1250", "cp1250_bin", "", "CP1250", 1, 1, NULL, NULL}, { 66, 1, "cp1250", "cp1250_bin", "", "CP1250", 1, 1, NULL, NULL},
{ 67, 1, "cp1256", "cp1256_bin", "", "CP1256", 1, 1, NULL, NULL}, { 67, 1, "cp1256", "cp1256_bin", "", "CP1256", 1, 1, NULL, NULL},
@@ -930,7 +932,7 @@ struct st_madb_os_charset MADB_OS_CHARSET[]=
{"20106", "IA5 German (7-bit)", NULL, NULL, MADB_CS_UNSUPPORTED}, {"20106", "IA5 German (7-bit)", NULL, NULL, MADB_CS_UNSUPPORTED},
{"20107", "Swedish (7-bit)", NULL, NULL, MADB_CS_UNSUPPORTED}, {"20107", "Swedish (7-bit)", NULL, NULL, MADB_CS_UNSUPPORTED},
{"20108", "Norwegian (7-bit)", NULL, NULL, MADB_CS_UNSUPPORTED}, {"20108", "Norwegian (7-bit)", NULL, NULL, MADB_CS_UNSUPPORTED},
{"20127", "US-ASCII (7-bit)", NULL, NULL, MADB_CS_UNSUPPORTED}, {"20127", "US-ASCII (7-bit)", "ascii", NULL, MADB_CS_EXACT},
{"20261", "T.61", NULL, NULL, MADB_CS_UNSUPPORTED}, {"20261", "T.61", NULL, NULL, MADB_CS_UNSUPPORTED},
{"20269", "Non-Spacing Accent", NULL, NULL, MADB_CS_UNSUPPORTED}, {"20269", "Non-Spacing Accent", NULL, NULL, MADB_CS_UNSUPPORTED},
{"20273", "EBCDIC Germany", NULL, NULL, MADB_CS_UNSUPPORTED}, {"20273", "EBCDIC Germany", NULL, NULL, MADB_CS_UNSUPPORTED},
@@ -1117,25 +1119,36 @@ int madb_get_windows_cp(const char *charset)
#endif #endif
/* }}} */ /* }}} */
size_t convert_string(const char *from, size_t *from_len, CHARSET_INFO *from_cs, size_t STDCALL mariadb_convert_string(const char *from, size_t *from_len, CHARSET_INFO *from_cs,
char *to, size_t *to_len, CHARSET_INFO *to_cs) char *to, size_t *to_len, CHARSET_INFO *to_cs, int *errorcode)
{ {
iconv_t conv= 0; iconv_t conv= 0;
size_t rc= -1; size_t rc= -1;
size_t save_len= *to_len; size_t save_len= *to_len;
char to_encoding[128]; char to_encoding[128];
*errorcode= 0;
/* check if conversion is supported */ /* check if conversion is supported */
if (!from_cs || !from_cs->encoding || !from_cs->encoding[0] || if (!from_cs || !from_cs->encoding || !from_cs->encoding[0] ||
!to_cs || !to_cs->encoding || !to_cs->encoding[0]) !to_cs || !to_cs->encoding || !to_cs->encoding[0])
goto error; {
*errorcode= EINVAL;
return rc;
}
snprintf(to_encoding, 128, "%s//TRANSLIT", to_cs->encoding); snprintf(to_encoding, 128, "%s//TRANSLIT", to_cs->encoding);
if ((conv= iconv_open(to_encoding, from_cs->encoding)) == (iconv_t)-1) if ((conv= iconv_open(to_encoding, from_cs->encoding)) == (iconv_t)-1)
{
*errorcode= errno;
goto error; goto error;
}
if ((rc= iconv(conv, (char **)&from, from_len, &to, to_len)) == -1) if ((rc= iconv(conv, (char **)&from, from_len, &to, to_len)) == -1)
{
*errorcode= errno;
goto error; goto error;
}
rc= save_len - *to_len; rc= save_len - *to_len;
error: error:
if (conv != (iconv_t)-1) if (conv != (iconv_t)-1)

2
unittest/libmariadb/CMakeLists.txt
View File

@@ -22,7 +22,7 @@ INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include
ADD_DEFINITIONS(-DLIBMARIADB) ADD_DEFINITIONS(-DLIBMARIADB)
SET(API_TESTS "basic-t" "fetch" "charset" "logs" "cursor" "errors" "view" "ps" "ps_bugs" SET(API_TESTS "basic-t" "fetch" "charset" "logs" "cursor" "errors" "view" "ps" "ps_bugs"
"sp" "result" "connection" "misc" "ssl" "ps_new" "sqlite3" "thread" "cs_conv") "sp" "result" "connection" "misc" "ssl" "ps_new" "sqlite3" "thread" "cs_conv" "dyncol")
FOREACH(API_TEST ${API_TESTS}) FOREACH(API_TEST ${API_TESTS})
ADD_EXECUTABLE(${API_TEST} ${API_TEST}.c) ADD_EXECUTABLE(${API_TEST} ${API_TEST}.c)

9
unittest/libmariadb/cs_conv.c
View File

@@ -59,6 +59,7 @@ static int test_cs_conversion(MYSQL *mysql)
while (cs_conv[i].cs_from) while (cs_conv[i].cs_from)
{ {
int error_code;
char query[1024]; char query[1024];
size_t from_len, to_len= 1024; size_t from_len, to_len= 1024;
CHARSET_INFO *cs_from, *cs_to; CHARSET_INFO *cs_from, *cs_to;
@@ -69,8 +70,8 @@ static int test_cs_conversion(MYSQL *mysql)
memset(str_converted, 0, 1024); memset(str_converted, 0, 1024);
memset(str_expected, 0, 1024); memset(str_expected, 0, 1024);
FAIL_IF(!(cs_from= get_charset_by_name(cs_conv[i].cs_from)), "invalid character set"); FAIL_IF(!(cs_from= mysql_get_charset_by_name(cs_conv[i].cs_from)), "invalid character set");
FAIL_IF(!(cs_to= get_charset_by_name(cs_conv[i].cs_to)), "invalid character set"); FAIL_IF(!(cs_to= mysql_get_charset_by_name(cs_conv[i].cs_to)), "invalid character set");
snprintf(query, 1024, "SET NAMES %s", cs_conv[i].cs_to); snprintf(query, 1024, "SET NAMES %s", cs_conv[i].cs_to);
@@ -94,8 +95,8 @@ static int test_cs_conversion(MYSQL *mysql)
mysql_free_result(res); mysql_free_result(res);
from_len= cs_conv[i].len ? cs_conv[i].len : strlen(cs_conv[i].source); from_len= cs_conv[i].len ? cs_conv[i].len : strlen(cs_conv[i].source);
FAIL_IF(convert_string(cs_conv[i].source, &from_len, cs_from, FAIL_IF(mariadb_convert_string(cs_conv[i].source, &from_len, cs_from,
str_expected, &to_len, cs_to) < 1, "conversion error occured"); str_expected, &to_len, cs_to, &error_code) < 1, "conversion error occured");
if (strcmp(str_converted, str_expected)) if (strcmp(str_converted, str_expected))
{ {

270
unittest/libmariadb/dyncol.c Normal file
View File

@@ -0,0 +1,270 @@
/*
Copyright (c) 2013 Monty Program AB. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
by the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "my_test.h"
#include "ma_dyncol.h"
static int create_dyncol_named(MYSQL *mysql)
{
DYNAMIC_COLUMN dyncol;
DYNAMIC_COLUMN_VALUE *vals;
uint i, column_count= 6;
int rc;
char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5", "Val6"};
MYSQL_LEX_STRING keys1[]= {{"key1", 4}, {"key2", 4}, {"key3", 4}, {"key4", 4}, {"key5", 4}, {"key6", 4}},
keys2[]= {{"key1", 4}, {"key1", 4}, {"key3", 4}, {"key4", 4}, {"key5", 4}, {"key6", 4}},
keys3[]= {{"\x70\x61\x72\x61\x00\x30", 6}, {"\x70\x61\x72\x61\x00\x31", 6}, {"\x70\x61\x72\x61\x00\x32", 6},
{"\x70\x61\x72\x61\x00\x33", 6}, {"\x70\x61\x72\x61\x00\x34", 6}, {"\x70\x61\x72\x61\x00\x35", 6}};
MYSQL_LEX_STRING *my_keys;
uint my_count;
vals= (DYNAMIC_COLUMN_VALUE *)malloc(column_count * sizeof(DYNAMIC_COLUMN_VALUE));
for (i=0; i < column_count; i++)
{
vals[i].type= DYN_COL_STRING;
vals[i].x.string.value.str= strval[i];
vals[i].x.string.value.length= strlen(strval[i]);
vals[i].x.string.charset= (CHARSET_INFO *)mysql->charset;
diag("%s", keys3[i].str);
}
mariadb_dyncol_init(&dyncol);
rc= mariadb_dyncol_create_many_named(&dyncol, column_count, keys1, vals, 0);
FAIL_IF(mariadb_dyncol_create_many_named(&dyncol, column_count, keys1, vals, 1) < 0, "Error");
column_count= 0;
FAIL_IF(mariadb_dyncol_column_count(&dyncol, &column_count) < 0, "Error");
FAIL_IF(column_count != 6, "6 columns expected");
mariadb_dyncol_free(&dyncol);
rc= mariadb_dyncol_create_many_named(&dyncol, column_count, keys3, vals, 1);
if (rc < 0) {
diag("Error!!: %d", rc);
return FAIL;
}
column_count= 0;
FAIL_IF(mariadb_dyncol_column_count(&dyncol, &column_count) < 0, "Error");
FAIL_IF(column_count != 6, "6 columns expected");
mariadb_dyncol_free(&dyncol);
/* Now try to add a duplicate key */
FAIL_IF(mariadb_dyncol_create_many_named(&dyncol, column_count, keys2, vals, 1) >=0, "Error expected");
mariadb_dyncol_free(&dyncol);
/* binary keys */
rc= mariadb_dyncol_create_many_named(&dyncol, column_count, keys3, vals, 1);
FAIL_IF(rc < 0, "binary keys failed");
/* get keys*/
rc= mariadb_dyncol_list_named(&dyncol, &my_count, &my_keys);
FAIL_IF(rc < 0, "list named failed");
for (i=0; i < my_count; i++)
{
if (memcmp(my_keys[i].str, keys3[i].str, keys3[i].length) != 0)
diag("error key %d", i);
vals[i].type=DYN_COL_NULL;
}
rc= mariadb_dyncol_update_many_named(&dyncol, column_count, keys3, vals);
FAIL_IF(rc < 0, "update failed");
mariadb_dyncol_free(&dyncol);
keys3[0].str= "test";
for (i=0; i < column_count; i++)
diag("%s", my_keys[i].str);
free(vals);
free(my_keys);
return OK;
}
static int mdev_4994(MYSQL *mysql)
{
DYNAMIC_COLUMN dyncol;
uint key= 1;
DYNAMIC_COLUMN_VALUE val;
int rc;
val.type= MYSQL_TYPE_NULL;
mariadb_dyncol_init(&dyncol);
rc= mariadb_dyncol_create_many_num(&dyncol, 1, &key, &val, 0);
FAIL_IF(rc < 0, "Unexpected error");
return OK;
}
static int create_dyncol_num(MYSQL *mysql)
{
DYNAMIC_COLUMN dyncol;
DYNAMIC_COLUMN_VALUE vals[5];
uint i, column_count= 5;
uint my_count;
MYSQL_LEX_STRING *my_keys;
DYNAMIC_COLUMN_VALUE *my_vals;
int rc;
char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5"};
uint keys1[5]= {1,2,3,4,5},
keys2[5]= {1,2,2,4,5};
MYSQL_LEX_STRING key1= {"1",1};
for (i=0; i < column_count; i++)
{
vals[i].type= DYN_COL_STRING;
vals[i].x.string.value.str= strval[i];
vals[i].x.string.value.length= strlen(strval[i]);
vals[i].x.string.charset= (CHARSET_INFO *)mysql->charset;
}
FAIL_IF(mariadb_dyncol_create_many_num(&dyncol, column_count, keys1, vals, 1) <0, "Error (keys1)");
vals[0].x.string.value.str= strval[1];
rc= mariadb_dyncol_update_many_named(&dyncol,1, &key1, vals);
diag("update: %d", rc);
rc= mariadb_dyncol_unpack(&dyncol, &my_count, &my_keys, &my_vals);
diag("unpack: %d %d", rc, my_count);
diag("---------------__");
for(i=0; i < 5; i++)
{
diag("%s %d", my_keys[i].str, my_keys[i].length);
}
free(my_keys);
free(my_vals);
FAIL_IF(mariadb_dyncol_column_count(&dyncol, &column_count) < 0, "Error");
FAIL_IF(column_count != 5, "5 columns expected");
mariadb_dyncol_free(&dyncol);
FAIL_IF(mariadb_dyncol_create_many_num(&dyncol, column_count, keys2, vals, 1) >=0, "Error expected (keys2)");
mariadb_dyncol_free(&dyncol);
return OK;
}
static int mdev_x1(MYSQL *mysql)
{
int i, rc;
uint num_keys[5]= {1,2,3,4,5};
char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5"};
DYNAMIC_COLUMN_VALUE vals[5];
DYNAMIC_COLUMN dynstr;
MYSQL_LEX_STRING my_key= {"1", 2};
uint unpack_columns;
MYSQL_LEX_STRING *unpack_keys;
DYNAMIC_COLUMN_VALUE *unpack_vals;
for (i=0; i < 5; i++)
{
vals[i].type= DYN_COL_STRING;
vals[i].x.string.value.str= strval[i];
vals[i].x.string.value.length= strlen(strval[i]);
vals[i].x.string.charset= (CHARSET_INFO *)mysql->charset;
}
mariadb_dyncol_init(&dynstr);
/* create numeric */
rc= mariadb_dyncol_create_many_num(&dynstr, 5, num_keys, vals, 1);
if (rc < 0)
{
diag("Error: %d", rc);
return FAIL;
}
/* unpack and print values */
rc= mariadb_dyncol_unpack(&dynstr, &unpack_columns, &unpack_keys, &unpack_vals);
if (rc < 0)
{
diag("Error: %d", rc);
return FAIL;
}
for (i=0; i < unpack_columns; i++)
if (memcmp(unpack_vals[i].x.string.value.str, vals[i].x.string.value.str, vals[i].x.string.value.length))
printf("Error1: key: %1s val: %s %s\n", unpack_keys[i].str, unpack_vals[i].x.string.value.str, vals[i].x.string.value.str);
free(unpack_keys);
free(unpack_vals);
/* change one value and update with named key */
/* vals[0].x.string.value.str= strval[1]; */
rc= mariadb_dyncol_update_many_named(&dynstr, 1, &my_key, vals);
if (rc < 0)
{
diag("Error: %d", rc);
return FAIL;
}
/* unpack and print values */
rc= mariadb_dyncol_unpack(&dynstr, &unpack_columns, &unpack_keys, &unpack_vals);
if (rc < 0)
{
diag("Error: %d", rc);
return FAIL;
}
diag("Columns: %d", unpack_columns);
for (i=0; i < unpack_columns; i++)
diag("Key: %s Len: %d", unpack_keys[i].str, unpack_keys[i].length);
free(unpack_keys);
free(unpack_vals);
mariadb_dyncol_free(&dynstr);
return OK;
}
static int dyncol_column_count(MYSQL *mysql)
{
DYNAMIC_COLUMN dyncol;
uint column_count= 5;
int rc;
mariadb_dyncol_init(&dyncol); /* memset(&dyncol, 0, sizeof(DYNAMIC_COLUMN)) */
rc= mariadb_dyncol_column_count(&dyncol, &column_count);
diag("rc=%d", rc);
FAIL_IF(rc < 0, "unexpected error");
FAIL_IF(column_count > 0, "Expected column_count=0");
return OK;
}
struct my_tests_st my_tests[] = {
{"mdev_x1", mdev_x1, TEST_CONNECTION_NEW, 0, NULL, NULL},
{"mdev_4994", mdev_4994, TEST_CONNECTION_NEW, 0, NULL, NULL},
{"create_dyncol_named", create_dyncol_named, TEST_CONNECTION_NEW, 0, NULL, NULL},
{"create_dyncol_num", create_dyncol_num, TEST_CONNECTION_NEW, 0, NULL, NULL},
{"dyncol_column_count", dyncol_column_count, TEST_CONNECTION_NEW, 0, NULL, NULL},
{NULL, NULL, 0, 0, NULL, 0}
};
int main(int argc, char **argv)
{
if (argc > 1)
get_options(argc, argv);
get_envvars();
run_tests(my_tests);
return(exit_status());
}

34
unittest/libmariadb/ssl.c
View File

@@ -395,9 +395,43 @@ static int test_bug62743(MYSQL *my)
mysql_real_connect(mysql, hostname, username, password, schema, mysql_real_connect(mysql, hostname, username, password, schema,
port, socketname, 0); port, socketname, 0);
diag("Error: %s", mysql_error(mysql));
FAIL_IF(mysql_errno(mysql) != 2026, "Expected errno 2026"); FAIL_IF(mysql_errno(mysql) != 2026, "Expected errno 2026");
mysql_close(mysql); mysql_close(mysql);
mysql= mysql_init(NULL);
FAIL_IF(!mysql, "Can't allocate memory");
mysql_ssl_set(mysql, "./certs/client-key.pem", NULL, NULL, NULL, NULL);
mysql_real_connect(mysql, hostname, username, password, schema,
port, socketname, 0);
diag("Error with key: %s", mysql_error(mysql));
FAIL_IF(mysql_errno(mysql) != 2026, "Expected errno 2026");
mysql_close(mysql);
mysql= mysql_init(NULL);
FAIL_IF(!mysql, "Can't allocate memory");
mysql_ssl_set(mysql, "./certs/client-key.pem", "./certs/client-cert.pem", NULL, NULL, NULL);
mysql_real_connect(mysql, hostname, username, password, schema,
port, socketname, 0);
FAIL_IF(mysql_errno(mysql) != 0, "Expected no error");
mysql_close(mysql);
mysql= mysql_init(NULL);
FAIL_IF(!mysql, "Can't allocate memory");
mysql_ssl_set(mysql, "./certs/client-key.pem", "blablubb", NULL, NULL, NULL);
mysql_real_connect(mysql, hostname, username, password, schema,
port, socketname, 0);
diag("Error with cert: %s", mysql_error(mysql));
FAIL_IF(mysql_errno(mysql) != 0, "Expected no error");
mysql_close(mysql);
return OK;
return OK; return OK;
} }