Debian Codegraph @

mysql-test/suite/memcached/t/memc261_container_errs.test

raw
1 source include/not_valgrind.inc;
2 source include/have_memcached_plugin.inc;
3 source include/not_windows.inc;
4
5 --disable_query_log
6 CALL mtr.add_suppression("daemon-memcached-w-batch-size': unsigned");
7 CALL mtr.add_suppression("Could not obtain server's UPN to be used as target service name");
8 CALL mtr.add_suppression("Warning: MySQL is trying to drop");
9 --enable_query_log
10
11 --enable_connect_log
12 SET @transaction_isolation= @@global.transaction_isolation;
13 SET GLOBAL TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
14
15 echo #######################################################;
16 echo # Test case with expected configuration;
17 # Create the memcached tables
18 --disable_query_log
19 source include/memcache_config.inc;
20 --enable_query_log
21
22 INSERT INTO cache_policies VALUES("cache_policy", "innodb_only",
23 "innodb_only", "innodb_only", "innodb_only");
24
25 INSERT INTO config_options VALUES("separator", "|");
26
27 INSERT INTO containers VALUES ("desc_t1", "test", "t1",
28 "c1", "c11,c2,c21", "c3", "c4", "c5", "PRIMARY");
29
30 USE test;
31
32 --disable_warnings
33 DROP TABLE IF EXISTS t1;
34 --enable_warnings
35 CREATE TABLE t1 (c1 VARCHAR(32),
36 c11 VARCHAR(32),
37 c2 VARCHAR(1024),
38 c21 VARCHAR(1024),
39 c3 INT, c4 BIGINT UNSIGNED, c5 INT, primary key(c1))
40 ENGINE = INNODB;
41
42 --disable_warnings
43 DROP TABLE IF EXISTS t2;
44 --enable_warnings
45 CREATE TABLE t2 (c1 VARCHAR(32),
46 c2 VARCHAR(255),
47 c21 VARCHAR(255),
48 c3 INT, c4 BIGINT UNSIGNED, c5 INT, primary key(c1))
49 ENGINE = INNODB;
50
51 INSERT INTO t1 VALUES ('D','D', 'Darmstadt', 'City', 0, 0, 0);
52 INSERT INTO t1 VALUES ('B','B', 'Berlin', 'Mitte', 0, 0, 0);
53 INSERT INTO t1 VALUES ('C','C', 'Cottbus', 'West', 0, 0 ,0);
54 INSERT INTO t1 VALUES ('H','H', 'Hamburg', 'Norderstedt', 0, 0, 0);
55
56 INSERT INTO t2 VALUES ('D', 'Darmstadt', 'City', 0, 0, 0);
57 INSERT INTO t2 VALUES ('B', 'Berlin', 'Mitte', 0, 0, 0);
58 INSERT INTO t2 VALUES ('C', 'Cottbus', 'West', 0, 0 ,0);
59 INSERT INTO t2 VALUES ('H', 'Hamburg', 'Norderstedt', 0, 0, 0);
60
61 # Tables must exist before plugin can be started!
62 --let $memcached_address=127.0.0.1:11261
63 --source ../include/load_daemon_memcached_expecting_success.inc
64
65 --sorted_result
66 SELECT c1,c11,c2,c21 FROM t1;
67
68
69 perl;
70 use DBI;
71 use Cache::Memcached;
72 my $memd = new Cache::Memcached {
73 'servers' => [ "127.0.0.1:11261" ],
74 'connect_timeout' => 20,
75 'select_timeout' => 20
76 };
77 print "Here are the memcached results with D,B,H,C:\n";
78 $val = $memd->get("D");
79 if ($val) { print "$val\n"; }
80 $val = $memd->get("B");
81 if ($val) { print "$val\n"; }
82 $val = $memd->get("H");
83 if ($val) { print "$val\n"; }
84 $val = $memd->get("C");
85 if ($val) { print "$val\n"; }
86 print "Here are the memcached results after set:\n";
87 $val = $memd->set("E","Essen|Ost");
88 $val = $memd->get("E");
89 if ($val) { print "$val\n"; }
90 print "Here are the memcached results after add:\n";
91 $val = $memd->add("F","Frankfurt|Sachsenhause");
92 $val = $memd->get("F");
93 if ($val) { print "$val\n"; }
94 print "Here are the memcached results after replace:\n";
95 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
96 $val = $memd->get("F");
97 if ($val) { print "$val\n"; }
98 print "Here are the memcached results after delete:\n";
99 $val = $memd->delete("F");
100 $val = $memd->get("F");
101 if ($val) { print "$val\n"; }
102 print "Here are the memcached results after add Frankfurt|Airport:\n";
103 $val = $memd->add("F","Frankfurt|Airport");
104 $val = $memd->get("F");
105 if ($val) { print "$val\n"; }
106 print "Here are the memcached results after replace Frankfurt a.M|Sachsenhausen.:\n";
107 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
108 $val = $memd->get("F");
109 if ($val) { print "$val\n"; }
110 $memd->disconnect_all;
111 EOF
112
113 --sorted_result
114 SELECT c1,c11,c2,c21 FROM t1;
115
116 echo #######################################################;
117 echo # Test case with not existing table in container;
118 # Stop plugin before innodb_memcached configuration
119 UNINSTALL PLUGIN daemon_memcached;
120
121 DROP DATABASE innodb_memcache;
122 # Create the memcached tables
123 --disable_query_log
124 source include/memcache_config.inc;
125 --enable_query_log
126
127 INSERT INTO cache_policies VALUES("cache_policy", "innodb_only",
128 "innodb_only", "innodb_only", "innodb_only");
129
130 INSERT INTO config_options VALUES("separator", "|");
131
132 # t9 is not existing!
133 INSERT INTO containers VALUES ("desc_t1", "test", "t9",
134 "c1", "c11,c2,c21", "c3", "c4", "c5", "PRIMARY");
135
136 # Tables must exist before plugin can be started!
137 --let $memcached_address=127.0.0.1:11261
138 --source ../include/load_daemon_memcached_expecting_error.inc
139
140 USE test;
141 --sorted_result
142 SELECT c1,c11,c2,c21 FROM t1;
143
144 perl;
145 use DBI;
146 use Cache::Memcached;
147 my $memd = new Cache::Memcached {
148 'servers' => [ "127.0.0.1:11261" ],
149 'connect_timeout' => 20,
150 'select_timeout' => 20
151 };
152 print "Here are the memcached results with D,B,H,C:\n";
153 $val = $memd->get("D");
154 if ($val) { print "$val\n"; }
155 $val = $memd->get("B");
156 if ($val) { print "$val\n"; }
157 $val = $memd->get("H");
158 if ($val) { print "$val\n"; }
159 $val = $memd->get("C");
160 if ($val) { print "$val\n"; }
161 print "Here are the memcached results after set:\n";
162 $val = $memd->set("E","Essen|Ost");
163 $val = $memd->get("E");
164 if ($val) { print "$val\n"; }
165 print "Here are the memcached results after add:\n";
166 $val = $memd->add("F","Frankfurt|Sachsenhause");
167 $val = $memd->get("F");
168 if ($val) { print "$val\n"; }
169 print "Here are the memcached results after replace:\n";
170 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
171 $val = $memd->get("F");
172 if ($val) { print "$val\n"; }
173 print "Here are the memcached results after delete:\n";
174 $val = $memd->delete("F");
175 $val = $memd->get("F");
176 if ($val) { print "$val\n"; }
177 print "Here are the memcached results after add Frankfurt|Airport:\n";
178 $val = $memd->add("F","Frankfurt|Airport");
179 $val = $memd->get("F");
180 if ($val) { print "$val\n"; }
181 print "Here are the memcached results after replace Frankfurt a.M|Sachsenhausen.:\n";
182 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
183 $val = $memd->get("F");
184 if ($val) { print "$val\n"; }
185 $memd->disconnect_all;
186 EOF
187
188 --sorted_result
189 SELECT c1,c11,c2,c21 FROM t1;
190
191 echo #######################################################;
192 echo # Test case with not existing database in container;
193 # Stop plugin before innodb_memcached configuration
194 UNINSTALL PLUGIN daemon_memcached;
195
196 DROP DATABASE innodb_memcache;
197 # Create the memcached tables
198 --disable_query_log
199 source include/memcache_config.inc;
200 --enable_query_log
201
202 INSERT INTO cache_policies VALUES("cache_policy", "innodb_only",
203 "innodb_only", "innodb_only", "innodb_only");
204
205 INSERT INTO config_options VALUES("separator", "|");
206
207 # unknown is not existing!
208 INSERT INTO containers VALUES ("desc_t1", "unknown", "t1",
209 "c1", "c11,c2,c21", "c3", "c4", "c5", "PRIMARY");
210
211 # Tables must exist before plugin can be started!
212 --let $memcached_address=127.0.0.1:11261
213 --source ../include/load_daemon_memcached_expecting_error.inc
214
215 USE test;
216 --sorted_result
217 SELECT c1,c11,c2,c21 FROM t1;
218
219 perl;
220 use DBI;
221 use Cache::Memcached;
222 my $memd = new Cache::Memcached {
223 'servers' => [ "127.0.0.1:11261" ],
224 'connect_timeout' => 20,
225 'select_timeout' => 20
226 };
227 print "Here are the memcached results with D,B,H,C:\n";
228 $val = $memd->get("D");
229 if ($val) { print "$val\n"; }
230 $val = $memd->get("B");
231 if ($val) { print "$val\n"; }
232 $val = $memd->get("H");
233 if ($val) { print "$val\n"; }
234 $val = $memd->get("C");
235 if ($val) { print "$val\n"; }
236 print "Here are the memcached results after set:\n";
237 $val = $memd->set("E","Essen|Ost");
238 $val = $memd->get("E");
239 if ($val) { print "$val\n"; }
240 print "Here are the memcached results after add:\n";
241 $val = $memd->add("F","Frankfurt|Sachsenhause");
242 $val = $memd->get("F");
243 if ($val) { print "$val\n"; }
244 print "Here are the memcached results after replace:\n";
245 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
246 $val = $memd->get("F");
247 if ($val) { print "$val\n"; }
248 print "Here are the memcached results after delete:\n";
249 $val = $memd->delete("F");
250 $val = $memd->get("F");
251 if ($val) { print "$val\n"; }
252 print "Here are the memcached results after add Frankfurt|Airport:\n";
253 $val = $memd->add("F","Frankfurt|Airport");
254 $val = $memd->get("F");
255 if ($val) { print "$val\n"; }
256 print "Here are the memcached results after replace Frankfurt a.M|Sachsenhausen.:\n";
257 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
258 $val = $memd->get("F");
259 if ($val) { print "$val\n"; }
260 $memd->disconnect_all;
261 EOF
262
263 --sorted_result
264 SELECT c1,c11,c2,c21 FROM t1;
265
266 echo #######################################################;
267 echo # Test case with not existing key column in container;
268 # Stop plugin before innodb_memcached configuration
269 UNINSTALL PLUGIN daemon_memcached;
270
271 DROP DATABASE innodb_memcache;
272 # Create the memcached tables
273 --disable_query_log
274 source include/memcache_config.inc;
275 --enable_query_log
276
277 INSERT INTO cache_policies VALUES("cache_policy", "innodb_only",
278 "innodb_only", "innodb_only", "innodb_only");
279
280 INSERT INTO config_options VALUES("separator", "|");
281
282 # unknown is not existing!
283 INSERT INTO containers VALUES ("desc_t1", "test", "t1",
284 "unknown", "c11,c2,c21", "c3", "c4", "c5", "PRIMARY");
285
286 # Tables must exist before plugin can be started!
287 --let $memcached_address=127.0.0.1:11261
288 --source ../include/load_daemon_memcached_expecting_error.inc
289
290 USE test;
291 --sorted_result
292 SELECT c1,c11,c2,c21 FROM t1;
293
294 perl;
295 use DBI;
296 use Cache::Memcached;
297 my $memd = new Cache::Memcached {
298 'servers' => [ "127.0.0.1:11261" ],
299 'connect_timeout' => 20,
300 'select_timeout' => 20
301 };
302 print "Here are the memcached results with D,B,H,C:\n";
303 $val = $memd->get("D");
304 if ($val) { print "$val\n"; }
305 $val = $memd->get("B");
306 if ($val) { print "$val\n"; }
307 $val = $memd->get("H");
308 if ($val) { print "$val\n"; }
309 $val = $memd->get("C");
310 if ($val) { print "$val\n"; }
311 print "Here are the memcached results after set:\n";
312 $val = $memd->set("E","Essen|Ost");
313 $val = $memd->get("E");
314 if ($val) { print "$val\n"; }
315 print "Here are the memcached results after add:\n";
316 $val = $memd->add("F","Frankfurt|Sachsenhause");
317 $val = $memd->get("F");
318 if ($val) { print "$val\n"; }
319 print "Here are the memcached results after replace:\n";
320 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
321 $val = $memd->get("F");
322 if ($val) { print "$val\n"; }
323 print "Here are the memcached results after delete:\n";
324 $val = $memd->delete("F");
325 $val = $memd->get("F");
326 if ($val) { print "$val\n"; }
327 print "Here are the memcached results after add Frankfurt|Airport:\n";
328 $val = $memd->add("F","Frankfurt|Airport");
329 $val = $memd->get("F");
330 if ($val) { print "$val\n"; }
331 print "Here are the memcached results after replace Frankfurt a.M|Sachsenhausen.:\n";
332 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
333 $val = $memd->get("F");
334 if ($val) { print "$val\n"; }
335 $memd->disconnect_all;
336 EOF
337
338 --sorted_result
339 SELECT c1,c11,c2,c21 FROM t1;
340
341 echo #######################################################;
342 echo # Test case with not existing value columns in container;
343 # Stop plugin before innodb_memcached configuration
344 UNINSTALL PLUGIN daemon_memcached;
345
346 DROP DATABASE innodb_memcache;
347 # Create the memcached tables
348 --disable_query_log
349 source include/memcache_config.inc;
350 --enable_query_log
351
352 INSERT INTO cache_policies VALUES("cache_policy", "innodb_only",
353 "innodb_only", "innodb_only", "innodb_only");
354
355 INSERT INTO config_options VALUES("separator", "|");
356
357 # unknown is not existing!
358 INSERT INTO containers VALUES ("desc_t1", "test", "t1",
359 "c1", "unknown", "c3", "c4", "c5", "PRIMARY");
360
361 # Tables must exist before plugin can be started!
362 --let $memcached_address=127.0.0.1:11261
363 --source ../include/load_daemon_memcached_expecting_error.inc
364
365 USE test;
366 --sorted_result
367 SELECT c1,c11,c2,c21 FROM t1;
368
369 perl;
370 use DBI;
371 use Cache::Memcached;
372 my $memd = new Cache::Memcached {
373 'servers' => [ "127.0.0.1:11261" ],
374 'connect_timeout' => 20,
375 'select_timeout' => 20
376 };
377 print "Here are the memcached results with D,B,H,C:\n";
378 $val = $memd->get("D");
379 if ($val) { print "$val\n"; }
380 $val = $memd->get("B");
381 if ($val) { print "$val\n"; }
382 $val = $memd->get("H");
383 if ($val) { print "$val\n"; }
384 $val = $memd->get("C");
385 if ($val) { print "$val\n"; }
386 print "Here are the memcached results after set:\n";
387 $val = $memd->set("E","Essen|Ost");
388 $val = $memd->get("E");
389 if ($val) { print "$val\n"; }
390 print "Here are the memcached results after add:\n";
391 $val = $memd->add("F","Frankfurt|Sachsenhause");
392 $val = $memd->get("F");
393 if ($val) { print "$val\n"; }
394 print "Here are the memcached results after replace:\n";
395 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
396 $val = $memd->get("F");
397 if ($val) { print "$val\n"; }
398 print "Here are the memcached results after delete:\n";
399 $val = $memd->delete("F");
400 $val = $memd->get("F");
401 if ($val) { print "$val\n"; }
402 print "Here are the memcached results after add Frankfurt|Airport:\n";
403 $val = $memd->add("F","Frankfurt|Airport");
404 $val = $memd->get("F");
405 if ($val) { print "$val\n"; }
406 print "Here are the memcached results after replace Frankfurt a.M|Sachsenhausen.:\n";
407 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
408 $val = $memd->get("F");
409 if ($val) { print "$val\n"; }
410 $memd->disconnect_all;
411 EOF
412
413 --sorted_result
414 SELECT c1,c11,c2,c21 FROM t1;
415
416 echo #######################################################;
417 echo # Test case with NULL value columns in container;
418 # Stop plugin before innodb_memcached configuration
419 UNINSTALL PLUGIN daemon_memcached;
420
421 DROP DATABASE innodb_memcache;
422 # Create the memcached tables
423 --disable_query_log
424 source include/memcache_config.inc;
425 --enable_query_log
426
427 INSERT INTO cache_policies VALUES("cache_policy", "innodb_only",
428 "innodb_only", "innodb_only", "innodb_only");
429
430 INSERT INTO config_options VALUES("separator", "|");
431
432 # unknown is not existing!
433 INSERT INTO containers VALUES ("desc_t1", "test", "t1",
434 "c1", NULL, "c3", "c4", "c5", "PRIMARY");
435
436 # Tables must exist before plugin can be started!
437 --let $memcached_address=127.0.0.1:11261
438 --source ../include/load_daemon_memcached_expecting_error.inc
439
440 USE test;
441 --sorted_result
442 SELECT c1,c11,c2,c21 FROM t1;
443
444 perl;
445 use DBI;
446 use Cache::Memcached;
447 my $memd = new Cache::Memcached {
448 'servers' => [ "127.0.0.1:11261" ],
449 'connect_timeout' => 20,
450 'select_timeout' => 20
451 };
452 print "Here are the memcached results with D,B,H,C:\n";
453 $val = $memd->get("D");
454 if ($val) { print "$val\n"; }
455 $val = $memd->get("B");
456 if ($val) { print "$val\n"; }
457 $val = $memd->get("H");
458 if ($val) { print "$val\n"; }
459 $val = $memd->get("C");
460 if ($val) { print "$val\n"; }
461 print "Here are the memcached results after set:\n";
462 $val = $memd->set("E","Essen|Ost");
463 $val = $memd->get("E");
464 if ($val) { print "$val\n"; }
465 print "Here are the memcached results after add:\n";
466 $val = $memd->add("F","Frankfurt|Sachsenhause");
467 $val = $memd->get("F");
468 if ($val) { print "$val\n"; }
469 print "Here are the memcached results after replace:\n";
470 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
471 $val = $memd->get("F");
472 if ($val) { print "$val\n"; }
473 print "Here are the memcached results after delete:\n";
474 $val = $memd->delete("F");
475 $val = $memd->get("F");
476 if ($val) { print "$val\n"; }
477 print "Here are the memcached results after add Frankfurt|Airport:\n";
478 $val = $memd->add("F","Frankfurt|Airport");
479 $val = $memd->get("F");
480 if ($val) { print "$val\n"; }
481 print "Here are the memcached results after replace Frankfurt a.M|Sachsenhausen.:\n";
482 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
483 $val = $memd->get("F");
484 if ($val) { print "$val\n"; }
485 $memd->disconnect_all;
486 EOF
487
488 --sorted_result
489 SELECT c1,c11,c2,c21 FROM t1;
490
491 echo #######################################################;
492 echo # Test case with not existing non-mandatory column in container;
493 # Stop plugin before innodb_memcached configuration
494 UNINSTALL PLUGIN daemon_memcached;
495
496 DROP DATABASE innodb_memcache;
497 # Create the memcached tables
498 --disable_query_log
499 source include/memcache_config.inc;
500 --enable_query_log
501
502 INSERT INTO cache_policies VALUES("cache_policy", "innodb_only",
503 "innodb_only", "innodb_only", "innodb_only");
504
505 INSERT INTO config_options VALUES("separator", "|");
506
507 # unknown is not existing!
508 INSERT INTO containers VALUES ("desc_t1", "test", "t1",
509 "c1", "c11,c2,c21", "unknown", "unknown", "unknown", "PRIMARY");
510
511 # Tables must exist before plugin can be started!
512 --let $memcached_address=127.0.0.1:11261
513 --source ../include/load_daemon_memcached_expecting_success.inc
514
515 USE test;
516 DELETE FROM t1 WHERE c1 IN ('E','F');
517 --sorted_result
518 SELECT c1,c11,c2,c21 FROM t1;
519
520 perl;
521 use DBI;
522 use Cache::Memcached;
523 my $memd = new Cache::Memcached {
524 'servers' => [ "127.0.0.1:11261" ],
525 'connect_timeout' => 20,
526 'select_timeout' => 20
527 };
528 print "Here are the memcached results with D,B,H,C:\n";
529 $val = $memd->get("D");
530 if ($val) { print "$val\n"; }
531 $val = $memd->get("B");
532 if ($val) { print "$val\n"; }
533 $val = $memd->get("H");
534 if ($val) { print "$val\n"; }
535 $val = $memd->get("C");
536 if ($val) { print "$val\n"; }
537 print "Here are the memcached results after set:\n";
538 $val = $memd->set("E","Essen|Ost");
539 $val = $memd->get("E");
540 if ($val) { print "$val\n"; }
541 print "Here are the memcached results after add:\n";
542 $val = $memd->add("F","Frankfurt|Sachsenhause");
543 $val = $memd->get("F");
544 if ($val) { print "$val\n"; }
545 print "Here are the memcached results after replace:\n";
546 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
547 $val = $memd->get("F");
548 if ($val) { print "$val\n"; }
549 print "Here are the memcached results after delete:\n";
550 $val = $memd->delete("F");
551 $val = $memd->get("F");
552 if ($val) { print "$val\n"; }
553 print "Here are the memcached results after add Frankfurt|Airport:\n";
554 $val = $memd->add("F","Frankfurt|Airport");
555 $val = $memd->get("F");
556 if ($val) { print "$val\n"; }
557 print "Here are the memcached results after replace Frankfurt a.M|Sachsenhausen.:\n";
558 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
559 $val = $memd->get("F");
560 if ($val) { print "$val\n"; }
561 $memd->disconnect_all;
562 EOF
563
564 --sorted_result
565 SELECT c1,c11,c2,c21 FROM t1;
566
567 echo #######################################################;
568 echo # Test case map to a partitioned table;
569 # Stop plugin before innodb_memcached configuration
570 UNINSTALL PLUGIN daemon_memcached;
571
572 DROP DATABASE innodb_memcache;
573 # Create the memcached tables
574 --disable_query_log
575 source include/memcache_config.inc;
576 --enable_query_log
577
578 INSERT INTO cache_policies VALUES("cache_policy", "innodb_only",
579 "innodb_only", "innodb_only", "innodb_only");
580
581 INSERT INTO config_options VALUES("separator", "|");
582
583 # unknown is not existing!
584 INSERT INTO containers VALUES ("desc_t1", "test", "t1",
585 "c1", "c11,c2,c21", "c3", "c4", "c5", "PRIMARY");
586
587 USE test;
588
589 --disable_warnings
590 DROP TABLE IF EXISTS t1;
591 --enable_warnings
592 CREATE TABLE t1 (c1 VARCHAR(32),
593 c11 VARCHAR(32),
594 c2 VARCHAR(1024),
595 c21 VARCHAR(1024),
596 c3 INT, c4 BIGINT UNSIGNED, c5 INT, primary key(c1))
597 ENGINE = INNODB
598 PARTITION BY KEY (c1);
599
600 # Tables must exist before plugin can be started!
601 --let $memcached_address=127.0.0.1:11261
602 --source ../include/load_daemon_memcached_expecting_error.inc
603
604 USE test;
605 DELETE FROM t1 WHERE c1 IN ('E','F');
606 --sorted_result
607 SELECT c1,c11,c2,c21 FROM t1;
608
609 perl;
610 use DBI;
611 use Cache::Memcached;
612 my $memd = new Cache::Memcached {
613 'servers' => [ "127.0.0.1:11261" ],
614 'connect_timeout' => 20,
615 'select_timeout' => 20
616 };
617 print "Here are the memcached results with D,B,H,C:\n";
618 $val = $memd->get("D");
619 if ($val) { print "$val\n"; }
620 $val = $memd->get("B");
621 if ($val) { print "$val\n"; }
622 $val = $memd->get("H");
623 if ($val) { print "$val\n"; }
624 $val = $memd->get("C");
625 if ($val) { print "$val\n"; }
626 print "Here are the memcached results after set:\n";
627 $val = $memd->set("E","Essen|Ost");
628 $val = $memd->get("E");
629 if ($val) { print "$val\n"; }
630 print "Here are the memcached results after add:\n";
631 $val = $memd->add("F","Frankfurt|Sachsenhause");
632 $val = $memd->get("F");
633 if ($val) { print "$val\n"; }
634 print "Here are the memcached results after replace:\n";
635 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
636 $val = $memd->get("F");
637 if ($val) { print "$val\n"; }
638 print "Here are the memcached results after delete:\n";
639 $val = $memd->delete("F");
640 $val = $memd->get("F");
641 if ($val) { print "$val\n"; }
642 print "Here are the memcached results after add Frankfurt|Airport:\n";
643 $val = $memd->add("F","Frankfurt|Airport");
644 $val = $memd->get("F");
645 if ($val) { print "$val\n"; }
646 print "Here are the memcached results after replace Frankfurt a.M|Sachsenhausen.:\n";
647 $val = $memd->replace("F","Frankfurt a. M.|Sachsenhausen");
648 $val = $memd->get("F");
649 if ($val) { print "$val\n"; }
650 $memd->disconnect_all;
651 EOF
652
653 --sorted_result
654 SELECT c1,c11,c2,c21 FROM t1;
655
656 USE test;
657 DROP TABLE t1;
658 DROP TABLE t2;
659
660 UNINSTALL PLUGIN daemon_memcached;
661 DROP DATABASE innodb_memcache;
662
663 SET @@global.transaction_isolation= @transaction_isolation;