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

@@ -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);

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 <my_stmt.h>
   

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"));

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

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;

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)

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)

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))
     {

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());
+}

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;
 }