From 73f30d2a8341f38ed3d9d3449e38320b615fa32d Mon Sep 17 00:00:00 2001 From: "holzboote@googlemail.com" <> Date: Fri, 20 Sep 2013 14:48:20 +0200 Subject: [PATCH] Merge from 10.0 dynamic column implemenetation: - functions which operate with numeric keys now have suffix _num - Fixes for MDEV 4993-4995 --- include/ma_dyncol.h | 26 +-- include/mysql.h | 5 + libmariadb/charset.c | 8 +- libmariadb/libmariadb_exports.def | 13 +- libmariadb/ma_dyncol.c | 81 +++++---- libmariadb/my_charset.c | 23 ++- unittest/libmariadb/CMakeLists.txt | 2 +- unittest/libmariadb/cs_conv.c | 9 +- unittest/libmariadb/dyncol.c | 270 +++++++++++++++++++++++++++++ unittest/libmariadb/ssl.c | 34 ++++ 10 files changed, 404 insertions(+), 67 deletions(-) create mode 100644 unittest/libmariadb/dyncol.c diff --git a/include/ma_dyncol.h b/include/ma_dyncol.h index 594ef702..a6ba4fd2 100644 --- a/include/ma_dyncol.h +++ b/include/ma_dyncol.h @@ -130,11 +130,11 @@ dynamic_column_get(DYNAMIC_COLUMN *org, uint column_nr, /* new functions */ enum enum_dyncol_func_result -mariadb_dyncol_create_many(DYNAMIC_COLUMN *str, - uint column_count, - uint *column_numbers, - DYNAMIC_COLUMN_VALUE *values, - my_bool new_string); +mariadb_dyncol_create_many_num(DYNAMIC_COLUMN *str, + uint column_count, + uint *column_numbers, + DYNAMIC_COLUMN_VALUE *values, + my_bool new_string); enum enum_dyncol_func_result mariadb_dyncol_create_many_named(DYNAMIC_COLUMN *str, uint column_count, @@ -144,10 +144,10 @@ mariadb_dyncol_create_many_named(DYNAMIC_COLUMN *str, enum enum_dyncol_func_result -mariadb_dyncol_update_many(DYNAMIC_COLUMN *str, - uint add_column_count, - uint *column_keys, - DYNAMIC_COLUMN_VALUE *values); +mariadb_dyncol_update_many_num(DYNAMIC_COLUMN *str, + uint add_column_count, + uint *column_keys, + DYNAMIC_COLUMN_VALUE *values); enum enum_dyncol_func_result mariadb_dyncol_update_many_named(DYNAMIC_COLUMN *str, uint add_column_count, @@ -156,13 +156,13 @@ mariadb_dyncol_update_many_named(DYNAMIC_COLUMN *str, 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 mariadb_dyncol_exists_named(DYNAMIC_COLUMN *str, MYSQL_LEX_STRING *name); /* List of not NULL columns */ 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 mariadb_dyncol_list_named(DYNAMIC_COLUMN *str, uint *count, 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 */ enum enum_dyncol_func_result -mariadb_dyncol_get(DYNAMIC_COLUMN *org, uint column_nr, - DYNAMIC_COLUMN_VALUE *store_it_here); +mariadb_dyncol_get_num(DYNAMIC_COLUMN *org, uint column_nr, + DYNAMIC_COLUMN_VALUE *store_it_here); enum enum_dyncol_func_result mariadb_dyncol_get_named(DYNAMIC_COLUMN *str, MYSQL_LEX_STRING *name, DYNAMIC_COLUMN_VALUE *store_it_here); diff --git a/include/mysql.h b/include/mysql.h index 84b880b9..7b3d95fc 100644 --- a/include/mysql.h +++ b/include/mysql.h @@ -52,6 +52,7 @@ typedef int my_socket; #include "mysql_com.h" #include "mysql_version.h" #include "my_list.h" +#include "m_ctype.h" #ifndef 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); my_bool STDCALL mariadb_connection(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 diff --git a/libmariadb/charset.c b/libmariadb/charset.c index 46c98e0a..8203404a 100644 --- a/libmariadb/charset.c +++ b/libmariadb/charset.c @@ -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_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; @@ -41,7 +41,7 @@ my_bool set_default_charset(uint cs, myf flags) CHARSET_INFO *new_charset; DBUG_ENTER("set_default_charset"); 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) { 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); } -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; @@ -66,7 +66,7 @@ my_bool set_default_charset_by_name(const char *cs_name, myf flags) CHARSET_INFO *new_charset; DBUG_ENTER("set_default_charset_by_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) { DBUG_PRINT("error",("Couldn't set default character set")); diff --git a/libmariadb/libmariadb_exports.def b/libmariadb/libmariadb_exports.def index a0a2e208..8539953d 100644 --- a/libmariadb/libmariadb_exports.def +++ b/libmariadb/libmariadb_exports.def @@ -106,15 +106,18 @@ EXPORTS mysql_stmt_more_results mariadb_connection 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_update_many + mariadb_dyncol_update_many_num mariadb_dyncol_update_many_named - mariadb_dyncol_exists + mariadb_dyncol_exists_num mariadb_dyncol_exists_named - mariadb_dyncol_list + mariadb_dyncol_list_num mariadb_dyncol_list_named - mariadb_dyncol_get + mariadb_dyncol_get_num mariadb_dyncol_get_named mariadb_dyncol_has_names mariadb_dyncol_check diff --git a/libmariadb/ma_dyncol.c b/libmariadb/ma_dyncol.c index 715add5b..ac0bc70c 100644 --- a/libmariadb/ma_dyncol.c +++ b/libmariadb/ma_dyncol.c @@ -75,10 +75,10 @@ uint32 copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs, CHARSET_INFO *from_cs, uint *errors); #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); -size_t convert_string(const char *from, size_t *from_len, CHARSET_INFO *from_cs, - char *to, size_t *to_len, CHARSET_INFO *to_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, int *errorcode); #endif /* 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); if (len == 0) /* Wrong packed number */ return ER_DYNCOL_FORMAT; +#ifndef LIBMARIADB 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) return ER_DYNCOL_UNKNOWN_CHARSET; data+= len; @@ -1643,15 +1647,22 @@ dynamic_new_column_store(DYNAMIC_COLUMN *str, if (!(columns_order= malloc(sizeof(void*)*column_count))) return ER_DYNCOL_RESOURCE; - if (new_str) + if (new_str || str->str == 0) { - if (dynamic_column_init_named(str, - fmt->fixed_hdr + - hdr->header_size + - hdr->nmpool_size + - hdr->data_size + - DYNCOL_SYZERESERVE)) - goto err; + if (column_count) + { + if (dynamic_column_init_named(str, + fmt->fixed_hdr + + hdr->header_size + + hdr->nmpool_size + + hdr->data_size + + DYNCOL_SYZERESERVE)) + goto err; + } + else + { + dynamic_column_initialize(str); + } } else { @@ -1856,11 +1867,11 @@ dynamic_column_create_many(DYNAMIC_COLUMN *str, */ enum enum_dyncol_func_result -mariadb_dyncol_create_many(DYNAMIC_COLUMN *str, - uint column_count, - uint *column_numbers, - DYNAMIC_COLUMN_VALUE *values, - my_bool new_string) +mariadb_dyncol_create_many_num(DYNAMIC_COLUMN *str, + uint column_count, + uint *column_numbers, + DYNAMIC_COLUMN_VALUE *values, + my_bool new_string) { DBUG_ENTER("mariadb_dyncol_create_many"); 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 -mariadb_dyncol_get(DYNAMIC_COLUMN *str, uint column_nr, - DYNAMIC_COLUMN_VALUE *store_it_here) +mariadb_dyncol_get_num(DYNAMIC_COLUMN *str, uint column_nr, + DYNAMIC_COLUMN_VALUE *store_it_here) { return dynamic_column_get_internal(str, store_it_here, column_nr, NULL); } @@ -2342,13 +2353,7 @@ err: */ enum enum_dyncol_func_result -dynamic_column_exists(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) +mariadb_dyncol_exists_num(DYNAMIC_COLUMN *str, uint column_nr) { 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 */ 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; uchar *read; uint i; enum enum_dyncol_func_result rc; - (*nums)= 0; /* In case of errors */ + (*nums)= 0; (*count)= 0; /* In case of errors */ if (str->length == 0) return ER_DYNCOL_OK; /* no columns */ @@ -3275,10 +3280,10 @@ dynamic_column_update_many(DYNAMIC_COLUMN *str, } enum enum_dyncol_func_result -mariadb_dyncol_update_many(DYNAMIC_COLUMN *str, - uint add_column_count, - uint *column_numbers, - DYNAMIC_COLUMN_VALUE *values) +mariadb_dyncol_update_many_num(DYNAMIC_COLUMN *str, + uint add_column_count, + uint *column_numbers, + DYNAMIC_COLUMN_VALUE *values) { return dynamic_column_update_many_fmt(str, add_column_count, column_numbers, values, FALSE); @@ -3887,6 +3892,8 @@ mariadb_dyncol_val_str(DYNAMIC_STRING *str, DYNAMIC_COLUMN_VALUE *val, { #ifndef LIBMARIADB uint dummy_errors; +#else + int dummy_errors; #endif if (!quote) { @@ -3899,8 +3906,8 @@ mariadb_dyncol_val_str(DYNAMIC_STRING *str, DYNAMIC_COLUMN_VALUE *val, val->x.string.charset, &dummy_errors); #else - convert_string(from, &len, val->x.string.charset, - str->str, (size_t *)&bufflen, cs); + mariadb_convert_string(from, &len, val->x.string.charset, + str->str, (size_t *)&bufflen, cs, &dummy_errors); #endif return ER_DYNCOL_OK; } @@ -3913,8 +3920,8 @@ mariadb_dyncol_val_str(DYNAMIC_STRING *str, DYNAMIC_COLUMN_VALUE *val, val->x.string.charset, &dummy_errors); #else - convert_string(from, &len, val->x.string.charset, - alloc, (size_t *)&bufflen, cs); + mariadb_convert_string(from, &len, val->x.string.charset, + alloc, (size_t *)&bufflen, cs, &dummy_errors); #endif from= alloc; } @@ -4391,6 +4398,10 @@ mariadb_dyncol_column_count(DYNAMIC_COLUMN *str, uint *column_count) DYN_HEADER header; 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) return rc; *column_count= header.column_count; diff --git a/libmariadb/my_charset.c b/libmariadb/my_charset.c index 3c05a157..e9f840ef 100644 --- a/libmariadb/my_charset.c +++ b/libmariadb/my_charset.c @@ -555,12 +555,14 @@ const CHARSET_INFO compiled_charsets[] = { 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}, { 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}, #ifdef USED_TO_BE_SO_BEFORE_MYSQL_5_5 { 60, 1, "armascii8", "armascii8_bin", "", "ARMSCII-8", 1, 1, NULL, NULL}, #endif { 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}, + { 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}, { 66, 1, "cp1250", "cp1250_bin", "", "CP1250", 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}, {"20107", "Swedish (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}, {"20269", "Non-Spacing Accent", 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 /* }}} */ -size_t convert_string(const char *from, size_t *from_len, CHARSET_INFO *from_cs, - char *to, size_t *to_len, CHARSET_INFO *to_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, int *errorcode) { iconv_t conv= 0; size_t rc= -1; size_t save_len= *to_len; char to_encoding[128]; + + *errorcode= 0; + /* check if conversion is supported */ if (!from_cs || !from_cs->encoding || !from_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); if ((conv= iconv_open(to_encoding, from_cs->encoding)) == (iconv_t)-1) + { + *errorcode= errno; goto error; + } if ((rc= iconv(conv, (char **)&from, from_len, &to, to_len)) == -1) + { + *errorcode= errno; goto error; + } rc= save_len - *to_len; error: if (conv != (iconv_t)-1) diff --git a/unittest/libmariadb/CMakeLists.txt b/unittest/libmariadb/CMakeLists.txt index 6d3587ea..27f64c1b 100644 --- a/unittest/libmariadb/CMakeLists.txt +++ b/unittest/libmariadb/CMakeLists.txt @@ -22,7 +22,7 @@ INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include ADD_DEFINITIONS(-DLIBMARIADB) 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}) ADD_EXECUTABLE(${API_TEST} ${API_TEST}.c) diff --git a/unittest/libmariadb/cs_conv.c b/unittest/libmariadb/cs_conv.c index 4e99d833..9d5c81bb 100644 --- a/unittest/libmariadb/cs_conv.c +++ b/unittest/libmariadb/cs_conv.c @@ -59,6 +59,7 @@ static int test_cs_conversion(MYSQL *mysql) while (cs_conv[i].cs_from) { + int error_code; char query[1024]; size_t from_len, to_len= 1024; CHARSET_INFO *cs_from, *cs_to; @@ -69,8 +70,8 @@ static int test_cs_conversion(MYSQL *mysql) memset(str_converted, 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_to= get_charset_by_name(cs_conv[i].cs_to)), "invalid character set"); + FAIL_IF(!(cs_from= mysql_get_charset_by_name(cs_conv[i].cs_from)), "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); @@ -94,8 +95,8 @@ static int test_cs_conversion(MYSQL *mysql) mysql_free_result(res); 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, - str_expected, &to_len, cs_to) < 1, "conversion error occured"); + FAIL_IF(mariadb_convert_string(cs_conv[i].source, &from_len, cs_from, + str_expected, &to_len, cs_to, &error_code) < 1, "conversion error occured"); if (strcmp(str_converted, str_expected)) { diff --git a/unittest/libmariadb/dyncol.c b/unittest/libmariadb/dyncol.c new file mode 100644 index 00000000..45b65a6a --- /dev/null +++ b/unittest/libmariadb/dyncol.c @@ -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()); +} diff --git a/unittest/libmariadb/ssl.c b/unittest/libmariadb/ssl.c index 8b3b42d2..79ab2d23 100644 --- a/unittest/libmariadb/ssl.c +++ b/unittest/libmariadb/ssl.c @@ -395,9 +395,43 @@ static int test_bug62743(MYSQL *my) mysql_real_connect(mysql, hostname, username, password, schema, port, socketname, 0); + diag("Error: %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", 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; }