1 | /* |
2 | Copyright (c) 2013 Monty Program AB. All rights reserved. |
3 | |
4 | This program is free software; you can redistribute it and/or modify |
5 | it under the terms of the GNU General Public License as published |
6 | by the Free Software Foundation; version 2 of the License. |
7 | |
8 | This program is distributed in the hope that it will be useful, but |
9 | WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
10 | or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
11 | for more details. |
12 | |
13 | You should have received a copy of the GNU General Public License along |
14 | with this program; if not, write to the Free Software Foundation, Inc., |
15 | 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
16 | */ |
17 | |
18 | #include "my_test.h" |
19 | #include "mariadb_dyncol.h" |
20 | |
21 | static int create_dyncol_named(MYSQL *mysql) |
22 | { |
23 | DYNAMIC_COLUMN dyncol; |
24 | DYNAMIC_COLUMN_VALUE *vals; |
25 | uint i, column_count= 6; |
26 | int rc; |
27 | const char *strval[]= {"Val1" , "Val2" , "Val3" , "Val4" , "Val5" , "Val6" }; |
28 | MYSQL_LEX_STRING keys1[]= {{(char *)"key1" , 4}, {(char *)"key2" , 4}, |
29 | {(char *)"key3" , 4}, {(char *)"key4" , 4}, |
30 | {(char *)"key5" , 4}, {(char *)"key6" , 4}}, |
31 | |
32 | keys2[]= {{(char *)"key1" , 4}, {(char *)"key1" , 4}, |
33 | {(char *)"key3" , 4}, {(char *)"key4" , 4}, |
34 | {(char *)"key5" , 4}, {(char *)"key6" , 4}}, |
35 | |
36 | keys3[]= {{(char *)"\x70\x61\x72\x61\x00\x30" , 6}, |
37 | {(char *)"\x70\x61\x72\x61\x00\x31" , 6}, |
38 | {(char *)"\x70\x61\x72\x61\x00\x32" , 6}, |
39 | {(char *)"\x70\x61\x72\x61\x00\x33" , 6}, |
40 | {(char *)"\x70\x61\x72\x61\x00\x34" , 6}, |
41 | {(char *)"\x70\x61\x72\x61\x00\x35" , 6}}; |
42 | MYSQL_LEX_STRING *my_keys; |
43 | uint my_count; |
44 | |
45 | vals= (DYNAMIC_COLUMN_VALUE *)malloc(column_count * sizeof(DYNAMIC_COLUMN_VALUE)); |
46 | |
47 | for (i=0; i < column_count; i++) |
48 | { |
49 | vals[i].type= DYN_COL_STRING; |
50 | vals[i].x.string.value.str= (char *)strval[i]; |
51 | vals[i].x.string.value.length= strlen(strval[i]); |
52 | vals[i].x.string.charset= (MARIADB_CHARSET_INFO *)mysql->charset; |
53 | diag("%s" , keys3[i].str); |
54 | } |
55 | |
56 | mariadb_dyncol_init(&dyncol); |
57 | rc= mariadb_dyncol_create_many_named(&dyncol, column_count, keys1, vals, 0); |
58 | FAIL_IF(mariadb_dyncol_create_many_named(&dyncol, column_count, keys1, vals, 1) < 0, "Error" ); |
59 | column_count= 0; |
60 | FAIL_IF(mariadb_dyncol_column_count(&dyncol, &column_count) < 0, "Error" ); |
61 | |
62 | FAIL_IF(column_count != 6, "6 columns expected" ); |
63 | mariadb_dyncol_free(&dyncol); |
64 | |
65 | rc= mariadb_dyncol_create_many_named(&dyncol, column_count, keys3, vals, 1); |
66 | if (rc < 0) { |
67 | diag("Error!!: %d" , rc); |
68 | return FAIL; |
69 | } |
70 | column_count= 0; |
71 | FAIL_IF(mariadb_dyncol_column_count(&dyncol, &column_count) < 0, "Error" ); |
72 | |
73 | FAIL_IF(column_count != 6, "6 columns expected" ); |
74 | |
75 | mariadb_dyncol_free(&dyncol); |
76 | |
77 | /* Now try to add a duplicate key */ |
78 | |
79 | FAIL_IF(mariadb_dyncol_create_many_named(&dyncol, column_count, keys2, vals, 1) >=0, "Error expected" ); |
80 | mariadb_dyncol_free(&dyncol); |
81 | |
82 | /* binary keys */ |
83 | rc= mariadb_dyncol_create_many_named(&dyncol, column_count, keys3, vals, 1); |
84 | FAIL_IF(rc < 0, "binary keys failed" ); |
85 | |
86 | /* get keys*/ |
87 | rc= mariadb_dyncol_list_named(&dyncol, &my_count, &my_keys); |
88 | FAIL_IF(rc < 0, "list named failed" ); |
89 | |
90 | for (i=0; i < my_count; i++) |
91 | { |
92 | if (memcmp(my_keys[i].str, keys3[i].str, keys3[i].length) != 0) |
93 | diag("error key %d" , i); |
94 | vals[i].type=DYN_COL_NULL; |
95 | } |
96 | rc= mariadb_dyncol_update_many_named(&dyncol, column_count, keys3, vals); |
97 | FAIL_IF(rc < 0, "update failed" ); |
98 | mariadb_dyncol_free(&dyncol); |
99 | |
100 | keys3[0].str= (char *)"test" ; |
101 | for (i=0; i < column_count; i++) |
102 | diag("%s" , my_keys[i].str); |
103 | |
104 | free(vals); |
105 | free(my_keys); |
106 | return OK; |
107 | } |
108 | |
109 | static int mdev_4994(MYSQL *unused __attribute__((unused))) |
110 | { |
111 | DYNAMIC_COLUMN dyncol; |
112 | uint key= 1; |
113 | DYNAMIC_COLUMN_VALUE val; |
114 | int rc; |
115 | |
116 | |
117 | val.type= DYN_COL_NULL; |
118 | |
119 | mariadb_dyncol_init(&dyncol); |
120 | rc= mariadb_dyncol_create_many_num(&dyncol, 1, &key, &val, 0); |
121 | FAIL_IF(rc < 0, "Unexpected error" ); |
122 | return OK; |
123 | } |
124 | |
125 | static int create_dyncol_num(MYSQL *mysql) |
126 | { |
127 | DYNAMIC_COLUMN dyncol; |
128 | DYNAMIC_COLUMN_VALUE vals[5]; |
129 | uint i, column_count= 5; |
130 | uint my_count; |
131 | MYSQL_LEX_STRING *my_keys; |
132 | DYNAMIC_COLUMN_VALUE *my_vals; |
133 | int rc; |
134 | const char *strval[]= {"Val1" , "Val2" , "Val3" , "Val4" , "Val5" }; |
135 | |
136 | uint keys1[5]= {1,2,3,4,5}, |
137 | keys2[5]= {1,2,2,4,5}; |
138 | MYSQL_LEX_STRING key1= {(char *)"1" ,1}; |
139 | |
140 | for (i=0; i < column_count; i++) |
141 | { |
142 | vals[i].type= DYN_COL_STRING; |
143 | vals[i].x.string.value.str= (char *)strval[i]; |
144 | vals[i].x.string.value.length= strlen(strval[i]); |
145 | vals[i].x.string.charset= (MARIADB_CHARSET_INFO *)mysql->charset; |
146 | } |
147 | FAIL_IF(mariadb_dyncol_create_many_num(&dyncol, column_count, keys1, vals, 1) <0, "Error (keys1)" ); |
148 | |
149 | vals[0].x.string.value.str= (char *)strval[1]; |
150 | rc= mariadb_dyncol_update_many_named(&dyncol,1, &key1, vals); |
151 | diag("update: %d" , rc); |
152 | |
153 | rc= mariadb_dyncol_unpack(&dyncol, &my_count, &my_keys, &my_vals); |
154 | diag("unpack: %d %d" , rc, my_count); |
155 | |
156 | free(my_keys); |
157 | free(my_vals); |
158 | |
159 | FAIL_IF(mariadb_dyncol_column_count(&dyncol, &column_count) < 0, "Error" ); |
160 | FAIL_IF(column_count != 5, "5 columns expected" ); |
161 | mariadb_dyncol_free(&dyncol); |
162 | FAIL_IF(mariadb_dyncol_create_many_num(&dyncol, column_count, keys2, vals, 1) >=0, "Error expected (keys2)" ); |
163 | mariadb_dyncol_free(&dyncol); |
164 | return OK; |
165 | } |
166 | |
167 | static int mdev_x1(MYSQL *mysql) |
168 | { |
169 | int rc; |
170 | uint i; |
171 | uint num_keys[5]= {1,2,3,4,5}; |
172 | const char *strval[]= {"Val1" , "Val2" , "Val3" , "Val4" , "Val5" }; |
173 | DYNAMIC_COLUMN_VALUE vals[5]; |
174 | DYNAMIC_COLUMN dynstr; |
175 | MYSQL_LEX_STRING my_key= {(char *)"1" , 2}; |
176 | uint unpack_columns; |
177 | MYSQL_LEX_STRING *unpack_keys; |
178 | DYNAMIC_COLUMN_VALUE *unpack_vals; |
179 | |
180 | for (i=0; i < 5; i++) |
181 | { |
182 | vals[i].type= DYN_COL_STRING; |
183 | vals[i].x.string.value.str= (char *)strval[i]; |
184 | vals[i].x.string.value.length= strlen(strval[i]); |
185 | vals[i].x.string.charset= (MARIADB_CHARSET_INFO *)mysql->charset; |
186 | } |
187 | |
188 | mariadb_dyncol_init(&dynstr); |
189 | |
190 | /* create numeric */ |
191 | rc= mariadb_dyncol_create_many_num(&dynstr, 5, num_keys, vals, 1); |
192 | if (rc < 0) |
193 | { |
194 | diag("Error: %d" , rc); |
195 | return FAIL; |
196 | } |
197 | |
198 | /* unpack and print values */ |
199 | rc= mariadb_dyncol_unpack(&dynstr, &unpack_columns, &unpack_keys, &unpack_vals); |
200 | if (rc < 0) |
201 | { |
202 | diag("Error: %d" , rc); |
203 | return FAIL; |
204 | } |
205 | |
206 | for (i=0; i < unpack_columns; i++) |
207 | if (memcmp(unpack_vals[i].x.string.value.str, vals[i].x.string.value.str, vals[i].x.string.value.length)) |
208 | diag("Error1: key: %1s val: %s %s" , unpack_keys[i].str, unpack_vals[i].x.string.value.str, vals[i].x.string.value.str); |
209 | |
210 | free(unpack_keys); |
211 | free(unpack_vals); |
212 | |
213 | /* change one value and update with named key */ |
214 | /* vals[0].x.string.value.str= strval[1]; */ |
215 | rc= mariadb_dyncol_update_many_named(&dynstr, 1, &my_key, vals); |
216 | if (rc < 0) |
217 | { |
218 | diag("Error: %d" , rc); |
219 | return FAIL; |
220 | } |
221 | |
222 | /* unpack and print values */ |
223 | rc= mariadb_dyncol_unpack(&dynstr, &unpack_columns, &unpack_keys, &unpack_vals); |
224 | if (rc < 0) |
225 | { |
226 | diag("Error: %d" , rc); |
227 | return FAIL; |
228 | } |
229 | diag("Columns: %d" , unpack_columns); |
230 | |
231 | for (i=0; i < unpack_columns; i++) |
232 | diag("Key: %s Len: %lu" , unpack_keys[i].str, (unsigned long)unpack_keys[i].length); |
233 | |
234 | |
235 | free(unpack_keys); |
236 | free(unpack_vals); |
237 | |
238 | mariadb_dyncol_free(&dynstr); |
239 | return OK; |
240 | } |
241 | |
242 | static int dyncol_column_count(MYSQL *unused __attribute__((unused))) |
243 | { |
244 | DYNAMIC_COLUMN dyncol; |
245 | uint column_count= 5; |
246 | int rc; |
247 | |
248 | mariadb_dyncol_init(&dyncol); /* memset(&dyncol, 0, sizeof(DYNAMIC_COLUMN)) */ |
249 | rc= mariadb_dyncol_column_count(&dyncol, &column_count); |
250 | diag("rc=%d" , rc); |
251 | FAIL_IF(rc < 0, "unexpected error" ); |
252 | FAIL_IF(column_count > 0, "Expected column_count=0" ); |
253 | return OK; |
254 | } |
255 | |
256 | struct my_tests_st my_tests[] = { |
257 | {"mdev_x1" , mdev_x1, TEST_CONNECTION_NEW, 0, NULL, NULL}, |
258 | {"mdev_4994" , mdev_4994, TEST_CONNECTION_NEW, 0, NULL, NULL}, |
259 | {"create_dyncol_named" , create_dyncol_named, TEST_CONNECTION_NEW, 0, NULL, NULL}, |
260 | {"create_dyncol_num" , create_dyncol_num, TEST_CONNECTION_NEW, 0, NULL, NULL}, |
261 | {"dyncol_column_count" , dyncol_column_count, TEST_CONNECTION_NEW, 0, NULL, NULL}, |
262 | {NULL, NULL, 0, 0, NULL, 0} |
263 | }; |
264 | |
265 | |
266 | int main(int argc, char **argv) |
267 | { |
268 | if (argc > 1) |
269 | get_options(argc, argv); |
270 | |
271 | get_envvars(); |
272 | |
273 | run_tests(my_tests); |
274 | |
275 | return(exit_status()); |
276 | } |
277 | |