void test_update_many(uint *column_numbers, uint *column_values,
uint column_count,
uint *update_numbers, uint *update_values,
my_bool *update_nulls, uint update_count,
uint *result_numbers, uint *result_values,
uint result_count)
{
int rc= FALSE;
uint i;
DYNAMIC_COLUMN str1;
DYNAMIC_COLUMN str2;
DYNAMIC_COLUMN_VALUE *val, *upd, *res;
val= (DYNAMIC_COLUMN_VALUE *)malloc(sizeof(DYNAMIC_COLUMN_VALUE) *
column_count);
upd= (DYNAMIC_COLUMN_VALUE *)malloc(sizeof(DYNAMIC_COLUMN_VALUE) *
update_count);
res= (DYNAMIC_COLUMN_VALUE *)malloc(sizeof(DYNAMIC_COLUMN_VALUE) *
result_count);
for (i= 0; i < column_count; i++)
{
val[i].type= DYN_COL_UINT;
val[i].x.ulong_value= column_values[i];
}
for (i= 0; i < update_count; i++)
{
if (update_nulls[i])
upd[i].type= DYN_COL_NULL;
else
{
upd[i].type= DYN_COL_UINT;
upd[i].x.ulong_value= update_values[i];
}
}
for (i= 0; i < result_count; i++)
{
res[i].type= DYN_COL_UINT;
res[i].x.ulong_value= result_values[i];
}
if (mariadb_dyncol_create_many_num(&str1, column_count, column_numbers, val, 1))
goto err;
if (mariadb_dyncol_update_many_num(&str1, update_count, update_numbers, upd))
goto err;
if (mariadb_dyncol_create_many_num(&str2, result_count, result_numbers, res, 1))
goto err;
if (str1.length == str2.length &&
memcmp(str1.str, str2.str, str1.length) ==0)
rc= TRUE;
err:
ok(rc, "%s", "update_many");
/* cleanup */
mariadb_dyncol_free(&str1);
mariadb_dyncol_free(&str2);
}
void test_value_single_date(uint year, uint month, uint day, const char *name)
{
int rc= FALSE;
uint ids[1]= {1};
DYNAMIC_COLUMN_VALUE val, res;
DYNAMIC_COLUMN str;
/* init values */
val.type= DYN_COL_DATE;
val.x.time_value.time_type= MYSQL_TIMESTAMP_DATE;
val.x.time_value.year= year;
val.x.time_value.month= month;
val.x.time_value.day= day;
mariadb_dyncol_value_init(&res);
/* create column */
if (mariadb_dyncol_create_many_num(&str, 1, ids, &val, 1))
goto err;
dynstr_append(&str, "\1"); str.length--; //check for overflow
/* read column */
if (mariadb_dyncol_get_num(&str, 1, &res))
goto err;
rc= ((res.type == DYN_COL_DATE) &&
(res.x.time_value.time_type == MYSQL_TIMESTAMP_DATE) &&
(res.x.time_value.year == year) &&
(res.x.time_value.month == month) &&
(res.x.time_value.day == day));
err:
ok(rc, "%s - %04u-%02u-%02u", name, year, month, day);
/* cleanup */
mariadb_dyncol_free(&str);
}
void test_value_single_decimal(const char *num)
{
char *end= (((char*)num) + strlen(num));
char buff[80];
int rc= FALSE;
int length= 80;
uint ids[1]= {1};
DYNAMIC_COLUMN_VALUE val, res;
DYNAMIC_COLUMN str;
/* init values */
mariadb_dyncol_prepare_decimal(&val); // special procedure for decimal!!!
if (string2decimal(num, &val.x.decimal.value, &end) != E_DEC_OK)
goto err;
mariadb_dyncol_value_init(&res);
/* create column */
if (mariadb_dyncol_create_many_num(&str, 1, ids, &val, 1))
goto err;
dynstr_append(&str, "\1"); str.length--; //check for overflow
/* read column */
if (mariadb_dyncol_get_num(&str, 1, &res))
goto err;
rc= ((res.type == DYN_COL_DECIMAL) &&
(decimal_cmp(&res.x.decimal.value, &val.x.decimal.value) == 0));
decimal2string(&res.x.decimal.value, buff, &length, 0, 0, ' ');
err:
ok(rc, "%s - %s", num, buff);
/* cleanup */
mariadb_dyncol_free(&str);
}
void test_value_single_string(const char *string, size_t len,
CHARSET_INFO *cs)
{
int rc= FALSE;
uint ids[1]= {1};
DYNAMIC_COLUMN_VALUE val, res;
DYNAMIC_COLUMN str;
/* init values */
val.type= DYN_COL_STRING;
val.x.string.value.str= (char*)string;
val.x.string.value.length= len;
val.x.string.charset= cs;
mariadb_dyncol_value_init(&res);
/* create column */
if (mariadb_dyncol_create_many_num(&str, 1, ids, &val, 1))
goto err;
dynstr_append(&str, "\1"); str.length--; //check for overflow
/* read column */
if (mariadb_dyncol_get_num(&str, 1, &res))
goto err;
rc= ((res.type == DYN_COL_STRING) &&
(res.x.string.value.length == len) &&
(memcmp(res.x.string.value.str, string, len) == 0) &&
(res.x.string.charset->number == cs->number));
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);
/* cleanup */
val.x.string.value.str= NULL; // we did not allocated it
mariadb_dyncol_free(&str);
}
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 void test_mdev_4994()
{
DYNAMIC_COLUMN dyncol;
LEX_STRING key= {0,0};
DYNAMIC_COLUMN_VALUE val;
int rc;
val.type= DYN_COL_NULL;
mariadb_dyncol_init(&dyncol);
rc= mariadb_dyncol_create_many_named(&dyncol, 1, &key, &val, 0); /* crash */
ok( (rc == ER_DYNCOL_OK), "%s", "test_mdev_4994");
mariadb_dyncol_free(&dyncol);
}
void test_value_multi_same_num()
{
int rc= FALSE;
uint i;
DYNAMIC_COLUMN_VALUE val[5];
uint column_numbers[]= {3,4,5,3,6}; // same column numbers
DYNAMIC_COLUMN str;
/* init values */
for (i= 0; i < 5; i++)
val[i].type= DYN_COL_NULL;
/* create column */
if (!mariadb_dyncol_create_many_num(&str, 5, column_numbers, val, 1))
goto err;
rc= TRUE;
err:
ok(rc, "%s", "same column numbers check");
/* cleanup */
mariadb_dyncol_free(&str);
}
void test_value_single_datetime(uint neg, uint year, uint month, uint day,
uint hour, uint minute, uint second,
uint mic, const char *name)
{
int rc= FALSE;
uint ids[1]= {1};
DYNAMIC_COLUMN_VALUE val, res;
DYNAMIC_COLUMN str;
/* init values */
val.type= DYN_COL_DATETIME;
val.x.time_value.time_type= MYSQL_TIMESTAMP_DATETIME;
val.x.time_value.neg= neg;
val.x.time_value.year= year;
val.x.time_value.month= month;
val.x.time_value.day= day;
val.x.time_value.hour= hour;
val.x.time_value.minute= minute;
val.x.time_value.second= second;
val.x.time_value.second_part= mic;
mariadb_dyncol_value_init(&res);
/* create column */
if (mariadb_dyncol_create_many_num(&str, 1, ids, &val, 1))
goto err;
dynstr_append(&str, "\1"); str.length--; //check for overflow
/* read column */
if (mariadb_dyncol_get_num(&str, 1, &res))
goto err;
rc= ((res.type == DYN_COL_DATETIME) &&
(res.x.time_value.time_type == MYSQL_TIMESTAMP_DATETIME) &&
(res.x.time_value.neg == (int)neg) &&
(res.x.time_value.year == year) &&
(res.x.time_value.month == month) &&
(res.x.time_value.day == day) &&
(res.x.time_value.hour == hour) &&
(res.x.time_value.minute == minute) &&
(res.x.time_value.second == second) &&
(res.x.time_value.second_part == mic));
err:
ok(rc, "%s - %c %04u-%02u-%02u %02u:%02u:%02u.%06u", name, (neg ? '-' : '+'),
year, month, day, hour, minute, second, mic);
/* cleanup */
mariadb_dyncol_free(&str);
}
static void test_mdev_9773()
{
int rc;
uint i;
uint num_keys[5]= {1,2,3,4,5};
char const *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5"};
DYNAMIC_COLUMN_VALUE vals[5];
DYNAMIC_COLUMN dynstr;
uint unpack_columns= 0;
MYSQL_LEX_STRING *unpack_keys= 0;
DYNAMIC_COLUMN_VALUE *unpack_vals= 0;
for (i = 0; i < 5; i++)
{
vals[i].type= DYN_COL_STRING;
vals[i].x.string.value.str= (char *)strval[i];
vals[i].x.string.value.length= strlen(strval[i]);
vals[i].x.string.charset= &my_charset_latin1;
}
mariadb_dyncol_init(&dynstr);
/* create numeric */
rc= mariadb_dyncol_create_many_num(&dynstr, 5, num_keys, vals, 1);
if (rc == ER_DYNCOL_OK)
rc= mariadb_dyncol_unpack(&dynstr, &unpack_columns, &unpack_keys,
&unpack_vals);
ok (rc == ER_DYNCOL_OK && unpack_columns == 5, "5 fields unpacked");
for (i = 0; i < unpack_columns; i++)
{
ok(memcmp(unpack_vals[i].x.string.value.str,
vals[i].x.string.value.str, vals[i].x.string.value.length) == 0,
"unpack %u", i);
}
my_free(unpack_keys);
my_free(unpack_vals);
mariadb_dyncol_free(&dynstr);
}
void test_value_single_null()
{
int rc= FALSE;
uint ids[1]= {1};
DYNAMIC_COLUMN_VALUE val, res;
DYNAMIC_COLUMN str;
/* init values */
val.type= DYN_COL_NULL;
mariadb_dyncol_value_init(&res);
/* create column */
if (mariadb_dyncol_create_many_num(&str, 1, ids, &val, 1))
goto err;
dynstr_append(&str, "\1"); str.length--; //check for overflow
/* read column */
if (mariadb_dyncol_get_num(&str, 1, &res))
goto err;
rc= (res.type == DYN_COL_NULL);
err:
ok(rc, "%s", "NULL");
/* cleanup */
mariadb_dyncol_free(&str);
}
int main(int argc, char *argv[])
{
DYNAMIC_COLUMN dyncol;
MYSQL_LEX_STRING *list_keys, my_keys[]= {{"key1", 4}, {"key2",4}, {"key3", 4}};
char *my_vals[]= {"value1", "value2", "value3"};
DYNAMIC_COLUMN_VALUE *vals;
unsigned int i, column_count;
CHARSET_INFO *cs= mysql_get_charset_by_name("utf8");
mariadb_dyncol_init(&dyncol);
vals= (DYNAMIC_COLUMN_VALUE *)malloc(sizeof(DYNAMIC_COLUMN_VALUE) * 3);
for (i=0; i < 3; i++)
{
vals[i].type= DYN_COL_STRING;
vals[i].x.string.value.length= strlen(my_vals[i]);
vals[i].x.string.value.str= my_vals[i];
vals[i].x.string.charset= cs;
}
/* Add columns */
if (mariadb_dyncol_create_many_named(&dyncol, 3, my_keys, vals, 0) != ER_DYNCOL_OK)
{
printf("Can't add columns\n");
exit(-1);
}
if (mariadb_dyncol_list_named(&dyncol, &column_count, &list_keys) == ER_DYNCOL_OK)
{
for (i=0; i < column_count; i++)
printf("Column: %u Key: %s\n", i, list_keys[i].str);
/* Don't forget to free the keys! */
free(list_keys);
}
mariadb_dyncol_free(&dyncol);
return 0;
}
void test_value_single_sint(longlong num, const char *name)
{
int rc= FALSE;
uint ids[1]= {1};
DYNAMIC_COLUMN_VALUE val, res;
DYNAMIC_COLUMN str;
/* init values */
val.type= DYN_COL_INT;
val.x.long_value= num;
mariadb_dyncol_value_init(&res);
/* create column */
if (mariadb_dyncol_create_many_num(&str, 1, ids, &val, 1))
goto err;
dynstr_append(&str, "\1"); str.length--; //check for overflow
/* read column */
if (mariadb_dyncol_get_num(&str, 1, &res))
goto err;
rc= (res.type == DYN_COL_INT) && (res.x.long_value == num);
num= res.x.ulong_value;
err:
ok(rc, "%s - %lld", name, num);
/* cleanup */
mariadb_dyncol_free(&str);
}
void test_empty_string()
{
DYNAMIC_COLUMN_VALUE val, res;
DYNAMIC_COLUMN str;
uint *array_of_uint;
uint number_of_uint;
int rc;
uint ids[1]= {1};
DYNAMIC_COLUMN_VALUE vals[1];
/* empty string */
bzero(&str, sizeof(str));
rc= mariadb_dyncol_get_num(&str, 1, &res);
ok( (rc == ER_DYNCOL_OK) && (res.type == DYN_COL_NULL), "%s", "empty get");
vals[0].type= DYN_COL_NULL;
rc= mariadb_dyncol_update_many_num(&str, 1, ids, vals);
ok( (rc == ER_DYNCOL_OK) && (str.str == 0), "%s", "empty delete");
rc= mariadb_dyncol_exists_num(&str, 1);
ok( (rc == ER_DYNCOL_NO), "%s", "empty exists");
rc= mariadb_dyncol_list_num(&str, &number_of_uint, &array_of_uint);
ok( (rc == ER_DYNCOL_OK) && (number_of_uint == 0) && (str.str == 0),
"%s", "empty list");
val.type= DYN_COL_UINT;
val.x.ulong_value= 1212;
rc= mariadb_dyncol_update_many_num(&str, 1, ids, &val);
if (rc == ER_DYNCOL_OK)
rc= mariadb_dyncol_get_num(&str, 1, &res);
ok( (rc == ER_DYNCOL_OK) && (str.str != 0) &&
(res.type == DYN_COL_UINT) && (res.x.ulong_value == val.x.ulong_value),
"%s", "empty update");
mariadb_dyncol_free(&str);
}
void test_value_multi(ulonglong num0,
longlong num1,
double num2,
const char *num3,
const char *string4, size_t len4, CHARSET_INFO *cs4,
uint year5, uint month5, uint day5,
uint neg6, uint hour6, uint minute6,
uint second6, uint mic6,
uint neg7, uint year7, uint month7, uint day7,
uint hour7, uint minute7, uint second7,
uint mic7,
uint *column_numbers,
const char *name)
{
char *end3= (((char*)num3) + strlen(num3));
int rc= FALSE;
uint i;
DYNAMIC_COLUMN_VALUE val[9], res[9];
DYNAMIC_COLUMN str;
/* init values */
val[0].type= DYN_COL_UINT;
val[0].x.ulong_value= num0;
val[1].type= DYN_COL_INT;
val[1].x.long_value= num1;
val[2].type= DYN_COL_DOUBLE;
val[2].x.double_value= num2;
mariadb_dyncol_prepare_decimal(val + 3); // special procedure for decimal!!!
if (string2decimal(num3, &val[3].x.decimal.value, &end3) != E_DEC_OK)
goto err;
val[4].type= DYN_COL_STRING;
val[4].x.string.value.str= (char*)string4;
val[4].x.string.value.length= len4;
val[4].x.string.charset= cs4;
val[5].type= DYN_COL_DATE;
val[5].x.time_value.time_type= MYSQL_TIMESTAMP_DATE;
val[5].x.time_value.year= year5;
val[5].x.time_value.month= month5;
val[5].x.time_value.day= day5;
val[6].type= DYN_COL_TIME;
val[6].x.time_value.time_type= MYSQL_TIMESTAMP_TIME;
val[6].x.time_value.neg= neg6;
val[6].x.time_value.hour= hour6;
val[6].x.time_value.minute= minute6;
val[6].x.time_value.second= second6;
val[6].x.time_value.second_part= mic6;
val[7].type= DYN_COL_DATETIME;
val[7].x.time_value.time_type= MYSQL_TIMESTAMP_DATETIME;
val[7].x.time_value.neg= neg7;
val[7].x.time_value.year= year7;
val[7].x.time_value.month= month7;
val[7].x.time_value.day= day7;
val[7].x.time_value.hour= hour7;
val[7].x.time_value.minute= minute7;
val[7].x.time_value.second= second7;
val[7].x.time_value.second_part= mic7;
val[8].type= DYN_COL_NULL;
for (i= 0; i < 9; i++)
mariadb_dyncol_value_init(res + i);
/* create column */
if (mariadb_dyncol_create_many_num(&str, 9, column_numbers, val, 1))
goto err;
dynstr_append(&str, "\1"); str.length--; //check for overflow
/* read column */
for (i= 0; i < 9; i++)
if (mariadb_dyncol_get_num(&str, column_numbers[i], res + i))
goto err;
rc= ((res[0].type == DYN_COL_UINT) &&
(res[0].x.ulong_value == num0) &&
(res[1].type == DYN_COL_INT) &&
(res[1].x.long_value == num1) &&
(res[2].type == DYN_COL_DOUBLE) &&
(res[2].x.double_value == num2) &&
(res[3].type == DYN_COL_DECIMAL) &&
(decimal_cmp(&res[3].x.decimal.value, &val[3].x.decimal.value) == 0) &&
(res[4].type == DYN_COL_STRING) &&
(res[4].x.string.value.length == len4) &&
(memcmp(res[4].x.string.value.str, string4, len4) == 0) &&
(res[4].x.string.charset->number == cs4->number) &&
(res[5].type == DYN_COL_DATE) &&
(res[5].x.time_value.time_type == MYSQL_TIMESTAMP_DATE) &&
(res[5].x.time_value.year == year5) &&
(res[5].x.time_value.month == month5) &&
(res[5].x.time_value.day == day5) &&
(res[6].type == DYN_COL_TIME) &&
(res[6].x.time_value.time_type == MYSQL_TIMESTAMP_TIME) &&
(res[6].x.time_value.neg == (int)neg6) &&
(res[6].x.time_value.hour == hour6) &&
(res[6].x.time_value.minute == minute6) &&
(res[6].x.time_value.second == second6) &&
(res[6].x.time_value.second_part == mic6) &&
(res[7].type == DYN_COL_DATETIME) &&
(res[7].x.time_value.time_type == MYSQL_TIMESTAMP_DATETIME) &&
(res[7].x.time_value.neg == (int)neg7) &&
(res[7].x.time_value.year == year7) &&
(res[7].x.time_value.month == month7) &&
(res[7].x.time_value.day == day7) &&
(res[7].x.time_value.hour == hour7) &&
(res[7].x.time_value.minute == minute7) &&
(res[7].x.time_value.second == second7) &&
(res[7].x.time_value.second_part == mic7) &&
(res[8].type == DYN_COL_NULL));
err:
ok(rc, "%s", name);
/* cleanup */
val[4].x.string.value.str= NULL; // we did not allocated it
mariadb_dyncol_free(&str);
}
static int mdev_x1(MYSQL *mysql)
{
int rc;
uint i;
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 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;
}
void test_update_multi(uint *column_numbers, uint *column_values,
my_bool *null_values, int only_add, int all)
{
int rc= FALSE;
int i, j;
DYNAMIC_COLUMN str;
DYNAMIC_COLUMN_VALUE val;
val.type= DYN_COL_UINT;
val.x.ulong_value= column_values[0];
if (mariadb_dyncol_create_many_num(&str, 1, column_numbers, &val, 1))
goto err;
for (i= 1; i < all; i++)
{
val.type= (null_values[i] ? DYN_COL_NULL : DYN_COL_UINT);
val.x.ulong_value= column_values[i];
if (mariadb_dyncol_update_many_num(&str, 1, column_numbers +i, &val))
goto err;
/* check value(s) */
for (j= i; j >= (i < only_add ? 0 : i); j--)
{
if (mariadb_dyncol_get_num(&str, column_numbers[j], &val))
goto err;
if (null_values[j])
{
if (val.type != DYN_COL_NULL ||
mariadb_dyncol_exists_num(&str, column_numbers[j]) == ER_DYNCOL_YES)
goto err;
}
else
{
if (val.type != DYN_COL_UINT ||
val.x.ulong_value != column_values[j] ||
mariadb_dyncol_exists_num(&str, column_numbers[j]) == ER_DYNCOL_NO)
goto err;
}
}
if (i < only_add)
{
uint elements, *num;
if (mariadb_dyncol_list_num(&str, &elements, &num))
{
my_free(num);
goto err;
}
/* cross check arrays */
if ((int)elements != i + 1)
{
my_free(num);
goto err;
}
for(j= 0; j < i + 1; j++)
{
int k;
for(k= 0;
k < i + 1 && column_numbers[j] != num[k];
k++);
if (k >= i + 1)
{
my_free(num);
goto err;
}
for(k= 0;
k < i + 1 && column_numbers[k] != num[j];
k++);
if (k >= i + 1)
{
my_free(num);
goto err;
}
}
my_free(num);
}
}
rc= TRUE;
err:
ok(rc, "%s", "add/delete/update");
/* cleanup */
mariadb_dyncol_free(&str);
}
