~drizzle-trunk/drizzle/development
» Revision
236.1.14
(compared to revision 201.1.1)
: client/drizzletest.cc
« back to all changes in this revision
Viewing changes to client/drizzletest.cc
- browse files at revision 236.1.14
- compare with another revision
- download diff
- download tarball
- view history from revision 236.1.14
- Committer: Monty Taylor
- Date: 2008-07-30 22:37:03 UTC
- mfrom: (134.2.1 antony.1)
- mto: (202.3.5 gettextize)
- mto: This revision was merged to the branch mainline in revision 243.
- Revision ID: monty@inaugust.com-20080730223703-8cizw5ioy6uapcsj
Merged build changes from Antony.
- files added:
- client/errname.h
- drizzled/field
- drizzled/share/czech
- drizzled/share/danish
- drizzled/share/dutch
- drizzled/share/english
- drizzled/share/estonian
- drizzled/share/french
- drizzled/share/german
- drizzled/share/greek
- drizzled/share/hungarian
- drizzled/share/italian
- drizzled/share/japanese
- drizzled/share/japanese-sjis
- drizzled/share/korean
- drizzled/share/norwegian
- drizzled/share/norwegian-ny
- drizzled/share/polish
- drizzled/share/portuguese
- drizzled/share/romanian
- drizzled/share/russian
- drizzled/share/serbian
- drizzled/share/slovak
- drizzled/share/spanish
- drizzled/share/swedish
- drizzled/share/ukrainian
- plugin/crc32
- plugin/md5
- files removed:
- extra/comp_err.c
- include
- include/mysql
- files renamed:
- server/ => drizzled/
- include/my_base.h => drizzled/base.h
- include/my_global.h => drizzled/global.h
- include/mysql/plugin.h => drizzled/plugin.h
- include/mysql/plugin_audit.h => drizzled/plugin_audit.h
- include/drizzle_version.h.in => drizzled/version.h.in
- include/drizzle.h => libdrizzle/drizzle.h
- include/drizzle_com.h => libdrizzle/drizzle_com.h
- include/drizzle_h.ic => libdrizzle/drizzle_h.ic
- include/drizzle_time.h => libdrizzle/drizzle_time.h
- include/errmsg.h => libdrizzle/errmsg.h
- include/my_time.h => libdrizzle/my_time.h
- include/sql_common.h => libdrizzle/sql_common.h
- strings/ => mystrings/
- include/decimal.h => mystrings/decimal.h
- include/m_ctype.h => mystrings/m_ctype.h
- include/m_string.h => mystrings/m_string.h
- include/my_uctype.h => mystrings/my_uctype.h
- include/my_xml.h => mystrings/my_xml.h
- include/base64.h => mysys/base64.h
- include/hash.h => mysys/hash.h
- include/my_alloc.h => mysys/my_alloc.h
- include/my_bit.h => mysys/my_bit.h
- include/my_bitmap.h => mysys/my_bitmap.h
- include/my_dir.h => mysys/my_dir.h
- include/my_getopt.h => mysys/my_getopt.h
- include/my_handler.h => mysys/my_handler.h
- include/my_list.h => mysys/my_list.h
- include/my_nosys.h => mysys/my_nosys.h
- include/my_pthread.h => mysys/my_pthread.h
- include/my_sys.h => mysys/my_sys.h
- include/my_tree.h => mysys/my_tree.h
- include/mysys_err.h => mysys/mysys_err.h
- include/queues.h => mysys/queues.h
- include/sha1.h => mysys/sha1.h
- include/thr_alarm.h => mysys/thr_alarm.h
- include/thr_lock.h => mysys/thr_lock.h
- include/typelib.h => mysys/typelib.h
- include/heap.h => storage/heap/heap.h
- include/keycache.h => storage/myisam/keycache.h
- include/myisam.h => storage/myisam/myisam.h
- include/myisammrg.h => storage/myisam/myisammrg.h
- include/myisampack.h => storage/myisam/myisampack.h
- include/violite.h => vio/violite.h
- files modified:
- .bzrignore
added
removed
client/drizzletest.cc
1
/* Copyright (C) 2000 MySQL AB
1
/* Copyright (C) 2008 Drizzle Open Source Development Team
2
2
3
3
This program is free software; you can redistribute it and/or modify
4
4
it under the terms of the GNU General Public License as published by
14
14
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
15
15
16
16
/*
17
mysqltest
17
drizzletest
18
18
19
19
Tool used for executing a .test file
20
20
21
See the "MySQL Test framework manual" for more information
22
http://dev.mysql.com/doc/mysqltest/en/index.html
21
See the "DRIZZLE Test framework manual" for more information
22
http://dev.mysql.com/doc/drizzletest/en/index.html
23
23
24
24
Please keep the test framework tools identical in all versions!
25
25
35
35
#include <pcrecpp.h>
36
36
37
37
#include "client_priv.h"
38
#include <drizzle_version.h>
39
#include <mysqld_error.h>
40
#include <m_ctype.h>
41
#include <my_dir.h>
42
#include <hash.h>
38
#include <mysys/hash.h>
43
39
#include <stdarg.h>
44
#include <violite.h>
40
#include <vio/violite.h>
45
41
42
#include "errname.h"
46
43
47
44
#define MAX_VAR_NAME_LENGTH 256
48
45
#define MAX_COLUMNS 256
80
77
static bool server_initialized= 0;
81
78
static bool is_windows= 0;
82
79
static char **default_argv;
83
static const char *load_default_groups[]= { "mysqltest", "client", 0 };
80
static const char *load_default_groups[]= { "drizzletest", "client", 0 };
84
81
static char line_buffer[MAX_DELIMITER_LENGTH], *line_buffer_pos= line_buffer;
85
82
86
83
static uint start_lineno= 0; /* Start line of current command */
126
123
127
124
static CHARSET_INFO *charset_info= &my_charset_latin1; /* Default charset */
128
125
129
static const char *embedded_server_groups[]=
130
{
131
"server",
132
"embedded",
133
"mysqltest_SERVER",
134
NullS
135
};
136
137
126
static int embedded_server_arg_count=0;
138
127
static char *embedded_server_args[MAX_EMBEDDED_SERVER_ARGS];
139
128
186
175
187
176
struct st_connection
188
177
{
189
MYSQL mysql;
178
DRIZZLE drizzle;
190
179
/* Used when creating views and sp, to avoid implicit commit */
191
MYSQL* util_mysql;
180
DRIZZLE *util_drizzle;
192
181
char *name;
193
182
};
194
183
struct st_connection connections[128];
195
184
struct st_connection* cur_con= NULL, *next_con, *connections_end;
196
185
197
186
/*
198
List of commands in mysqltest
187
List of commands in drizzletest
199
188
Must match the "command_names" array
200
189
Add new commands before Q_UNKNOWN!
201
190
*/
202
191
enum enum_commands {
203
192
Q_CONNECTION=1, Q_QUERY,
204
Q_CONNECT, Q_SLEEP, Q_REAL_SLEEP,
205
Q_INC, Q_DEC,
206
Q_SOURCE, Q_DISCONNECT,
207
Q_LET, Q_ECHO,
208
Q_WHILE, Q_END_BLOCK,
209
Q_SYSTEM, Q_RESULT,
210
Q_REQUIRE, Q_SAVE_MASTER_POS,
193
Q_CONNECT, Q_SLEEP, Q_REAL_SLEEP,
194
Q_INC, Q_DEC,
195
Q_SOURCE, Q_DISCONNECT,
196
Q_LET, Q_ECHO,
197
Q_WHILE, Q_END_BLOCK,
198
Q_SYSTEM, Q_RESULT,
199
Q_REQUIRE, Q_SAVE_MASTER_POS,
211
200
Q_SYNC_WITH_MASTER,
212
201
Q_SYNC_SLAVE_WITH_MASTER,
213
202
Q_ERROR,
214
Q_SEND, Q_REAP,
215
Q_DIRTY_CLOSE, Q_REPLACE, Q_REPLACE_COLUMN,
216
Q_PING, Q_EVAL,
203
Q_SEND, Q_REAP,
204
Q_DIRTY_CLOSE, Q_REPLACE, Q_REPLACE_COLUMN,
205
Q_PING, Q_EVAL,
217
206
Q_EVAL_RESULT,
218
207
Q_ENABLE_QUERY_LOG, Q_DISABLE_QUERY_LOG,
219
208
Q_ENABLE_RESULT_LOG, Q_DISABLE_RESULT_LOG,
235
224
Q_CHMOD_FILE, Q_APPEND_FILE, Q_CAT_FILE, Q_DIFF_FILES,
236
225
Q_SEND_QUIT, Q_CHANGE_USER, Q_MKDIR, Q_RMDIR,
237
226
238
Q_UNKNOWN, /* Unknown command. */
239
Q_COMMENT, /* Comments, ignored. */
227
Q_UNKNOWN, /* Unknown command. */
228
Q_COMMENT, /* Comments, ignored. */
240
229
Q_COMMENT_WITH_COMMAND
241
230
};
242
231
308
297
"copy_file",
309
298
"perl",
310
299
"die",
311
300
312
301
/* Don't execute any more commands, compare result */
313
302
"exit",
314
303
"skip",
367
356
};
368
357
369
358
TYPELIB command_typelib= {array_elements(command_names),"",
370
command_names, 0};
359
command_names, 0};
371
360
372
361
DYNAMIC_STRING ds_res, ds_progress, ds_warning_messages;
373
362
374
363
char builtin_echo[FN_REFLEN];
375
364
376
365
void die(const char *fmt, ...)
377
ATTRIBUTE_FORMAT(printf, 1, 2);
366
__attribute__((format(printf, 1, 2)));
378
367
void abort_not_supported_test(const char *fmt, ...)
379
ATTRIBUTE_FORMAT(printf, 1, 2);
368
__attribute__((format(printf, 1, 2)));
380
369
void verbose_msg(const char *fmt, ...)
381
ATTRIBUTE_FORMAT(printf, 1, 2);
370
__attribute__((format(printf, 1, 2)));
382
371
void warning_msg(const char *fmt, ...)
383
ATTRIBUTE_FORMAT(printf, 1, 2);
372
__attribute__((format(printf, 1, 2)));
384
373
void log_msg(const char *fmt, ...)
385
ATTRIBUTE_FORMAT(printf, 1, 2);
374
__attribute__((format(printf, 1, 2)));
386
375
387
376
VAR* var_from_env(const char *, const char *);
388
377
VAR* var_init(VAR* v, const char *name, int name_len, const char *val,
446
435
send_one_query executes query in separate thread, which is
447
436
necessary in embedded library to run 'send' in proper way.
448
437
This implementation doesn't handle errors returned
449
by mysql_send_query. It's technically possible, though
438
by drizzle_send_query. It's technically possible, though
450
439
I don't see where it is needed.
451
440
*/
452
441
pthread_handler_t send_one_query(void *arg)
453
442
{
454
443
struct st_connection *cn= (struct st_connection*)arg;
455
444
456
mysql_thread_init();
457
VOID(mysql_send_query(&cn->mysql, cn->cur_query, cn->cur_query_len));
445
drizzle_thread_init();
446
VOID(drizzle_send_query(&cn->drizzle, cn->cur_query, cn->cur_query_len));
458
447
459
mysql_thread_end();
448
drizzle_thread_end();
460
449
pthread_mutex_lock(&cn->mutex);
461
450
cn->query_done= 1;
462
451
VOID(pthread_cond_signal(&cn->cond));
471
460
pthread_t tid;
472
461
473
462
if (flags & QUERY_REAP_FLAG)
474
return mysql_send_query(&cn->mysql, q, q_len);
463
return drizzle_send_query(&cn->drizzle, q, q_len);
475
464
476
465
if (pthread_mutex_init(&cn->mutex, NULL) ||
477
466
pthread_cond_init(&cn->cond, NULL))
499
488
500
489
#else /*EMBEDDED_LIBRARY*/
501
490
502
#define do_send_query(cn,q,q_len,flags) mysql_send_query(&cn->mysql, q, q_len)
491
#define do_send_query(cn,q,q_len,flags) drizzle_send_query(&cn->drizzle, q, q_len)
503
492
504
493
#endif /*EMBEDDED_LIBRARY*/
505
494
518
507
case '$':
519
508
if (escaped)
520
509
{
521
escaped= 0;
522
dynstr_append_mem(query_eval, p, 1);
510
escaped= 0;
511
dynstr_append_mem(query_eval, p, 1);
523
512
}
524
513
else
525
514
{
526
if (!(v= var_get(p, &p, 0, 0)))
527
die("Bad variable in eval");
528
dynstr_append_mem(query_eval, v->str_val, v->str_val_len);
515
if (!(v= var_get(p, &p, 0, 0)))
516
die("Bad variable in eval");
517
dynstr_append_mem(query_eval, v->str_val, v->str_val_len);
529
518
}
530
519
break;
531
520
case '\\':
532
521
next_c= *(p+1);
533
522
if (escaped)
534
523
{
535
escaped= 0;
536
dynstr_append_mem(query_eval, p, 1);
524
escaped= 0;
525
dynstr_append_mem(query_eval, p, 1);
537
526
}
538
527
else if (next_c == '\\' || next_c == '$' || next_c == '"')
539
528
{
540
529
/* Set escaped only if next char is \, " or $ */
541
escaped= 1;
530
escaped= 1;
542
531
543
532
if (pass_through_escape_chars)
544
533
{
547
536
}
548
537
}
549
538
else
550
dynstr_append_mem(query_eval, p, 1);
539
dynstr_append_mem(query_eval, p, 1);
551
540
break;
552
541
default:
553
542
escaped= 0;
567
556
568
557
SYNOPSIS
569
558
show_query
570
mysql - connection to use
559
drizzle - connection to use
571
560
query - query to run
572
561
573
562
*/
574
563
575
static void show_query(MYSQL* mysql, const char* query)
564
static void show_query(DRIZZLE *drizzle, const char* query)
576
565
{
577
MYSQL_RES* res;
578
579
580
if (!mysql)
566
DRIZZLE_RES* res;
567
568
569
if (!drizzle)
581
570
return;
582
571
583
if (mysql_query(mysql, query))
572
if (drizzle_query(drizzle, query))
584
573
{
585
574
log_msg("Error running query '%s': %d %s",
586
query, mysql_errno(mysql), mysql_error(mysql));
575
query, drizzle_errno(drizzle), drizzle_error(drizzle));
587
576
return;
588
577
}
589
578
590
if ((res= mysql_store_result(mysql)) == NULL)
579
if ((res= drizzle_store_result(drizzle)) == NULL)
591
580
{
592
581
/* No result set returned */
593
582
return;
594
583
}
595
584
596
585
{
597
MYSQL_ROW row;
586
DRIZZLE_ROW row;
598
587
unsigned int i;
599
588
unsigned int row_num= 0;
600
unsigned int num_fields= mysql_num_fields(res);
601
MYSQL_FIELD *fields= mysql_fetch_fields(res);
589
unsigned int num_fields= drizzle_num_fields(res);
590
DRIZZLE_FIELD *fields= drizzle_fetch_fields(res);
602
591
603
592
fprintf(stderr, "=== %s ===\n", query);
604
while ((row= mysql_fetch_row(res)))
593
while ((row= drizzle_fetch_row(res)))
605
594
{
606
uint32_t *lengths= mysql_fetch_lengths(res);
595
uint32_t *lengths= drizzle_fetch_lengths(res);
607
596
row_num++;
608
597
609
598
fprintf(stderr, "---- %d. ----\n", row_num);
618
607
fprintf(stderr, "=");
619
608
fprintf(stderr, "\n\n");
620
609
}
621
mysql_free_result(res);
610
drizzle_free_result(res);
622
611
623
612
return;
624
613
}
633
622
634
623
SYNOPSIS
635
624
show_warnings_before_error
636
mysql - connection to use
625
drizzle - connection to use
637
626
638
627
*/
639
628
640
static void show_warnings_before_error(MYSQL* mysql)
629
static void show_warnings_before_error(DRIZZLE *drizzle)
641
630
{
642
MYSQL_RES* res;
631
DRIZZLE_RES* res;
643
632
const char* query= "SHOW WARNINGS";
644
633
645
634
646
if (!mysql)
635
if (!drizzle)
647
636
return;
648
637
649
if (mysql_query(mysql, query))
638
if (drizzle_query(drizzle, query))
650
639
{
651
640
log_msg("Error running query '%s': %d %s",
652
query, mysql_errno(mysql), mysql_error(mysql));
641
query, drizzle_errno(drizzle), drizzle_error(drizzle));
653
642
return;
654
643
}
655
644
656
if ((res= mysql_store_result(mysql)) == NULL)
645
if ((res= drizzle_store_result(drizzle)) == NULL)
657
646
{
658
647
/* No result set returned */
659
648
return;
660
649
}
661
650
662
if (mysql_num_rows(res) <= 1)
651
if (drizzle_num_rows(res) <= 1)
663
652
{
664
653
/* Don't display the last row, it's "last error" */
665
654
}
666
655
else
667
656
{
668
MYSQL_ROW row;
657
DRIZZLE_ROW row;
669
658
unsigned int row_num= 0;
670
unsigned int num_fields= mysql_num_fields(res);
659
unsigned int num_fields= drizzle_num_fields(res);
671
660
672
661
fprintf(stderr, "\nWarnings from just before the error:\n");
673
while ((row= mysql_fetch_row(res)))
662
while ((row= drizzle_fetch_row(res)))
674
663
{
675
664
uint32_t i;
676
uint32_t *lengths= mysql_fetch_lengths(res);
665
uint32_t *lengths= drizzle_fetch_lengths(res);
677
666
678
if (++row_num >= mysql_num_rows(res))
667
if (++row_num >= drizzle_num_rows(res))
679
668
{
680
669
/* Don't display the last row, it's "last error" */
681
670
break;
689
678
fprintf(stderr, "\n");
690
679
}
691
680
}
692
mysql_free_result(res);
681
drizzle_free_result(res);
693
682
694
683
return;
695
684
}
820
809
821
810
for (--next_con; next_con >= connections; --next_con)
822
811
{
823
mysql_close(&next_con->mysql);
824
if (next_con->util_mysql)
825
mysql_close(next_con->util_mysql);
812
drizzle_close(&next_con->drizzle);
813
if (next_con->util_drizzle)
814
drizzle_close(next_con->util_drizzle);
826
815
my_free(next_con->name, MYF(MY_ALLOW_ZERO_PTR));
827
816
}
828
817
return;
875
864
my_free(opt_pass,MYF(MY_ALLOW_ZERO_PTR));
876
865
free_defaults(default_argv);
877
866
878
/* Only call mysql_server_end if mysql_server_init has been called */
867
/* Only call drizzle_server_end if drizzle_server_init has been called */
879
868
if (server_initialized)
880
mysql_server_end();
869
drizzle_server_end();
881
870
882
871
return;
883
872
}
923
912
dying= 1;
924
913
925
914
/* Print the error message */
926
fprintf(stderr, "mysqltest: ");
915
fprintf(stderr, "drizzletest: ");
927
916
if (cur_file && cur_file != file_stack)
928
917
fprintf(stderr, "In included file \"%s\": ",
929
918
cur_file->file_name);
971
960
been produced prior to the error
972
961
*/
973
962
if (cur_con)
974
show_warnings_before_error(&cur_con->mysql);
963
show_warnings_before_error(&cur_con->drizzle);
975
964
976
965
cleanup_and_exit(1);
977
966
}
1018
1007
return;
1019
1008
1020
1009
va_start(args, fmt);
1021
fprintf(stderr, "mysqltest: ");
1010
fprintf(stderr, "drizzletest: ");
1022
1011
if (cur_file && cur_file != file_stack)
1023
1012
fprintf(stderr, "In included file \"%s\": ",
1024
1013
cur_file->file_name);
1040
1029
1041
1030
1042
1031
va_start(args, fmt);
1043
dynstr_append(&ds_warning_messages, "mysqltest: ");
1032
dynstr_append(&ds_warning_messages, "drizzletest: ");
1044
1033
if (start_lineno != 0)
1045
1034
{
1046
1035
dynstr_append(&ds_warning_messages, "Warning detected ");
1292
1281
/* Print diff directly to stdout */
1293
1282
fprintf(stderr, "%s\n", ds_tmp.str);
1294
1283
}
1295
1284
1296
1285
dynstr_free(&ds_tmp);
1297
1286
1298
1287
}
1647
1636
1648
1637
1649
1638
VAR* var_get(const char *var_name, const char **var_name_end, bool raw,
1650
bool ignore_not_existing)
1639
bool ignore_not_existing)
1651
1640
{
1652
1641
int digit;
1653
1642
VAR *v;
1665
1654
if (var_name == save_var_name)
1666
1655
{
1667
1656
if (ignore_not_existing)
1668
return(0);
1657
return(0);
1669
1658
die("Empty variable");
1670
1659
}
1671
1660
length= (uint) (var_name - save_var_name);
1679
1668
strmake(buff, save_var_name, length);
1680
1669
v= var_from_env(buff, "");
1681
1670
}
1682
var_name--; /* Point at last character */
1671
var_name--; /* Point at last character */
1683
1672
}
1684
1673
else
1685
1674
v = var_reg + digit;
1776
1765
1777
1766
/*
1778
1767
Store an integer (typically the returncode of the last SQL)
1779
statement in the mysqltest builtin variable $mysql_errno
1768
statement in the drizzletest builtin variable $drizzle_errno
1780
1769
*/
1781
1770
1782
1771
static void var_set_errno(int sql_errno)
1783
1772
{
1784
var_set_int("$mysql_errno", sql_errno);
1773
var_set_int("$drizzle_errno", sql_errno);
1785
1774
}
1786
1775
1787
1776
1788
1777
/*
1789
Update $mysql_get_server_version variable with version
1778
Update $drizzle_get_server_version variable with version
1790
1779
of the currently connected server
1791
1780
*/
1792
1781
1793
static void var_set_mysql_get_server_version(MYSQL* mysql)
1782
static void var_set_drizzle_get_server_version(DRIZZLE *drizzle)
1794
1783
{
1795
var_set_int("$mysql_get_server_version", mysql_get_server_version(mysql));
1784
var_set_int("$drizzle_get_server_version", drizzle_get_server_version(drizzle));
1796
1785
}
1797
1786
1798
1787
1801
1790
1802
1791
SYNOPSIS
1803
1792
var_query_set()
1804
var variable to set from query
1793
var variable to set from query
1805
1794
query start of query string to execute
1806
1795
query_end end of the query string to execute
1807
1796
1822
1811
static void var_query_set(VAR *var, const char *query, const char** query_end)
1823
1812
{
1824
1813
char *end = (char*)((query_end && *query_end) ?
1825
*query_end : query + strlen(query));
1826
MYSQL_RES *res;
1827
MYSQL_ROW row;
1828
MYSQL* mysql = &cur_con->mysql;
1814
*query_end : query + strlen(query));
1815
DRIZZLE_RES *res;
1816
DRIZZLE_ROW row;
1817
DRIZZLE *drizzle= &cur_con->drizzle;
1829
1818
DYNAMIC_STRING ds_query;
1830
1819
1831
1820
1839
1828
init_dynamic_string(&ds_query, 0, (end - query) + 32, 256);
1840
1829
do_eval(&ds_query, query, end, false);
1841
1830
1842
if (mysql_real_query(mysql, ds_query.str, ds_query.length))
1831
if (drizzle_real_query(drizzle, ds_query.str, ds_query.length))
1843
1832
die("Error running query '%s': %d %s", ds_query.str,
1844
mysql_errno(mysql), mysql_error(mysql));
1845
if (!(res= mysql_store_result(mysql)))
1833
drizzle_errno(drizzle), drizzle_error(drizzle));
1834
if (!(res= drizzle_store_result(drizzle)))
1846
1835
die("Query '%s' didn't return a result set", ds_query.str);
1847
1836
dynstr_free(&ds_query);
1848
1837
1849
if ((row= mysql_fetch_row(res)) && row[0])
1838
if ((row= drizzle_fetch_row(res)) && row[0])
1850
1839
{
1851
1840
/*
1852
1841
Concatenate all fields in the first row with tab in between
1857
1846
uint32_t *lengths;
1858
1847
1859
1848
init_dynamic_string(&result, "", 512, 512);
1860
lengths= mysql_fetch_lengths(res);
1861
for (i= 0; i < mysql_num_fields(res); i++)
1849
lengths= drizzle_fetch_lengths(res);
1850
for (i= 0; i < drizzle_num_fields(res); i++)
1862
1851
{
1863
1852
if (row[i])
1864
1853
{
1865
1854
/* Add column to tab separated string */
1866
dynstr_append_mem(&result, row[i], lengths[i]);
1855
dynstr_append_mem(&result, row[i], lengths[i]);
1867
1856
}
1868
1857
dynstr_append_mem(&result, "\t", 1);
1869
1858
}
1874
1863
else
1875
1864
eval_expr(var, "", 0);
1876
1865
1877
mysql_free_result(res);
1866
drizzle_free_result(res);
1878
1867
return;
1879
1868
}
1880
1869
1905
1894
{
1906
1895
long row_no;
1907
1896
int col_no= -1;
1908
MYSQL_RES* res;
1909
MYSQL* mysql= &cur_con->mysql;
1897
DRIZZLE_RES* res;
1898
DRIZZLE *drizzle= &cur_con->drizzle;
1910
1899
1911
1900
static DYNAMIC_STRING ds_query;
1912
1901
static DYNAMIC_STRING ds_col;
1934
1923
die("Mismatched \"'s around query '%s'", ds_query.str);
1935
1924
1936
1925
/* Run the query */
1937
if (mysql_real_query(mysql, ds_query.str, ds_query.length))
1926
if (drizzle_real_query(drizzle, ds_query.str, ds_query.length))
1938
1927
die("Error running query '%s': %d %s", ds_query.str,
1939
mysql_errno(mysql), mysql_error(mysql));
1940
if (!(res= mysql_store_result(mysql)))
1928
drizzle_errno(drizzle), drizzle_error(drizzle));
1929
if (!(res= drizzle_store_result(drizzle)))
1941
1930
die("Query '%s' didn't return a result set", ds_query.str);
1942
1931
1943
1932
{
1944
1933
/* Find column number from the given column name */
1945
1934
uint i;
1946
uint num_fields= mysql_num_fields(res);
1947
MYSQL_FIELD *fields= mysql_fetch_fields(res);
1935
uint num_fields= drizzle_num_fields(res);
1936
DRIZZLE_FIELD *fields= drizzle_fetch_fields(res);
1948
1937
1949
1938
for (i= 0; i < num_fields; i++)
1950
1939
{
1957
1946
}
1958
1947
if (col_no == -1)
1959
1948
{
1960
mysql_free_result(res);
1949
drizzle_free_result(res);
1961
1950
die("Could not find column '%s' in the result of '%s'",
1962
1951
ds_col.str, ds_query.str);
1963
1952
}
1966
1955
1967
1956
{
1968
1957
/* Get the value */
1969
MYSQL_ROW row;
1958
DRIZZLE_ROW row;
1970
1959
long rows= 0;
1971
1960
const char* value= "No such row";
1972
1961
1973
while ((row= mysql_fetch_row(res)))
1962
while ((row= drizzle_fetch_row(res)))
1974
1963
{
1975
1964
if (++rows == row_no)
1976
1965
{
1987
1976
eval_expr(var, value, 0);
1988
1977
}
1989
1978
dynstr_free(&ds_query);
1990
mysql_free_result(res);
1979
drizzle_free_result(res);
1991
1980
1992
1981
return;
1993
1982
}
2101
2090
2102
2091
SYNOPSIS
2103
2092
do_source()
2104
query called command
2093
query called command
2105
2094
2106
2095
DESCRIPTION
2107
2096
source <file_name>
2191
2180
2192
2181
SYNOPSIS
2193
2182
do_exec()
2194
query called command
2183
query called command
2195
2184
2196
2185
DESCRIPTION
2197
2186
exec <command>
2202
2191
It can thus be used to execute a command that shall fail.
2203
2192
2204
2193
NOTE
2205
Although mysqltest is executed from cygwin shell, the command will be
2194
Although drizzletest is executed from cygwin shell, the command will be
2206
2195
executed in "cmd.exe". Thus commands like "rm" etc can NOT be used, use
2207
mysqltest commmand(s) like "remove_file" for that
2196
drizzletest commmand(s) like "remove_file" for that
2208
2197
*/
2209
2198
2210
2199
static void do_exec(struct st_command *command)
2306
2295
2307
2296
SYNOPSIS
2308
2297
do_modify_var()
2309
query called command
2298
query called command
2310
2299
operator operation to perform on the var
2311
2300
2312
2301
DESCRIPTION
2347
2336
Wrapper for 'system' function
2348
2337
2349
2338
NOTE
2350
If mysqltest is executed from cygwin shell, the command will be
2339
If drizzletest is executed from cygwin shell, the command will be
2351
2340
executed in the "windows command interpreter" cmd.exe and we prepend "sh"
2352
2341
to make it be executed by cygwins "bash". Thus commands like "rm",
2353
2342
"mkdir" as well as shellscripts can executed by "system" in Windows.
2363
2352
/*
2364
2353
SYNOPSIS
2365
2354
do_system
2366
command called command
2355
command called command
2367
2356
2368
2357
DESCRIPTION
2369
2358
system <command>
2406
2395
/*
2407
2396
SYNOPSIS
2408
2397
do_remove_file
2409
command called command
2398
command called command
2410
2399
2411
2400
DESCRIPTION
2412
2401
remove_file <file_name>
2436
2425
/*
2437
2426
SYNOPSIS
2438
2427
do_copy_file
2439
command command handle
2428
command command handle
2440
2429
2441
2430
DESCRIPTION
2442
2431
copy_file <from_file> <to_file>
2473
2462
/*
2474
2463
SYNOPSIS
2475
2464
do_chmod_file
2476
command command handle
2465
command command handle
2477
2466
2478
2467
DESCRIPTION
2479
2468
chmod <octal> <file_name>
2487
2476
static DYNAMIC_STRING ds_mode;
2488
2477
static DYNAMIC_STRING ds_file;
2489
2478
const struct command_arg chmod_file_args[] = {
2490
{ "mode", ARG_STRING, true, &ds_mode, "Mode of file(octal) ex. 0660"},
2479
{ "mode", ARG_STRING, true, &ds_mode, "Mode of file(octal) ex. 0660"},
2491
2480
{ "filename", ARG_STRING, true, &ds_file, "Filename of file to modify" }
2492
2481
};
2493
2482
2512
2501
/*
2513
2502
SYNOPSIS
2514
2503
do_file_exists
2515
command called command
2504
command called command
2516
2505
2517
2506
DESCRIPTION
2518
2507
fiile_exist <file_name>
2543
2532
/*
2544
2533
SYNOPSIS
2545
2534
do_mkdir
2546
command called command
2535
command called command
2547
2536
2548
2537
DESCRIPTION
2549
2538
mkdir <dir_name>
2572
2561
/*
2573
2562
SYNOPSIS
2574
2563
do_rmdir
2575
command called command
2564
command called command
2576
2565
2577
2566
DESCRIPTION
2578
2567
rmdir <dir_name>
2706
2695
/*
2707
2696
SYNOPSIS
2708
2697
do_write_file
2709
command called command
2698
command called command
2710
2699
2711
2700
DESCRIPTION
2712
2701
write_file <file_name> [<delimiter>];
2739
2728
/*
2740
2729
SYNOPSIS
2741
2730
do_append_file
2742
command called command
2731
command called command
2743
2732
2744
2733
DESCRIPTION
2745
2734
append_file <file_name> [<delimiter>];
2770
2759
/*
2771
2760
SYNOPSIS
2772
2761
do_cat_file
2773
command called command
2762
command called command
2774
2763
2775
2764
DESCRIPTION
2776
2765
cat_file <file_name>;
2803
2792
/*
2804
2793
SYNOPSIS
2805
2794
do_diff_files
2806
command called command
2795
command called command
2807
2796
2808
2797
DESCRIPTION
2809
2798
diff_files <file1> <file2>;
2861
2850
/*
2862
2851
SYNOPSIS
2863
2852
do_send_quit
2864
command called command
2853
command called command
2865
2854
2866
2855
DESCRIPTION
2867
2856
Sends a simple quit command to the server for the named connection.
2886
2875
if (!(con= find_connection_by_name(name)))
2887
2876
die("connection '%s' not found in connection pool", name);
2888
2877
2889
simple_command(&con->mysql,COM_QUIT,0,0,1);
2878
simple_command(&con->drizzle,COM_QUIT,0,0,1);
2890
2879
2891
2880
return;
2892
2881
}
2910
2899
2911
2900
static void do_change_user(struct st_command *command)
2912
2901
{
2913
MYSQL *mysql = &cur_con->mysql;
2902
DRIZZLE *drizzle= &cur_con->drizzle;
2914
2903
/* static keyword to make the NetWare compiler happy. */
2915
2904
static DYNAMIC_STRING ds_user, ds_passwd, ds_db;
2916
2905
const struct command_arg change_user_args[] = {
2927
2916
',');
2928
2917
2929
2918
if (!ds_user.length)
2930
dynstr_set(&ds_user, mysql->user);
2919
dynstr_set(&ds_user, drizzle->user);
2931
2920
2932
2921
if (!ds_passwd.length)
2933
dynstr_set(&ds_passwd, mysql->passwd);
2922
dynstr_set(&ds_passwd, drizzle->passwd);
2934
2923
2935
2924
if (!ds_db.length)
2936
dynstr_set(&ds_db, mysql->db);
2925
dynstr_set(&ds_db, drizzle->db);
2937
2926
2938
if (mysql_change_user(mysql, ds_user.str, ds_passwd.str, ds_db.str))
2939
die("change user failed: %s", mysql_error(mysql));
2927
if (drizzle_change_user(drizzle, ds_user.str, ds_passwd.str, ds_db.str))
2928
die("change user failed: %s", drizzle_error(drizzle));
2940
2929
2941
2930
dynstr_free(&ds_user);
2942
2931
dynstr_free(&ds_passwd);
2949
2938
/*
2950
2939
SYNOPSIS
2951
2940
do_perl
2952
command command handle
2941
command command handle
2953
2942
2954
2943
DESCRIPTION
2955
2944
perl [<delimiter>];
3069
3058
do_wait_for_slave_to_stop(struct st_command *c __attribute__((unused)))
3070
3059
{
3071
3060
static int SLAVE_POLL_INTERVAL= 300000;
3072
MYSQL* mysql = &cur_con->mysql;
3061
DRIZZLE *drizzle= &cur_con->drizzle;
3073
3062
for (;;)
3074
3063
{
3075
MYSQL_RES *res= NULL;
3076
MYSQL_ROW row;
3064
DRIZZLE_RES *res= NULL;
3065
DRIZZLE_ROW row;
3077
3066
int done;
3078
3067
3079
if (mysql_query(mysql,"show status like 'Slave_running'") ||
3080
!(res=mysql_store_result(mysql)))
3068
if (drizzle_query(drizzle,"show status like 'Slave_running'") ||
3069
!(res=drizzle_store_result(drizzle)))
3081
3070
die("Query failed while probing slave for stop: %s",
3082
mysql_error(mysql));
3083
if (!(row=mysql_fetch_row(res)) || !row[1])
3071
drizzle_error(drizzle));
3072
if (!(row=drizzle_fetch_row(res)) || !row[1])
3084
3073
{
3085
mysql_free_result(res);
3074
drizzle_free_result(res);
3086
3075
die("Strange result from query while probing slave for stop");
3087
3076
}
3088
3077
done = !strcmp(row[1],"OFF");
3089
mysql_free_result(res);
3078
drizzle_free_result(res);
3090
3079
if (done)
3091
3080
break;
3092
3081
my_sleep(SLAVE_POLL_INTERVAL);
3097
3086
3098
3087
static void do_sync_with_master2(long offset)
3099
3088
{
3100
MYSQL_RES *res;
3101
MYSQL_ROW row;
3102
MYSQL *mysql= &cur_con->mysql;
3089
DRIZZLE_RES *res;
3090
DRIZZLE_ROW row;
3091
DRIZZLE *drizzle= &cur_con->drizzle;
3103
3092
char query_buf[FN_REFLEN+128];
3104
3093
int tries= 0;
3105
3094
3107
3096
die("Calling 'sync_with_master' without calling 'save_master_pos'");
3108
3097
3109
3098
sprintf(query_buf, "select master_pos_wait('%s', %ld)", master_pos.file,
3110
master_pos.pos + offset);
3099
master_pos.pos + offset);
3111
3100
3112
3101
wait_for_position:
3113
3102
3114
if (mysql_query(mysql, query_buf))
3115
die("failed in '%s': %d: %s", query_buf, mysql_errno(mysql),
3116
mysql_error(mysql));
3103
if (drizzle_query(drizzle, query_buf))
3104
die("failed in '%s': %d: %s", query_buf, drizzle_errno(drizzle),
3105
drizzle_error(drizzle));
3117
3106
3118
if (!(res= mysql_store_result(mysql)))
3119
die("mysql_store_result() returned NULL for '%s'", query_buf);
3120
if (!(row= mysql_fetch_row(res)))
3107
if (!(res= drizzle_store_result(drizzle)))
3108
die("drizzle_store_result() returned NULL for '%s'", query_buf);
3109
if (!(row= drizzle_fetch_row(res)))
3121
3110
{
3122
mysql_free_result(res);
3111
drizzle_free_result(res);
3123
3112
die("empty result in %s", query_buf);
3124
3113
}
3125
3114
if (!row[0])
3128
3117
It may be that the slave SQL thread has not started yet, though START
3129
3118
SLAVE has been issued ?
3130
3119
*/
3131
mysql_free_result(res);
3120
drizzle_free_result(res);
3132
3121
if (tries++ == 30)
3133
3122
{
3134
show_query(mysql, "SHOW MASTER STATUS");
3135
show_query(mysql, "SHOW SLAVE STATUS");
3123
show_query(drizzle, "SHOW MASTER STATUS");
3124
show_query(drizzle, "SHOW SLAVE STATUS");
3136
3125
die("could not sync with master ('%s' returned NULL)", query_buf);
3137
3126
}
3138
3127
sleep(1); /* So at most we will wait 30 seconds and make 31 tries */
3139
3128
goto wait_for_position;
3140
3129
}
3141
mysql_free_result(res);
3130
drizzle_free_result(res);
3142
3131
return;
3143
3132
}
3144
3133
3164
3153
3165
3154
/*
3166
3155
when ndb binlog is on, this call will wait until last updated epoch
3167
(locally in the mysqld) has been received into the binlog
3156
(locally in the drizzled) has been received into the binlog
3168
3157
*/
3169
3158
static int do_save_master_pos(void)
3170
3159
{
3171
MYSQL_RES *res;
3172
MYSQL_ROW row;
3173
MYSQL *mysql = &cur_con->mysql;
3160
DRIZZLE_RES *res;
3161
DRIZZLE_ROW row;
3162
DRIZZLE *drizzle= &cur_con->drizzle;
3174
3163
const char *query;
3175
3164
3176
3165
3177
if (mysql_query(mysql, query= "show master status"))
3166
if (drizzle_query(drizzle, query= "show master status"))
3178
3167
die("failed in 'show master status': %d %s",
3179
mysql_errno(mysql), mysql_error(mysql));
3168
drizzle_errno(drizzle), drizzle_error(drizzle));
3180
3169
3181
if (!(res = mysql_store_result(mysql)))
3182
die("mysql_store_result() retuned NULL for '%s'", query);
3183
if (!(row = mysql_fetch_row(res)))
3170
if (!(res = drizzle_store_result(drizzle)))
3171
die("drizzle_store_result() retuned NULL for '%s'", query);
3172
if (!(row = drizzle_fetch_row(res)))
3184
3173
die("empty result in show master status");
3185
3174
strnmov(master_pos.file, row[0], sizeof(master_pos.file)-1);
3186
3175
master_pos.pos = strtoul(row[1], (char**) 0, 10);
3187
mysql_free_result(res);
3176
drizzle_free_result(res);
3188
3177
return(0);
3189
3178
}
3190
3179
3194
3183
3195
3184
SYNOPSIS
3196
3185
do_let()
3197
query called command
3186
query called command
3198
3187
3199
3188
DESCRIPTION
3200
3189
let $<var_name>=<var_val><delimiter>
3252
3241
3253
3242
SYNOPSIS
3254
3243
do_sleep()
3255
q called command
3244
q called command
3256
3245
real_sleep use the value from opt_sleep as number of seconds to sleep
3257
3246
if real_sleep is false
3258
3247
3336
3325
abort_not_supported_test("Test requires charset '%s'", charset_name);
3337
3326
}
3338
3327
3339
3340
/* List of error names to error codes, available from 5.0 */
3341
typedef struct
3342
{
3343
const char *name;
3344
uint code;
3345
} st_error;
3346
3347
static st_error global_error_names[] =
3348
{
3349
#include <mysqld_ername.h>
3350
{ 0, 0 }
3351
};
3352
3353
3328
static uint get_errcode_from_name(char *error_name, char *error_end)
3354
3329
{
3355
3330
/* SQL error as string */
3455
3430
3456
3431
/* Convert the sting to int */
3457
3432
if (!str2int(start, 10, (long) INT_MIN, (long) INT_MAX, &val))
3458
die("Invalid argument to error: '%s'", command->first_argument);
3433
die("Invalid argument to error: '%s'", command->first_argument);
3459
3434
3460
3435
to->code.errnum= (uint) val;
3461
3436
to->type= ERR_ERRNO;
3505
3480
if (*from == '"' || *from == '\'')
3506
3481
sep= *from++;
3507
3482
else
3508
sep=' '; /* Separated with space */
3483
sep=' '; /* Separated with space */
3509
3484
3510
3485
for ( ; (c=*from) ; from++)
3511
3486
{
3512
3487
if (c == '\\' && from[1])
3513
{ /* Escaped character */
3488
{ /* Escaped character */
3514
3489
/* We can't translate \0 -> ASCII 0 as replace can't handle ASCII 0 */
3515
3490
switch (*++from) {
3516
3491
case 'n':
3517
*to++= '\n';
3518
break;
3492
*to++= '\n';
3493
break;
3519
3494
case 't':
3520
*to++= '\t';
3521
break;
3495
*to++= '\t';
3496
break;
3522
3497
case 'r':
3523
*to++ = '\r';
3524
break;
3498
*to++ = '\r';
3499
break;
3525
3500
case 'b':
3526
*to++ = '\b';
3527
break;
3528
case 'Z': /* ^Z must be escaped on Win32 */
3529
*to++='\032';
3530
break;
3501
*to++ = '\b';
3502
break;
3503
case 'Z': /* ^Z must be escaped on Win32 */
3504
*to++='\032';
3505
break;
3531
3506
default:
3532
*to++ = *from;
3533
break;
3507
*to++ = *from;
3508
break;
3534
3509
}
3535
3510
}
3536
3511
else if (c == sep)
3537
3512
{
3538
3513
if (c == ' ' || c != *++from)
3539
break; /* Found end of string */
3540
*to++=c; /* Copy duplicated separator */
3514
break; /* Found end of string */
3515
*to++=c; /* Copy duplicated separator */
3541
3516
}
3542
3517
else
3543
3518
*to++=c;
3545
3520
if (*from != ' ' && *from)
3546
3521
die("Wrong string argument in %s", command->query);
3547
3522
3548
while (my_isspace(charset_info,*from)) /* Point to next string */
3523
while (my_isspace(charset_info,*from)) /* Point to next string */
3549
3524
from++;
3550
3525
3551
*to =0; /* End of string marker */
3552
*to_ptr= to+1; /* Store pointer to end */
3526
*to =0; /* End of string marker */
3527
*to_ptr= to+1; /* Store pointer to end */
3553
3528
*from_ptr= from;
3554
3529
3555
3530
/* Check if this was a variable */
3558
3533
const char *end= to;
3559
3534
VAR *var=var_get(start, &end, 0, 1);
3560
3535
if (var && to == (char*) end+1)
3561
return(var->str_val); /* return found variable value */
3536
return(var->str_val); /* return found variable value */
3562
3537
}
3563
3538
return(start);
3564
3539
}
3565
3540
3566
3541
3567
static void set_reconnect(MYSQL* mysql, int val)
3542
static void set_reconnect(DRIZZLE *drizzle, int val)
3568
3543
{
3569
3544
bool reconnect= val;
3570
3545
3571
mysql_options(mysql, MYSQL_OPT_RECONNECT, (char *)&reconnect);
3546
drizzle_options(drizzle, DRIZZLE_OPT_RECONNECT, (char *)&reconnect);
3572
3547
3573
3548
return;
3574
3549
}
3579
3554
if (!(cur_con= find_connection_by_name(name)))
3580
3555
die("connection '%s' not found in connection pool", name);
3581
3556
3582
/* Update $mysql_get_server_version to that of current connection */
3583
var_set_mysql_get_server_version(&cur_con->mysql);
3557
/* Update $drizzle_get_server_version to that of current connection */
3558
var_set_drizzle_get_server_version(&cur_con->drizzle);
3584
3559
3585
3560
return(0);
3586
3561
}
3624
3599
3625
3600
if (command->type == Q_DIRTY_CLOSE)
3626
3601
{
3627
if (con->mysql.net.vio)
3602
if (con->drizzle.net.vio)
3628
3603
{
3629
vio_delete(con->mysql.net.vio);
3630
con->mysql.net.vio = 0;
3604
vio_delete(con->drizzle.net.vio);
3605
con->drizzle.net.vio = 0;
3631
3606
}
3632
3607
}
3633
3608
3634
mysql_close(&con->mysql);
3609
drizzle_close(&con->drizzle);
3635
3610
3636
if (con->util_mysql)
3637
mysql_close(con->util_mysql);
3638
con->util_mysql= 0;
3611
if (con->util_drizzle)
3612
drizzle_close(con->util_drizzle);
3613
con->util_drizzle= 0;
3639
3614
3640
3615
my_free(con->name, MYF(0));
3641
3616
3675
3650
3676
3651
*/
3677
3652
3678
static void safe_connect(MYSQL* mysql, const char *name, const char *host,
3653
static void safe_connect(DRIZZLE *drizzle, const char *name, const char *host,
3679
3654
const char *user, const char *pass, const char *db,
3680
3655
int port)
3681
3656
{
3683
3658
static ulong connection_retry_sleep= 100000; /* Microseconds */
3684
3659
3685
3660
3686
while(!mysql_real_connect(mysql, host, user, pass, db, port, NULL,
3661
while(!drizzle_connect(drizzle, host, user, pass, db, port, NULL,
3687
3662
CLIENT_MULTI_STATEMENTS | CLIENT_REMEMBER_OPTIONS))
3688
3663
{
3689
3664
/*
3694
3669
on protocol/connection type
3695
3670
*/
3696
3671
3697
if ((mysql_errno(mysql) == CR_CONN_HOST_ERROR ||
3698
mysql_errno(mysql) == CR_CONNECTION_ERROR) &&
3672
if ((drizzle_errno(drizzle) == CR_CONN_HOST_ERROR ||
3673
drizzle_errno(drizzle) == CR_CONNECTION_ERROR) &&
3699
3674
failed_attempts < opt_max_connect_retries)
3700
3675
{
3701
3676
verbose_msg("Connect attempt %d/%d failed: %d: %s", failed_attempts,
3702
opt_max_connect_retries, mysql_errno(mysql),
3703
mysql_error(mysql));
3677
opt_max_connect_retries, drizzle_errno(drizzle),
3678
drizzle_error(drizzle));
3704
3679
my_sleep(connection_retry_sleep);
3705
3680
}
3706
3681
else
3707
3682
{
3708
3683
if (failed_attempts > 0)
3709
3684
die("Could not open connection '%s' after %d attempts: %d %s", name,
3710
failed_attempts, mysql_errno(mysql), mysql_error(mysql));
3685
failed_attempts, drizzle_errno(drizzle), drizzle_error(drizzle));
3711
3686
else
3712
3687
die("Could not open connection '%s': %d %s", name,
3713
mysql_errno(mysql), mysql_error(mysql));
3688
drizzle_errno(drizzle), drizzle_error(drizzle));
3714
3689
}
3715
3690
failed_attempts++;
3716
3691
}
3742
3717
*/
3743
3718
3744
3719
static int connect_n_handle_errors(struct st_command *command,
3745
MYSQL* con, const char* host,
3720
DRIZZLE *con, const char* host,
3746
3721
const char* user, const char* pass,
3747
3722
const char* db, int port, const char* sock)
3748
3723
{
3775
3750
dynstr_append_mem(ds, delimiter, delimiter_length);
3776
3751
dynstr_append_mem(ds, "\n", 1);
3777
3752
}
3778
if (!mysql_real_connect(con, host, user, pass, db, port, 0,
3753
if (!drizzle_connect(con, host, user, pass, db, port, 0,
3779
3754
CLIENT_MULTI_STATEMENTS))
3780
3755
{
3781
var_set_errno(mysql_errno(con));
3782
handle_error(command, mysql_errno(con), mysql_error(con),
3783
mysql_sqlstate(con), ds);
3756
var_set_errno(drizzle_errno(con));
3757
handle_error(command, drizzle_errno(con), drizzle_error(con),
3758
drizzle_sqlstate(con), ds);
3784
3759
return 0; /* Not connected */
3785
3760
}
3786
3761
3791
3766
3792
3767
3793
3768
/*
3794
Open a new connection to MySQL Server with the parameters
3769
Open a new connection to DRIZZLE Server with the parameters
3795
3770
specified. Make the new connection the current connection.
3796
3771
3797
3772
SYNOPSIS
3798
3773
do_connect()
3799
q called command
3774
q called command
3800
3775
3801
3776
DESCRIPTION
3802
3777
connect(<name>,<host>,<user>,[<pass>,[<db>,[<port>,<sock>[<opts>]]]]);
3892
3867
else if (!strncmp(con_options, "COMPRESS", 8))
3893
3868
con_compress= 1;
3894
3869
else
3895
die("Illegal option to connect: %.*s",
3870
die("Illegal option to connect: %.*s",
3896
3871
(int) (end - con_options), con_options);
3897
3872
/* Process next option */
3898
3873
con_options= end;
3900
3875
3901
3876
if (find_connection_by_name(ds_connection_name.str))
3902
3877
die("Connection %s already exists", ds_connection_name.str);
3903
3878
3904
3879
if (next_con != connections_end)
3905
3880
con_slot= next_con;
3906
3881
else
3913
3888
#ifdef EMBEDDED_LIBRARY
3914
3889
con_slot->query_done= 1;
3915
3890
#endif
3916
if (!mysql_init(&con_slot->mysql))
3917
die("Failed on mysql_init()");
3891
if (!drizzle_create(&con_slot->drizzle))
3892
die("Failed on drizzle_create()");
3918
3893
if (opt_compress || con_compress)
3919
mysql_options(&con_slot->mysql, MYSQL_OPT_COMPRESS, NullS);
3920
mysql_options(&con_slot->mysql, MYSQL_OPT_LOCAL_INFILE, 0);
3921
mysql_options(&con_slot->mysql, MYSQL_SET_CHARSET_NAME,
3894
drizzle_options(&con_slot->drizzle, DRIZZLE_OPT_COMPRESS, NullS);
3895
drizzle_options(&con_slot->drizzle, DRIZZLE_OPT_LOCAL_INFILE, 0);
3896
drizzle_options(&con_slot->drizzle, DRIZZLE_SET_CHARSET_NAME,
3922
3897
charset_info->csname);
3923
int opt_protocol= MYSQL_PROTOCOL_TCP;
3924
mysql_options(&con_slot->mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
3898
int opt_protocol= DRIZZLE_PROTOCOL_TCP;
3899
drizzle_options(&con_slot->drizzle,DRIZZLE_OPT_PROTOCOL,(char*)&opt_protocol);
3925
3900
if (opt_charsets_dir)
3926
mysql_options(&con_slot->mysql, MYSQL_SET_CHARSET_DIR,
3901
drizzle_options(&con_slot->drizzle, DRIZZLE_SET_CHARSET_DIR,
3927
3902
opt_charsets_dir);
3928
3903
3929
3904
/* Use default db name */
3934
3909
if (ds_database.length && !strcmp(ds_database.str,"*NO-ONE*"))
3935
3910
dynstr_set(&ds_database, "");
3936
3911
3937
if (connect_n_handle_errors(command, &con_slot->mysql,
3912
if (connect_n_handle_errors(command, &con_slot->drizzle,
3938
3913
ds_host.str,ds_user.str,
3939
3914
ds_password.str, ds_database.str,
3940
3915
con_port, ds_sock.str))
3942
3917
if (!(con_slot->name= my_strdup(ds_connection_name.str, MYF(MY_WME))))
3943
3918
die("Out of memory");
3944
3919
cur_con= con_slot;
3945
3920
3946
3921
if (con_slot == next_con)
3947
3922
next_con++; /* if we used the next_con slot, advance the pointer */
3948
3923
}
3949
3924
3950
/* Update $mysql_get_server_version to that of current connection */
3951
var_set_mysql_get_server_version(&cur_con->mysql);
3925
/* Update $drizzle_get_server_version to that of current connection */
3926
var_set_drizzle_get_server_version(&cur_con->drizzle);
3952
3927
3953
3928
dynstr_free(&ds_connection_name);
3954
3929
dynstr_free(&ds_host);
3995
3970
SYNOPSIS
3996
3971
do_block()
3997
3972
cmd Type of block
3998
q called command
3973
q called command
3999
3974
4000
3975
DESCRIPTION
4001
3976
if ([!]<expr>)
4105
4080
return 0;
4106
4081
4107
4082
for (i= 1; i < length &&
4108
(c= my_getc(cur_file->file)) == *(delim + i);
4083
(c= my_getc(cur_file->file)) == *(delim + i);
4109
4084
i++)
4110
4085
tmp[i]= c;
4111
4086
4112
4087
if (i == length)
4113
return 1; /* Found delimiter */
4088
return 1; /* Found delimiter */
4114
4089
4115
4090
/* didn't find delimiter, push back things that we read */
4116
4091
my_ungetc(c);
4169
4144
found_eof:
4170
4145
if (cur_file->file != stdin)
4171
4146
{
4172
my_fclose(cur_file->file, MYF(0));
4147
my_fclose(cur_file->file, MYF(0));
4173
4148
cur_file->file= 0;
4174
4149
}
4175
4150
my_free((uchar*) cur_file->file_name, MYF(MY_ALLOW_ZERO_PTR));
4204
4179
case R_NORMAL:
4205
4180
if (end_of_query(c))
4206
4181
{
4207
*p= 0;
4208
return(0);
4182
*p= 0;
4183
return(0);
4209
4184
}
4210
4185
else if ((c == '{' &&
4211
4186
(!my_strnncoll_simple(charset_info, (const uchar*) "while", 5,
4215
4190
{
4216
4191
/* Only if and while commands can be terminated by { */
4217
4192
*p++= c;
4218
*p= 0;
4219
return(0);
4193
*p= 0;
4194
return(0);
4220
4195
}
4221
4196
else if (c == '\'' || c == '"' || c == '`')
4222
4197
{
4223
4198
last_quote= c;
4224
state= R_Q;
4199
state= R_Q;
4225
4200
}
4226
4201
break;
4227
4202
4229
4204
if (c == '\n')
4230
4205
{
4231
4206
/* Comments are terminated by newline */
4232
*p= 0;
4233
return(0);
4207
*p= 0;
4208
return(0);
4234
4209
}
4235
4210
break;
4236
4211
4238
4213
if (c == '#' || c == '-')
4239
4214
{
4240
4215
/* A # or - in the first position of the line - this is a comment */
4241
state = R_COMMENT;
4216
state = R_COMMENT;
4242
4217
}
4243
4218
else if (my_isspace(charset_info, c))
4244
4219
{
4245
4220
/* Skip all space at begining of line */
4246
if (c == '\n')
4221
if (c == '\n')
4247
4222
{
4248
4223
/* Query hasn't started yet */
4249
start_lineno= cur_file->lineno;
4224
start_lineno= cur_file->lineno;
4250
4225
}
4251
skip_char= 1;
4226
skip_char= 1;
4252
4227
}
4253
4228
else if (end_of_query(c))
4254
4229
{
4255
*p= 0;
4256
return(0);
4230
*p= 0;
4231
return(0);
4257
4232
}
4258
4233
else if (c == '}')
4259
4234
{
4260
4235
/* A "}" need to be by itself in the begining of a line to terminate */
4261
4236
*p++= c;
4262
*p= 0;
4263
return(0);
4237
*p= 0;
4238
return(0);
4264
4239
}
4265
4240
else if (c == '\'' || c == '"' || c == '`')
4266
4241
{
4267
4242
last_quote= c;
4268
state= R_Q;
4243
state= R_Q;
4269
4244
}
4270
4245
else
4271
state= R_NORMAL;
4246
state= R_NORMAL;
4272
4247
break;
4273
4248
4274
4249
case R_Q:
4275
4250
if (c == last_quote)
4276
state= R_NORMAL;
4251
state= R_NORMAL;
4277
4252
else if (c == '\\')
4278
state= R_SLASH_IN_Q;
4253
state= R_SLASH_IN_Q;
4279
4254
break;
4280
4255
4281
4256
case R_SLASH_IN_Q:
4294
4269
/* completed before we pass buf_end */
4295
4270
if ((charlen > 1) && (p + charlen) <= buf_end)
4296
4271
{
4297
int i;
4298
char* mb_start = p;
4299
4300
*p++ = c;
4301
4302
for (i= 1; i < charlen; i++)
4303
{
4304
if (feof(cur_file->file))
4305
goto found_eof;
4306
c= my_getc(cur_file->file);
4307
*p++ = c;
4308
}
4309
if (! my_ismbchar(charset_info, mb_start, p))
4310
{
4311
/* It was not a multiline char, push back the characters */
4312
/* We leave first 'c', i.e. pretend it was a normal char */
4313
while (p > mb_start)
4314
my_ungetc(*--p);
4315
}
4272
int i;
4273
char* mb_start = p;
4274
4275
*p++ = c;
4276
4277
for (i= 1; i < charlen; i++)
4278
{
4279
if (feof(cur_file->file))
4280
goto found_eof;
4281
c= my_getc(cur_file->file);
4282
*p++ = c;
4283
}
4284
if (! my_ismbchar(charset_info, mb_start, p))
4285
{
4286
/* It was not a multiline char, push back the characters */
4287
/* We leave first 'c', i.e. pretend it was a normal char */
4288
while (p > mb_start)
4289
my_ungetc(*--p);
4290
}
4316
4291
}
4317
4292
else
4318
4293
#endif
4319
*p++= c;
4294
*p++= c;
4320
4295
}
4321
4296
}
4322
4297
die("The input buffer is too small for this query.x\n" \
4379
4354
4380
4355
/*
4381
4356
Check a command that is about to be sent (or should have been
4382
sent if parsing was enabled) to mysql server for
4357
sent if parsing was enabled) to DRIZZLE server for
4383
4358
suspicious things and generate warnings.
4384
4359
*/
4385
4360
4391
4366
{
4392
4367
/*
4393
4368
Look for query's that lines that start with a -- comment
4394
and has a mysqltest command
4369
and has a drizzletest command
4395
4370
*/
4396
4371
if (ptr[0] == '\n' &&
4397
4372
ptr[1] && ptr[1] == '-' &&
4412
4387
*end= 0;
4413
4388
type= find_type(start, &command_typelib, 1+2);
4414
4389
if (type)
4415
warning_msg("Embedded mysqltest command '--%s' detected in "
4390
warning_msg("Embedded drizzletest command '--%s' detected in "
4416
4391
"query '%s' was this intentional? ",
4417
4392
start, command->query);
4418
4393
*end= save;
4639
4614
};
4640
4615
4641
4616
4642
#include <help_start.h>
4643
4644
4617
static void print_version(void)
4645
4618
{
4646
4619
printf("%s Ver %s Distrib %s, for %s (%s)\n",my_progname,MTEST_VERSION,
4647
MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
4620
MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
4648
4621
}
4649
4622
4650
4623
static void usage(void)
4651
4624
{
4652
4625
print_version();
4653
printf("MySQL AB, by Sasha, Matt, Monty & Jani\n");
4626
printf("DRIZZLE AB, by Sasha, Matt, Monty & Jani\n");
4654
4627
printf("This software comes with ABSOLUTELY NO WARRANTY\n\n");
4655
printf("Runs a test against the mysql server and compares output with a results file.\n\n");
4628
printf("Runs a test against the DRIZZLE server and compares output with a results file.\n\n");
4656
4629
printf("Usage: %s [OPTIONS] [database] < test_file\n", my_progname);
4657
4630
my_print_help(my_long_options);
4658
4631
printf(" --no-defaults Don't read default options from any options file.\n");
4659
4632
my_print_variables(my_long_options);
4660
4633
}
4661
4634
4662
#include <help_end.h>
4663
4664
4665
4635
/*
4666
4636
Read arguments for embedded server and put them into
4667
4637
embedded_server_args[]
4682
4652
if (!embedded_server_arg_count)
4683
4653
{
4684
4654
embedded_server_arg_count=1;
4685
embedded_server_args[0]= (char*) ""; /* Progname */
4655
embedded_server_args[0]= (char*) ""; /* Progname */
4686
4656
}
4687
4657
if (!(file=my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(MY_WME))))
4688
4658
die("Failed to open file '%s'", buff);
4689
4659
4690
4660
while (embedded_server_arg_count < MAX_EMBEDDED_SERVER_ARGS &&
4691
(str=fgets(argument,sizeof(argument), file)))
4661
(str=fgets(argument,sizeof(argument), file)))
4692
4662
{
4693
*(strend(str)-1)=0; /* Remove end newline */
4663
*(strend(str)-1)=0; /* Remove end newline */
4694
4664
if (!(embedded_server_args[embedded_server_arg_count]=
4695
(char*) my_strdup(str,MYF(MY_WME))))
4665
(char*) my_strdup(str,MYF(MY_WME))))
4696
4666
{
4697
4667
my_fclose(file,MYF(0));
4698
4668
die("Out of memory");
4710
4680
4711
4681
static bool
4712
4682
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
4713
char *argument)
4683
char *argument)
4714
4684
{
4715
4685
switch(optid) {
4716
4686
case 'r':
4743
4713
}
4744
4714
fn_format(buff, argument, "", "", MY_UNPACK_FILENAME);
4745
4715
timer_file= buff;
4746
unlink(timer_file); /* Ignore error, may not exist */
4716
unlink(timer_file); /* Ignore error, may not exist */
4747
4717
break;
4748
4718
}
4749
4719
case 'p':
4751
4721
{
4752
4722
my_free(opt_pass, MYF(MY_ALLOW_ZERO_PTR));
4753
4723
opt_pass= my_strdup(argument, MYF(MY_FAE));
4754
while (*argument) *argument++= 'x'; /* Destroy argument */
4724
while (*argument) *argument++= 'x'; /* Destroy argument */
4755
4725
tty_password= 0;
4756
4726
}
4757
4727
else
4899
4869
Append the result for one field to the dynamic string ds
4900
4870
*/
4901
4871
4902
static void append_field(DYNAMIC_STRING *ds, uint col_idx, MYSQL_FIELD* field,
4872
static void append_field(DYNAMIC_STRING *ds, uint col_idx, DRIZZLE_FIELD* field,
4903
4873
const char* val, uint64_t len, bool is_null)
4904
4874
{
4905
4875
if (col_idx < max_replace_column && replace_column[col_idx])
4934
4904
Values may be converted with 'replace_column'
4935
4905
*/
4936
4906
4937
static void append_result(DYNAMIC_STRING *ds, MYSQL_RES *res)
4907
static void append_result(DYNAMIC_STRING *ds, DRIZZLE_RES *res)
4938
4908
{
4939
MYSQL_ROW row;
4940
uint32_t num_fields= mysql_num_fields(res);
4941
MYSQL_FIELD *fields= mysql_fetch_fields(res);
4909
DRIZZLE_ROW row;
4910
uint32_t num_fields= drizzle_num_fields(res);
4911
DRIZZLE_FIELD *fields= drizzle_fetch_fields(res);
4942
4912
uint32_t *lengths;
4943
4913
4944
while ((row = mysql_fetch_row(res)))
4914
while ((row = drizzle_fetch_row(res)))
4945
4915
{
4946
4916
uint32_t i;
4947
lengths = mysql_fetch_lengths(res);
4917
lengths = drizzle_fetch_lengths(res);
4948
4918
for (i = 0; i < num_fields; i++)
4949
4919
append_field(ds, i, &fields[i],
4950
4920
(const char*)row[i], lengths[i], !row[i]);
4959
4929
*/
4960
4930
4961
4931
static void append_metadata(DYNAMIC_STRING *ds,
4962
MYSQL_FIELD *field,
4932
DRIZZLE_FIELD *field,
4963
4933
uint num_fields)
4964
4934
{
4965
MYSQL_FIELD *field_end;
4935
DRIZZLE_FIELD *field_end;
4966
4936
dynstr_append(ds,"Catalog\tDatabase\tTable\tTable_alias\tColumn\t"
4967
4937
"Column_alias\tType\tLength\tMax length\tIs_null\t"
4968
4938
"Flags\tDecimals\tCharsetnr\n");
5030
5000
*/
5031
5001
5032
5002
static void append_table_headings(DYNAMIC_STRING *ds,
5033
MYSQL_FIELD *field,
5003
DRIZZLE_FIELD *field,
5034
5004
uint num_fields)
5035
5005
{
5036
5006
uint col_idx;
5050
5020
Number of warnings appended to ds
5051
5021
*/
5052
5022
5053
static int append_warnings(DYNAMIC_STRING *ds, MYSQL* mysql)
5023
static int append_warnings(DYNAMIC_STRING *ds, DRIZZLE *drizzle)
5054
5024
{
5055
5025
uint count;
5056
MYSQL_RES *warn_res;
5057
5058
5059
if (!(count= mysql_warning_count(mysql)))
5026
DRIZZLE_RES *warn_res;
5027
5028
5029
if (!(count= drizzle_warning_count(drizzle)))
5060
5030
return(0);
5061
5031
5062
5032
/*
5064
5034
through PS API we should not issue SHOW WARNINGS until
5065
5035
we have not read all results...
5066
5036
*/
5067
assert(!mysql_more_results(mysql));
5068
5069
if (mysql_real_query(mysql, "SHOW WARNINGS", 13))
5070
die("Error running query \"SHOW WARNINGS\": %s", mysql_error(mysql));
5071
5072
if (!(warn_res= mysql_store_result(mysql)))
5037
assert(!drizzle_more_results(drizzle));
5038
5039
if (drizzle_real_query(drizzle, "SHOW WARNINGS", 13))
5040
die("Error running query \"SHOW WARNINGS\": %s", drizzle_error(drizzle));
5041
5042
if (!(warn_res= drizzle_store_result(drizzle)))
5073
5043
die("Warning count is %u but didn't get any warnings",
5074
count);
5044
count);
5075
5045
5076
5046
append_result(ds, warn_res);
5077
mysql_free_result(warn_res);
5047
drizzle_free_result(warn_res);
5078
5048
5079
5049
return(count);
5080
5050
}
5081
5051
5082
5052
5083
5053
/*
5084
Run query using MySQL C API
5054
Run query using DRIZZLE C API
5085
5055
5086
5056
SYNOPSIS
5087
5057
run_query_normal()
5088
mysql mysql handle
5089
command current command pointer
5090
flags flags indicating if we should SEND and/or REAP
5091
query query string to execute
5092
query_len length query string to execute
5093
ds output buffer where to store result form query
5058
drizzle DRIZZLE handle
5059
command current command pointer
5060
flags flags indicating if we should SEND and/or REAP
5061
query query string to execute
5062
query_len length query string to execute
5063
ds output buffer where to store result form query
5094
5064
*/
5095
5065
5096
5066
static void run_query_normal(struct st_connection *cn,
5098
5068
int flags, char *query, int query_len,
5099
5069
DYNAMIC_STRING *ds, DYNAMIC_STRING *ds_warnings)
5100
5070
{
5101
MYSQL_RES *res= 0;
5102
MYSQL *mysql= &cn->mysql;
5071
DRIZZLE_RES *res= 0;
5072
DRIZZLE *drizzle= &cn->drizzle;
5103
5073
int err= 0, counter= 0;
5104
5074
5105
5075
if (flags & QUERY_SEND_FLAG)
5109
5079
*/
5110
5080
if (do_send_query(cn, query, query_len, flags))
5111
5081
{
5112
handle_error(command, mysql_errno(mysql), mysql_error(mysql),
5113
mysql_sqlstate(mysql), ds);
5082
handle_error(command, drizzle_errno(drizzle), drizzle_error(drizzle),
5083
drizzle_sqlstate(drizzle), ds);
5114
5084
goto end;
5115
5085
}
5116
5086
}
5128
5098
do
5129
5099
{
5130
5100
/*
5131
When on first result set, call mysql_read_query_result to retrieve
5101
When on first result set, call drizzle_read_query_result to retrieve
5132
5102
answer to the query sent earlier
5133
5103
*/
5134
if ((counter==0) && mysql_read_query_result(mysql))
5104
if ((counter==0) && drizzle_read_query_result(drizzle))
5135
5105
{
5136
handle_error(command, mysql_errno(mysql), mysql_error(mysql),
5137
mysql_sqlstate(mysql), ds);
5106
handle_error(command, drizzle_errno(drizzle), drizzle_error(drizzle),
5107
drizzle_sqlstate(drizzle), ds);
5138
5108
goto end;
5139
5109
5140
5110
}
5142
5112
/*
5143
5113
Store the result of the query if it will return any fields
5144
5114
*/
5145
if (mysql_field_count(mysql) && ((res= mysql_store_result(mysql)) == 0))
5115
if (drizzle_field_count(drizzle) && ((res= drizzle_store_result(drizzle)) == 0))
5146
5116
{
5147
handle_error(command, mysql_errno(mysql), mysql_error(mysql),
5148
mysql_sqlstate(mysql), ds);
5117
handle_error(command, drizzle_errno(drizzle), drizzle_error(drizzle),
5118
drizzle_sqlstate(drizzle), ds);
5149
5119
goto end;
5150
5120
}
5151
5121
5155
5125
5156
5126
if (res)
5157
5127
{
5158
MYSQL_FIELD *fields= mysql_fetch_fields(res);
5159
uint num_fields= mysql_num_fields(res);
5128
DRIZZLE_FIELD *fields= drizzle_fetch_fields(res);
5129
uint num_fields= drizzle_num_fields(res);
5160
5130
5161
if (display_metadata)
5131
if (display_metadata)
5162
5132
append_metadata(ds, fields, num_fields);
5163
5133
5164
if (!display_result_vertically)
5165
append_table_headings(ds, fields, num_fields);
5134
if (!display_result_vertically)
5135
append_table_headings(ds, fields, num_fields);
5166
5136
5167
append_result(ds, res);
5137
append_result(ds, res);
5168
5138
}
5169
5139
5170
5140
/*
5171
Need to call mysql_affected_rows() before the "new"
5141
Need to call drizzle_affected_rows() before the "new"
5172
5142
query to find the warnings
5173
5143
*/
5174
5144
if (!disable_info)
5175
affected_rows= mysql_affected_rows(mysql);
5145
affected_rows= drizzle_affected_rows(drizzle);
5176
5146
5177
5147
/*
5178
5148
Add all warnings to the result. We can't do this if we are in
5179
5149
the middle of processing results from multi-statement, because
5180
5150
this will break protocol.
5181
5151
*/
5182
if (!disable_warnings && !mysql_more_results(mysql))
5152
if (!disable_warnings && !drizzle_more_results(drizzle))
5183
5153
{
5184
if (append_warnings(ds_warnings, mysql) || ds_warnings->length)
5185
{
5186
dynstr_append_mem(ds, "Warnings:\n", 10);
5187
dynstr_append_mem(ds, ds_warnings->str, ds_warnings->length);
5188
}
5154
if (append_warnings(ds_warnings, drizzle) || ds_warnings->length)
5155
{
5156
dynstr_append_mem(ds, "Warnings:\n", 10);
5157
dynstr_append_mem(ds, ds_warnings->str, ds_warnings->length);
5158
}
5189
5159
}
5190
5160
5191
5161
if (!disable_info)
5192
append_info(ds, affected_rows, mysql_info(mysql));
5162
append_info(ds, affected_rows, drizzle_info(drizzle));
5193
5163
}
5194
5164
5195
5165
if (res)
5196
5166
{
5197
mysql_free_result(res);
5167
drizzle_free_result(res);
5198
5168
res= 0;
5199
5169
}
5200
5170
counter++;
5201
} while (!(err= mysql_next_result(mysql)));
5171
} while (!(err= drizzle_next_result(drizzle)));
5202
5172
if (err > 0)
5203
5173
{
5204
/* We got an error from mysql_next_result, maybe expected */
5205
handle_error(command, mysql_errno(mysql), mysql_error(mysql),
5206
mysql_sqlstate(mysql), ds);
5174
/* We got an error from drizzle_next_result, maybe expected */
5175
handle_error(command, drizzle_errno(drizzle), drizzle_error(drizzle),
5176
drizzle_sqlstate(drizzle), ds);
5207
5177
goto end;
5208
5178
}
5209
5179
assert(err == -1); /* Successful and there are no more results */
5214
5184
end:
5215
5185
5216
5186
/*
5217
We save the return code (mysql_errno(mysql)) from the last call sent
5218
to the server into the mysqltest builtin variable $mysql_errno. This
5187
We save the return code (drizzle_errno(drizzle)) from the last call sent
5188
to the server into the drizzletest builtin variable $drizzle_errno. This
5219
5189
variable then can be used from the test case itself.
5220
5190
*/
5221
var_set_errno(mysql_errno(mysql));
5191
var_set_errno(drizzle_errno(drizzle));
5222
5192
return;
5223
5193
}
5224
5194
5235
5205
ds - dynamic string which is used for output buffer
5236
5206
5237
5207
NOTE
5238
If there is an unexpected error this function will abort mysqltest
5208
If there is an unexpected error this function will abort drizzletest
5239
5209
immediately.
5240
5210
*/
5241
5211
5315
5285
else
5316
5286
die("query '%s' failed with wrong sqlstate %s: '%s', instead of %s...",
5317
5287
command->query, err_sqlstate, err_error,
5318
command->expected_errors.err[0].code.sqlstate);
5288
command->expected_errors.err[0].code.sqlstate);
5319
5289
}
5320
5290
5321
5291
return;
5361
5331
5362
5332
SYNPOSIS
5363
5333
run_query()
5364
mysql mysql handle
5365
command currrent command pointer
5334
drizzle DRIZZLE handle
5335
command currrent command pointer
5366
5336
5367
5337
flags control the phased/stages of query execution to be performed
5368
5338
if QUERY_SEND_FLAG bit is on, the query will be sent. If QUERY_REAP_FLAG
5369
5339
is on the result will be read - for regular query, both bits must be on
5370
5340
*/
5371
5341
5372
static void run_query(struct st_connection *cn,
5342
static void run_query(struct st_connection *cn,
5373
5343
struct st_command *command,
5374
5344
int flags)
5375
5345
{
5493
5463
command->query[command->first_word_len]= save;
5494
5464
if (type > 0)
5495
5465
{
5496
command->type=(enum enum_commands) type; /* Found command */
5466
command->type=(enum enum_commands) type; /* Found command */
5497
5467
5498
5468
/*
5499
5469
Look for case where "query" was explicitly specified to
5507
5477
}
5508
5478
else
5509
5479
{
5510
/* No mysqltest command matched */
5480
/* No drizzletest command matched */
5511
5481
5512
5482
if (command->type != Q_COMMENT_WITH_COMMAND)
5513
5483
{
5514
/* A query that will sent to mysqld */
5484
/* A query that will sent to drizzled */
5515
5485
command->type= Q_QUERY;
5516
5486
}
5517
5487
else
5518
5488
{
5519
/* -- comment that didn't contain a mysqltest command */
5489
/* -- comment that didn't contain a drizzletest command */
5520
5490
command->type= Q_COMMENT;
5521
5491
warning_msg("Suspicious command '--%s' detected, was this intentional? "\
5522
5492
"Use # instead of -- to avoid this warning",
5655
5625
init_dynamic_string(&ds_warning_messages, "", 0, 2048);
5656
5626
parse_args(argc, argv);
5657
5627
5658
if (mysql_server_init(embedded_server_arg_count,
5659
embedded_server_args,
5660
(char**) embedded_server_groups))
5661
die("Can't initialize MySQL server");
5662
5628
server_initialized= 1;
5663
5629
if (cur_file == file_stack && cur_file->file == 0)
5664
5630
{
5667
5633
cur_file->lineno= 1;
5668
5634
}
5669
5635
cur_con= connections;
5670
if (!( mysql_init(&cur_con->mysql)))
5671
die("Failed in mysql_init()");
5636
if (!( drizzle_create(&cur_con->drizzle)))
5637
die("Failed in drizzle_create()");
5672
5638
if (opt_compress)
5673
mysql_options(&cur_con->mysql,MYSQL_OPT_COMPRESS,NullS);
5674
mysql_options(&cur_con->mysql, MYSQL_OPT_LOCAL_INFILE, 0);
5675
mysql_options(&cur_con->mysql, MYSQL_SET_CHARSET_NAME,
5639
drizzle_options(&cur_con->drizzle,DRIZZLE_OPT_COMPRESS,NullS);
5640
drizzle_options(&cur_con->drizzle, DRIZZLE_OPT_LOCAL_INFILE, 0);
5641
drizzle_options(&cur_con->drizzle, DRIZZLE_SET_CHARSET_NAME,
5676
5642
charset_info->csname);
5677
int opt_protocol= MYSQL_PROTOCOL_TCP;
5678
mysql_options(&cur_con->mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
5643
int opt_protocol= DRIZZLE_PROTOCOL_TCP;
5644
drizzle_options(&cur_con->drizzle,DRIZZLE_OPT_PROTOCOL,(char*)&opt_protocol);
5679
5645
if (opt_charsets_dir)
5680
mysql_options(&cur_con->mysql, MYSQL_SET_CHARSET_DIR,
5646
drizzle_options(&cur_con->drizzle, DRIZZLE_SET_CHARSET_DIR,
5681
5647
opt_charsets_dir);
5682
5648
5683
5649
if (!(cur_con->name = my_strdup("default", MYF(MY_WME))))
5684
5650
die("Out of memory");
5685
5651
5686
safe_connect(&cur_con->mysql, cur_con->name, opt_host, opt_user, opt_pass,
5652
safe_connect(&cur_con->drizzle, cur_con->name, opt_host, opt_user, opt_pass,
5687
5653
opt_db, opt_port);
5688
5654
5689
5655
/* Use all time until exit if no explicit 'start_timer' */
5690
5656
timer_start= timer_now();
5691
5657
5692
5658
/*
5693
Initialize $mysql_errno with -1, so we can
5659
Initialize $drizzle_errno with -1, so we can
5694
5660
- distinguish it from valid values ( >= 0 ) and
5695
5661
- detect if there was never a command sent to the server
5696
5662
*/
5697
5663
var_set_errno(-1);
5698
5664
5699
/* Update $mysql_get_server_version to that of current connection */
5700
var_set_mysql_get_server_version(&cur_con->mysql);
5665
/* Update $drizzle_get_server_version to that of current connection */
5666
var_set_drizzle_get_server_version(&cur_con->drizzle);
5701
5667
5702
5668
if (opt_include)
5703
5669
{
5729
5695
case Q_CONNECTION: select_connection(command); break;
5730
5696
case Q_DISCONNECT:
5731
5697
case Q_DIRTY_CLOSE:
5732
do_close_connection(command); break;
5698
do_close_connection(command); break;
5733
5699
case Q_ENABLE_QUERY_LOG: disable_query_log=0; break;
5734
5700
case Q_DISABLE_QUERY_LOG: disable_query_log=1; break;
5735
5701
case Q_ENABLE_ABORT_ON_ERROR: abort_on_error=1; break;
5765
5731
case Q_PERL: do_perl(command); break;
5766
5732
case Q_DELIMITER:
5767
5733
do_delimiter(command);
5768
break;
5734
break;
5769
5735
case Q_DISPLAY_VERTICAL_RESULTS:
5770
5736
display_result_vertically= true;
5771
5737
break;
5772
5738
case Q_DISPLAY_HORIZONTAL_RESULTS:
5773
display_result_vertically= false;
5739
display_result_vertically= false;
5774
5740
break;
5775
5741
case Q_SORTED_RESULT:
5776
5742
/*
5777
5743
Turn on sorting of result set, will be reset after next
5778
5744
command
5779
5745
*/
5780
display_result_sorted= true;
5746
display_result_sorted= true;
5781
5747
break;
5782
5748
case Q_LET: do_let(command); break;
5783
5749
case Q_EVAL_RESULT:
5785
5751
case Q_EVAL:
5786
5752
case Q_QUERY_VERTICAL:
5787
5753
case Q_QUERY_HORIZONTAL:
5788
if (command->query == command->query_buf)
5754
if (command->query == command->query_buf)
5789
5755
{
5790
5756
/* Skip the first part of command, i.e query_xxx */
5791
command->query= command->first_argument;
5757
command->query= command->first_argument;
5792
5758
command->first_word_len= 0;
5793
5759
}
5794
/* fall through */
5760
/* fall through */
5795
5761
case Q_QUERY:
5796
5762
case Q_REAP:
5797
5763
{
5798
bool old_display_result_vertically= display_result_vertically;
5764
bool old_display_result_vertically= display_result_vertically;
5799
5765
/* Default is full query, both reap and send */
5800
5766
int flags= QUERY_REAP_FLAG | QUERY_SEND_FLAG;
5801
5767
5813
5779
/* Check for special property for this query */
5814
5780
display_result_vertically|= (command->type == Q_QUERY_VERTICAL);
5815
5781
5816
if (save_file[0])
5817
{
5818
strmake(command->require_file, save_file, sizeof(save_file) - 1);
5819
save_file[0]= 0;
5820
}
5821
run_query(cur_con, command, flags);
5822
command_executed++;
5782
if (save_file[0])
5783
{
5784
strmake(command->require_file, save_file, sizeof(save_file) - 1);
5785
save_file[0]= 0;
5786
}
5787
run_query(cur_con, command, flags);
5788
command_executed++;
5823
5789
command->last_argument= command->end;
5824
5790
5825
5791
/* Restore settings */
5826
display_result_vertically= old_display_result_vertically;
5792
display_result_vertically= old_display_result_vertically;
5827
5793
5828
break;
5794
break;
5829
5795
}
5830
5796
case Q_SEND:
5831
5797
if (!*command->first_argument)
5839
5805
}
5840
5806
5841
5807
/* Remove "send" if this is first iteration */
5842
if (command->query == command->query_buf)
5843
command->query= command->first_argument;
5808
if (command->query == command->query_buf)
5809
command->query= command->first_argument;
5844
5810
5845
/*
5846
run_query() can execute a query partially, depending on the flags.
5847
QUERY_SEND_FLAG flag without QUERY_REAP_FLAG tells it to just send
5811
/*
5812
run_query() can execute a query partially, depending on the flags.
5813
QUERY_SEND_FLAG flag without QUERY_REAP_FLAG tells it to just send
5848
5814
the query and read the result some time later when reap instruction
5849
is given on this connection.
5815
is given on this connection.
5850
5816
*/
5851
run_query(cur_con, command, QUERY_SEND_FLAG);
5852
command_executed++;
5817
run_query(cur_con, command, QUERY_SEND_FLAG);
5818
command_executed++;
5853
5819
command->last_argument= command->end;
5854
break;
5820
break;
5855
5821
case Q_REQUIRE:
5856
do_get_file_name(command, save_file, sizeof(save_file));
5857
break;
5822
do_get_file_name(command, save_file, sizeof(save_file));
5823
break;
5858
5824
case Q_ERROR:
5859
5825
do_get_errcodes(command);
5860
break;
5826
break;
5861
5827
case Q_REPLACE:
5862
do_get_replace(command);
5863
break;
5828
do_get_replace(command);
5829
break;
5864
5830
case Q_REPLACE_REGEX:
5865
5831
do_get_replace_regex(command);
5866
5832
break;
5867
5833
case Q_REPLACE_COLUMN:
5868
do_get_replace_column(command);
5869
break;
5834
do_get_replace_column(command);
5835
break;
5870
5836
case Q_SAVE_MASTER_POS: do_save_master_pos(); break;
5871
5837
case Q_SYNC_WITH_MASTER: do_sync_with_master(command); break;
5872
5838
case Q_SYNC_SLAVE_WITH_MASTER:
5873
5839
{
5874
do_save_master_pos();
5875
if (*command->first_argument)
5876
select_connection(command);
5877
else
5878
select_connection_name("slave");
5879
do_sync_with_master2(0);
5880
break;
5840
do_save_master_pos();
5841
if (*command->first_argument)
5842
select_connection(command);
5843
else
5844
select_connection_name("slave");
5845
do_sync_with_master2(0);
5846
break;
5881
5847
}
5882
case Q_COMMENT: /* Ignore row */
5848
case Q_COMMENT: /* Ignore row */
5883
5849
command->last_argument= command->end;
5884
break;
5850
break;
5885
5851
case Q_PING:
5886
(void) mysql_ping(&cur_con->mysql);
5887
break;
5852
(void) drizzle_ping(&cur_con->drizzle);
5853
break;
5888
5854
case Q_EXEC:
5889
do_exec(command);
5890
command_executed++;
5891
break;
5855
do_exec(command);
5856
command_executed++;
5857
break;
5892
5858
case Q_START_TIMER:
5893
/* Overwrite possible earlier start of timer */
5894
timer_start= timer_now();
5895
break;
5859
/* Overwrite possible earlier start of timer */
5860
timer_start= timer_now();
5861
break;
5896
5862
case Q_END_TIMER:
5897
/* End timer before ending mysqltest */
5898
timer_output();
5899
break;
5863
/* End timer before ending drizzletest */
5864
timer_output();
5865
break;
5900
5866
case Q_CHARACTER_SET:
5901
do_set_charset(command);
5902
break;
5867
do_set_charset(command);
5868
break;
5903
5869
case Q_DISABLE_RECONNECT:
5904
set_reconnect(&cur_con->mysql, 0);
5870
set_reconnect(&cur_con->drizzle, 0);
5905
5871
break;
5906
5872
case Q_ENABLE_RECONNECT:
5907
set_reconnect(&cur_con->mysql, 1);
5873
set_reconnect(&cur_con->drizzle, 1);
5908
5874
break;
5909
5875
case Q_DISABLE_PARSING:
5910
5876
if (parsing_disabled == 0)
6003
5969
6004
5970
if (record)
6005
5971
{
6006
/* Recording - dump the output from test to result file */
6007
str_to_file(result_file_name, ds_res.str, ds_res.length);
5972
/* Recording - dump the output from test to result file */
5973
str_to_file(result_file_name, ds_res.str, ds_res.length);
6008
5974
}
6009
5975
else
6010
5976
{
6011
/* Check that the output from test is equal to result file
6012
- detect missing result file
6013
- detect zero size result file
5977
/* Check that the output from test is equal to result file
5978
- detect missing result file
5979
- detect zero size result file
6014
5980
*/
6015
check_result(&ds_res);
5981
check_result(&ds_res);
6016
5982
}
6017
5983
}
6018
5984
else
6061
6027
before executing any commands. The time we measure is
6062
6028
6063
6029
- If no explicit 'start_timer' or 'end_timer' is given in the
6064
test case, the timer measure how long we execute in mysqltest.
6030
test case, the timer measure how long we execute in drizzletest.
6065
6031
6066
6032
- If only 'start_timer' is given we measure how long we execute
6067
from that point until we terminate mysqltest.
6033
from that point until we terminate drizzletest.
6068
6034
6069
6035
- If only 'end_timer' is given we measure how long we execute
6070
from that we enter mysqltest to the 'end_timer' is command is
6036
from that we enter drizzletest to the 'end_timer' is command is
6071
6037
executed.
6072
6038
6073
6039
- If both 'start_timer' and 'end_timer' are given we measure
6156
6122
6157
6123
/* Definitions for replace result */
6158
6124
6159
typedef struct st_pointer_array { /* when using array-strings */
6160
TYPELIB typelib; /* Pointer to strings */
6161
uchar *str; /* Strings is here */
6162
int7 *flag; /* Flag about each var. */
6163
uint array_allocs,max_count,length,max_length;
6125
typedef struct st_pointer_array { /* when using array-strings */
6126
TYPELIB typelib; /* Pointer to strings */
6127
uchar *str; /* Strings is here */
6128
int7 *flag; /* Flag about each var. */
6129
uint array_allocs,max_count,length,max_length;
6164
6130
} POINTER_ARRAY;
6165
6131
6166
6132
struct st_replace;
6167
6133
struct st_replace *init_replace(char * *from, char * *to, uint count,
6168
char * word_end_chars);
6134
char * word_end_chars);
6169
6135
int insert_pointer_name(POINTER_ARRAY *pa,char * name);
6170
6136
void replace_strings_append(struct st_replace *rep, DYNAMIC_STRING* ds,
6171
6137
const char *from, int len);
6192
6158
6193
6159
free_replace();
6194
6160
6195
bzero((char*) &to_array,sizeof(to_array));
6196
bzero((char*) &from_array,sizeof(from_array));
6161
memset((char*) &to_array, 0, sizeof(to_array));
6162
memset((char*) &from_array, 0, sizeof(from_array));
6197
6163
if (!*from)
6198
6164
die("Missing argument in %s", command->query);
6199
6165
start= buff= (char *)my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
6211
6177
for (i= 1,pos= word_end_chars ; i < 256 ; i++)
6212
6178
if (my_isspace(charset_info,i))
6213
6179
*pos++= i;
6214
*pos=0; /* End pointer */
6180
*pos=0; /* End pointer */
6215
6181
if (!(glob_replace= init_replace((char**) from_array.typelib.type_names,
6216
(char**) to_array.typelib.type_names,
6217
(uint) from_array.typelib.count,
6218
word_end_chars)))
6182
(char**) to_array.typelib.type_names,
6183
(uint) from_array.typelib.count,
6184
word_end_chars)))
6219
6185
die("Can't initialize replace from '%s'", command->query);
6220
6186
free_pointer_array(&from_array);
6221
6187
free_pointer_array(&to_array);
6389
6355
/* for each regexp substitution statement */
6390
6356
while (p < expr_end)
6391
6357
{
6392
bzero(®,sizeof(reg));
6358
memset(®, 0, sizeof(reg));
6393
6359
/* find the start of the statement */
6394
6360
while (p < expr_end)
6395
6361
{
6602
6568
#define LAST_CHAR_CODE 259
6603
6569
6604
6570
typedef struct st_rep_set {
6605
uint *bits; /* Pointer to used sets */
6606
short next[LAST_CHAR_CODE]; /* Pointer to next sets */
6607
uint found_len; /* Best match to date */
6608
int found_offset;
6609
uint table_offset;
6610
uint size_of_bits; /* For convinience */
6571
uint *bits; /* Pointer to used sets */
6572
short next[LAST_CHAR_CODE]; /* Pointer to next sets */
6573
uint found_len; /* Best match to date */
6574
int found_offset;
6575
uint table_offset;
6576
uint size_of_bits; /* For convinience */
6611
6577
} REP_SET;
6612
6578
6613
6579
typedef struct st_rep_sets {
6614
uint count; /* Number of sets */
6615
uint extra; /* Extra sets in buffer */
6616
uint invisible; /* Sets not chown */
6617
uint size_of_bits;
6618
REP_SET *set,*set_buffer;
6619
uint *bit_buffer;
6580
uint count; /* Number of sets */
6581
uint extra; /* Extra sets in buffer */
6582
uint invisible; /* Sets not chown */
6583
uint size_of_bits;
6584
REP_SET *set,*set_buffer;
6585
uint *bit_buffer;
6620
6586
} REP_SETS;
6621
6587
6622
6588
typedef struct st_found_set {
6667
6633
/* Init a replace structure for further calls */
6668
6634
6669
6635
REPLACE *init_replace(char * *from, char * *to,uint count,
6670
char * word_end_chars)
6636
char * word_end_chars)
6671
6637
{
6672
6638
static const int SPACE_CHAR= 256;
6673
6639
static const int START_OF_LINE= 257;
6699
6665
if (len > max_length)
6700
6666
max_length=len;
6701
6667
}
6702
bzero((char*) is_word_end,sizeof(is_word_end));
6668
memset((char*) is_word_end, 0, sizeof(is_word_end));
6703
6669
for (i=0 ; word_end_chars[i] ; i++)
6704
6670
is_word_end[(uchar) word_end_chars[i]]=1;
6705
6671
6707
6673
return(0);
6708
6674
found_sets=0;
6709
6675
if (!(found_set= (FOUND_SET*) my_malloc(sizeof(FOUND_SET)*max_length*count,
6710
MYF(MY_WME))))
6676
MYF(MY_WME))))
6711
6677
{
6712
6678
free_sets(&sets);
6713
6679
return(0);
6714
6680
}
6715
VOID(make_new_set(&sets)); /* Set starting set */
6716
make_sets_invisible(&sets); /* Hide previus sets */
6681
VOID(make_new_set(&sets)); /* Set starting set */
6682
make_sets_invisible(&sets); /* Hide previus sets */
6717
6683
used_sets=-1;
6718
word_states=make_new_set(&sets); /* Start of new word */
6719
start_states=make_new_set(&sets); /* This is first state */
6684
word_states=make_new_set(&sets); /* Start of new word */
6685
start_states=make_new_set(&sets); /* This is first state */
6720
6686
if (!(follow=(FOLLOWS*) my_malloc((states+2)*sizeof(FOLLOWS),MYF(MY_WME))))
6721
6687
{
6722
6688
free_sets(&sets);
6732
6698
internal_set_bit(start_states,states+1);
6733
6699
if (!from[i][2])
6734
6700
{
6735
start_states->table_offset=i;
6736
start_states->found_offset=1;
6701
start_states->table_offset=i;
6702
start_states->found_offset=1;
6737
6703
}
6738
6704
}
6739
6705
else if (from[i][0] == '\\' && from[i][1] == '$')
6742
6708
internal_set_bit(word_states,states);
6743
6709
if (!from[i][2] && start_states->table_offset == (uint) ~0)
6744
6710
{
6745
start_states->table_offset=i;
6746
start_states->found_offset=0;
6711
start_states->table_offset=i;
6712
start_states->found_offset=0;
6747
6713
}
6748
6714
}
6749
6715
else
6750
6716
{
6751
6717
internal_set_bit(word_states,states);
6752
6718
if (from[i][0] == '\\' && (from[i][1] == 'b' && from[i][2]))
6753
internal_set_bit(start_states,states+1);
6719
internal_set_bit(start_states,states+1);
6754
6720
else
6755
internal_set_bit(start_states,states);
6721
internal_set_bit(start_states,states);
6756
6722
}
6757
6723
for (pos=from[i], len=0; *pos ; pos++)
6758
6724
{
6759
6725
if (*pos == '\\' && *(pos+1))
6760
6726
{
6761
pos++;
6762
switch (*pos) {
6763
case 'b':
6764
follow_ptr->chr = SPACE_CHAR;
6765
break;
6766
case '^':
6767
follow_ptr->chr = START_OF_LINE;
6768
break;
6769
case '$':
6770
follow_ptr->chr = END_OF_LINE;
6771
break;
6772
case 'r':
6773
follow_ptr->chr = '\r';
6774
break;
6775
case 't':
6776
follow_ptr->chr = '\t';
6777
break;
6778
case 'v':
6779
follow_ptr->chr = '\v';
6780
break;
6781
default:
6782
follow_ptr->chr = (uchar) *pos;
6783
break;
6784
}
6727
pos++;
6728
switch (*pos) {
6729
case 'b':
6730
follow_ptr->chr = SPACE_CHAR;
6731
break;
6732
case '^':
6733
follow_ptr->chr = START_OF_LINE;
6734
break;
6735
case '$':
6736
follow_ptr->chr = END_OF_LINE;
6737
break;
6738
case 'r':
6739
follow_ptr->chr = '\r';
6740
break;
6741
case 't':
6742
follow_ptr->chr = '\t';
6743
break;
6744
case 'v':
6745
follow_ptr->chr = '\v';
6746
break;
6747
default:
6748
follow_ptr->chr = (uchar) *pos;
6749
break;
6750
}
6785
6751
}
6786
6752
else
6787
follow_ptr->chr= (uchar) *pos;
6753
follow_ptr->chr= (uchar) *pos;
6788
6754
follow_ptr->table_offset=i;
6789
6755
follow_ptr->len= ++len;
6790
6756
follow_ptr++;
6800
6766
for (set_nr=0,pos=0 ; set_nr < sets.count ; set_nr++)
6801
6767
{
6802
6768
set=sets.set+set_nr;
6803
default_state= 0; /* Start from beginning */
6769
default_state= 0; /* Start from beginning */
6804
6770
6805
6771
/* If end of found-string not found or start-set with current set */
6806
6772
6808
6774
{
6809
6775
if (!follow[i].chr)
6810
6776
{
6811
if (! default_state)
6812
default_state= find_found(found_set,set->table_offset,
6813
set->found_offset+1);
6777
if (! default_state)
6778
default_state= find_found(found_set,set->table_offset,
6779
set->found_offset+1);
6814
6780
}
6815
6781
}
6816
copy_bits(sets.set+used_sets,set); /* Save set for changes */
6782
copy_bits(sets.set+used_sets,set); /* Save set for changes */
6817
6783
if (!default_state)
6818
or_bits(sets.set+used_sets,sets.set); /* Can restart from start */
6784
or_bits(sets.set+used_sets,sets.set); /* Can restart from start */
6819
6785
6820
6786
/* Find all chars that follows current sets */
6821
bzero((char*) used_chars,sizeof(used_chars));
6787
memset((char*) used_chars, 0, sizeof(used_chars));
6822
6788
for (i= (uint) ~0; (i=get_next_bit(sets.set+used_sets,i)) ;)
6823
6789
{
6824
6790
used_chars[follow[i].chr]=1;
6825
6791
if ((follow[i].chr == SPACE_CHAR && !follow[i+1].chr &&
6826
follow[i].len > 1) || follow[i].chr == END_OF_LINE)
6827
used_chars[0]=1;
6792
follow[i].len > 1) || follow[i].chr == END_OF_LINE)
6793
used_chars[0]=1;
6828
6794
}
6829
6795
6830
6796
/* Mark word_chars used if \b is in state */
6831
6797
if (used_chars[SPACE_CHAR])
6832
6798
for (pos= word_end_chars ; *pos ; pos++)
6833
used_chars[(int) (uchar) *pos] = 1;
6799
used_chars[(int) (uchar) *pos] = 1;
6834
6800
6835
6801
/* Handle other used characters */
6836
6802
for (chr= 0 ; chr < 256 ; chr++)
6837
6803
{
6838
6804
if (! used_chars[chr])
6839
set->next[chr]= chr ? default_state : -1;
6805
set->next[chr]= chr ? default_state : -1;
6840
6806
else
6841
6807
{
6842
new_set=make_new_set(&sets);
6843
set=sets.set+set_nr; /* if realloc */
6844
new_set->table_offset=set->table_offset;
6845
new_set->found_len=set->found_len;
6846
new_set->found_offset=set->found_offset+1;
6847
found_end=0;
6808
new_set=make_new_set(&sets);
6809
set=sets.set+set_nr; /* if realloc */
6810
new_set->table_offset=set->table_offset;
6811
new_set->found_len=set->found_len;
6812
new_set->found_offset=set->found_offset+1;
6813
found_end=0;
6848
6814
6849
for (i= (uint) ~0 ; (i=get_next_bit(sets.set+used_sets,i)) ; )
6850
{
6851
if (!follow[i].chr || follow[i].chr == chr ||
6852
(follow[i].chr == SPACE_CHAR &&
6853
(is_word_end[chr] ||
6854
(!chr && follow[i].len > 1 && ! follow[i+1].chr))) ||
6855
(follow[i].chr == END_OF_LINE && ! chr))
6856
{
6857
if ((! chr || (follow[i].chr && !follow[i+1].chr)) &&
6858
follow[i].len > found_end)
6859
found_end=follow[i].len;
6860
if (chr && follow[i].chr)
6861
internal_set_bit(new_set,i+1); /* To next set */
6862
else
6863
internal_set_bit(new_set,i);
6864
}
6865
}
6866
if (found_end)
6867
{
6868
new_set->found_len=0; /* Set for testing if first */
6869
bits_set=0;
6870
for (i= (uint) ~0; (i=get_next_bit(new_set,i)) ;)
6871
{
6872
if ((follow[i].chr == SPACE_CHAR ||
6873
follow[i].chr == END_OF_LINE) && ! chr)
6874
bit_nr=i+1;
6875
else
6876
bit_nr=i;
6877
if (follow[bit_nr-1].len < found_end ||
6878
(new_set->found_len &&
6879
(chr == 0 || !follow[bit_nr].chr)))
6880
internal_clear_bit(new_set,i);
6881
else
6882
{
6883
if (chr == 0 || !follow[bit_nr].chr)
6884
{ /* best match */
6885
new_set->table_offset=follow[bit_nr].table_offset;
6886
if (chr || (follow[i].chr == SPACE_CHAR ||
6887
follow[i].chr == END_OF_LINE))
6888
new_set->found_offset=found_end; /* New match */
6889
new_set->found_len=found_end;
6890
}
6891
bits_set++;
6892
}
6893
}
6894
if (bits_set == 1)
6895
{
6896
set->next[chr] = find_found(found_set,
6897
new_set->table_offset,
6898
new_set->found_offset);
6899
free_last_set(&sets);
6900
}
6901
else
6902
set->next[chr] = find_set(&sets,new_set);
6903
}
6904
else
6905
set->next[chr] = find_set(&sets,new_set);
6815
for (i= (uint) ~0 ; (i=get_next_bit(sets.set+used_sets,i)) ; )
6816
{
6817
if (!follow[i].chr || follow[i].chr == chr ||
6818
(follow[i].chr == SPACE_CHAR &&
6819
(is_word_end[chr] ||
6820
(!chr && follow[i].len > 1 && ! follow[i+1].chr))) ||
6821
(follow[i].chr == END_OF_LINE && ! chr))
6822
{
6823
if ((! chr || (follow[i].chr && !follow[i+1].chr)) &&
6824
follow[i].len > found_end)
6825
found_end=follow[i].len;
6826
if (chr && follow[i].chr)
6827
internal_set_bit(new_set,i+1); /* To next set */
6828
else
6829
internal_set_bit(new_set,i);
6830
}
6831
}
6832
if (found_end)
6833
{
6834
new_set->found_len=0; /* Set for testing if first */
6835
bits_set=0;
6836
for (i= (uint) ~0; (i=get_next_bit(new_set,i)) ;)
6837
{
6838
if ((follow[i].chr == SPACE_CHAR ||
6839
follow[i].chr == END_OF_LINE) && ! chr)
6840
bit_nr=i+1;
6841
else
6842
bit_nr=i;
6843
if (follow[bit_nr-1].len < found_end ||
6844
(new_set->found_len &&
6845
(chr == 0 || !follow[bit_nr].chr)))
6846
internal_clear_bit(new_set,i);
6847
else
6848
{
6849
if (chr == 0 || !follow[bit_nr].chr)
6850
{ /* best match */
6851
new_set->table_offset=follow[bit_nr].table_offset;
6852
if (chr || (follow[i].chr == SPACE_CHAR ||
6853
follow[i].chr == END_OF_LINE))
6854
new_set->found_offset=found_end; /* New match */
6855
new_set->found_len=found_end;
6856
}
6857
bits_set++;
6858
}
6859
}
6860
if (bits_set == 1)
6861
{
6862
set->next[chr] = find_found(found_set,
6863
new_set->table_offset,
6864
new_set->found_offset);
6865
free_last_set(&sets);
6866
}
6867
else
6868
set->next[chr] = find_set(&sets,new_set);
6869
}
6870
else
6871
set->next[chr] = find_set(&sets,new_set);
6906
6872
}
6907
6873
}
6908
6874
}
6910
6876
/* Alloc replace structure for the replace-state-machine */
6911
6877
6912
6878
if ((replace=(REPLACE*) my_malloc(sizeof(REPLACE)*(sets.count)+
6913
sizeof(REPLACE_STRING)*(found_sets+1)+
6914
sizeof(char *)*count+result_len,
6915
MYF(MY_WME | MY_ZEROFILL))))
6879
sizeof(REPLACE_STRING)*(found_sets+1)+
6880
sizeof(char *)*count+result_len,
6881
MYF(MY_WME | MY_ZEROFILL))))
6916
6882
{
6917
6883
rep_str=(REPLACE_STRING*) (replace+sets.count);
6918
6884
to_array= (char **) (rep_str+found_sets+1);
6927
6893
for (i=1 ; i <= found_sets ; i++)
6928
6894
{
6929
6895
pos=from[found_set[i-1].table_offset];
6930
rep_str[i].found= !bcmp((const uchar*) pos,
6931
(const uchar*) "\\^", 3) ? 2 : 1;
6896
rep_str[i].found= !memcmp((const uchar*) pos,
6897
(const uchar*) "\\^", 3) ? 2 : 1;
6932
6898
rep_str[i].replace_string=to_array[found_set[i-1].table_offset];
6933
6899
rep_str[i].to_offset=found_set[i-1].found_offset-start_at_word(pos);
6934
6900
rep_str[i].from_offset=found_set[i-1].found_offset-replace_len(pos)+
6935
end_of_word(pos);
6901
end_of_word(pos);
6936
6902
}
6937
6903
for (i=0 ; i < sets.count ; i++)
6938
6904
{
6939
6905
for (j=0 ; j < 256 ; j++)
6940
if (sets.set[i].next[j] >= 0)
6941
replace[i].next[j]=replace+sets.set[i].next[j];
6942
else
6943
replace[i].next[j]=(REPLACE*) (rep_str+(-sets.set[i].next[j]-1));
6906
if (sets.set[i].next[j] >= 0)
6907
replace[i].next[j]=replace+sets.set[i].next[j];
6908
else
6909
replace[i].next[j]=(REPLACE*) (rep_str+(-sets.set[i].next[j]-1));
6944
6910
}
6945
6911
}
6946
6912
my_free(follow,MYF(0));
6952
6918
6953
6919
int init_sets(REP_SETS *sets,uint states)
6954
6920
{
6955
bzero((char*) sets,sizeof(*sets));
6921
memset((char*) sets, 0, sizeof(*sets));
6956
6922
sets->size_of_bits=((states+7)/8);
6957
6923
if (!(sets->set_buffer=(REP_SET*) my_malloc(sizeof(REP_SET)*SET_MALLOC_HUNC,
6958
MYF(MY_WME))))
6924
MYF(MY_WME))))
6959
6925
return 1;
6960
6926
if (!(sets->bit_buffer=(uint*) my_malloc(sizeof(uint)*sets->size_of_bits*
6961
SET_MALLOC_HUNC,MYF(MY_WME))))
6927
SET_MALLOC_HUNC,MYF(MY_WME))))
6962
6928
{
6963
6929
my_free(sets->set,MYF(0));
6964
6930
return 1;
6983
6949
{
6984
6950
sets->extra--;
6985
6951
set=sets->set+ sets->count++;
6986
bzero((char*) set->bits,sizeof(uint)*sets->size_of_bits);
6987
bzero((char*) &set->next[0],sizeof(set->next[0])*LAST_CHAR_CODE);
6952
memset((char*) set->bits, 0, sizeof(uint)*sets->size_of_bits);
6953
memset((char*) &set->next[0], 0, sizeof(set->next[0])*LAST_CHAR_CODE);
6988
6954
set->found_offset=0;
6989
6955
set->found_len=0;
6990
6956
set->table_offset= (uint) ~0;
6994
6960
count=sets->count+sets->invisible+SET_MALLOC_HUNC;
6995
6961
if (!(set=(REP_SET*) my_realloc((uchar*) sets->set_buffer,
6996
6962
sizeof(REP_SET)*count,
6997
MYF(MY_WME))))
6963
MYF(MY_WME))))
6998
6964
return 0;
6999
6965
sets->set_buffer=set;
7000
6966
sets->set=set+sets->invisible;
7001
6967
if (!(bit_buffer=(uint*) my_realloc((uchar*) sets->bit_buffer,
7002
(sizeof(uint)*sets->size_of_bits)*count,
7003
MYF(MY_WME))))
6968
(sizeof(uint)*sets->size_of_bits)*count,
6969
MYF(MY_WME))))
7004
6970
return 0;
7005
6971
sets->bit_buffer=bit_buffer;
7006
6972
for (i=0 ; i < count ; i++)
7050
7016
void copy_bits(REP_SET *to,REP_SET *from)
7051
7017
{
7052
7018
memcpy((uchar*) to->bits,(uchar*) from->bits,
7053
(size_t) (sizeof(uint) * to->size_of_bits));
7019
(size_t) (sizeof(uint) * to->size_of_bits));
7054
7020
}
7055
7021
7056
7022
int cmp_bits(REP_SET *set1,REP_SET *set2)
7057
7023
{
7058
return bcmp((uchar*) set1->bits,(uchar*) set2->bits,
7059
sizeof(uint) * set1->size_of_bits);
7024
return memcmp((uchar*) set1->bits,(uchar*) set2->bits,
7025
sizeof(uint) * set1->size_of_bits);
7060
7026
}
7061
7027
7062
7028
7098
7064
return i;
7099
7065
}
7100
7066
}
7101
return i; /* return new postion */
7067
return i; /* return new postion */
7102
7068
}
7103
7069
7104
7070
/* find if there is a found_set with same table_offset & found_offset
7113
7079
int i;
7114
7080
for (i=0 ; (uint) i < found_sets ; i++)
7115
7081
if (found_set[i].table_offset == table_offset &&
7116
found_set[i].found_offset == found_offset)
7082
found_set[i].found_offset == found_offset)
7117
7083
return -i-2;
7118
7084
found_set[i].table_offset=table_offset;
7119
7085
found_set[i].found_offset=found_offset;
7120
7086
found_sets++;
7121
return -i-2; /* return new postion */
7087
return -i-2; /* return new postion */
7122
7088
}
7123
7089
7124
7090
/* Return 1 if regexp starts with \b or ends with \b*/
7125
7091
7126
7092
uint start_at_word(char * pos)
7127
7093
{
7128
return (((!bcmp((const uchar*) pos, (const uchar*) "\\b",2) && pos[2]) ||
7129
!bcmp((const uchar*) pos, (const uchar*) "\\^", 2)) ? 1 : 0);
7094
return (((!memcmp((const uchar*) pos, (const uchar*) "\\b",2) && pos[2]) ||
7095
!memcmp((const uchar*) pos, (const uchar*) "\\^", 2)) ? 1 : 0);
7130
7096
}
7131
7097
7132
7098
uint end_of_word(char * pos)
7133
7099
{
7134
7100
char * end=strend(pos);
7135
return ((end > pos+2 && !bcmp((const uchar*) end-2,
7136
(const uchar*) "\\b", 2)) ||
7137
(end >= pos+2 && !bcmp((const uchar*) end-2,
7101
return ((end > pos+2 && !memcmp((const uchar*) end-2,
7102
(const uchar*) "\\b", 2)) ||
7103
(end >= pos+2 && !memcmp((const uchar*) end-2,
7138
7104
(const uchar*) "\\$",2))) ? 1 : 0;
7139
7105
}
7140
7106
7142
7108
* Handle replacement of strings
7143
7109
****************************************************************************/
7144
7110
7145
#define PC_MALLOC 256 /* Bytes for pointers */
7146
#define PS_MALLOC 512 /* Bytes for data */
7111
#define PC_MALLOC 256 /* Bytes for pointers */
7112
#define PS_MALLOC 512 /* Bytes for data */
7147
7113
7148
7114
int insert_pointer_name(POINTER_ARRAY *pa,char * name)
7149
7115
{
7155
7121
if (! pa->typelib.count)
7156
7122
{
7157
7123
if (!(pa->typelib.type_names=(const char **)
7158
my_malloc(((PC_MALLOC-MALLOC_OVERHEAD)/
7159
(sizeof(char *)+sizeof(*pa->flag))*
7160
(sizeof(char *)+sizeof(*pa->flag))),MYF(MY_WME))))
7124
my_malloc(((PC_MALLOC-MALLOC_OVERHEAD)/
7125
(sizeof(char *)+sizeof(*pa->flag))*
7126
(sizeof(char *)+sizeof(*pa->flag))),MYF(MY_WME))))
7161
7127
return(-1);
7162
7128
if (!(pa->str= (uchar*) my_malloc((uint) (PS_MALLOC-MALLOC_OVERHEAD),
7163
MYF(MY_WME))))
7129
MYF(MY_WME))))
7164
7130
{
7165
7131
my_free((char*) pa->typelib.type_names,MYF(0));
7166
7132
return (-1);
7167
7133
}
7168
7134
pa->max_count=(PC_MALLOC-MALLOC_OVERHEAD)/(sizeof(uchar*)+
7169
sizeof(*pa->flag));
7135
sizeof(*pa->flag));
7170
7136
pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
7171
7137
pa->length=0;
7172
7138
pa->max_length=PS_MALLOC-MALLOC_OVERHEAD;
7176
7142
if (pa->length+length >= pa->max_length)
7177
7143
{
7178
7144
if (!(new_pos= (uchar*) my_realloc((uchar*) pa->str,
7179
(uint) (pa->max_length+PS_MALLOC),
7180
MYF(MY_WME))))
7145
(uint) (pa->max_length+PS_MALLOC),
7146
MYF(MY_WME))))
7181
7147
return(1);
7182
7148
if (new_pos != pa->str)
7183
7149
{
7184
7150
my_ptrdiff_t diff=PTR_BYTE_DIFF(new_pos,pa->str);
7185
7151
for (i=0 ; i < pa->typelib.count ; i++)
7186
pa->typelib.type_names[i]= ADD_TO_PTR(pa->typelib.type_names[i],diff,
7187
char*);
7152
pa->typelib.type_names[i]= ADD_TO_PTR(pa->typelib.type_names[i],diff,
7153
char*);
7188
7154
pa->str=new_pos;
7189
7155
}
7190
7156
pa->max_length+=PS_MALLOC;
7195
7161
pa->array_allocs++;
7196
7162
len=(PC_MALLOC*pa->array_allocs - MALLOC_OVERHEAD);
7197
7163
if (!(new_array=(const char **) my_realloc((uchar*) pa->typelib.type_names,
7198
(uint) len/
7164
(uint) len/
7199
7165
(sizeof(uchar*)+sizeof(*pa->flag))*
7200
7166
(sizeof(uchar*)+sizeof(*pa->flag)),
7201
7167
MYF(MY_WME))))
7205
7171
pa->max_count=len/(sizeof(uchar*) + sizeof(*pa->flag));
7206
7172
pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
7207
7173
memcpy((uchar*) pa->flag,(char *) (pa->typelib.type_names+old_count),
7208
old_count*sizeof(*pa->flag));
7174
old_count*sizeof(*pa->flag));
7209
7175
}
7210
pa->flag[pa->typelib.count]=0; /* Reset flag */
7176
pa->flag[pa->typelib.count]=0; /* Reset flag */
7211
7177
pa->typelib.type_names[pa->typelib.count++]= (char*) pa->str+pa->length;
7212
pa->typelib.type_names[pa->typelib.count]= NullS; /* Put end-mark */
7178
pa->typelib.type_names[pa->typelib.count]= NullS; /* Put end-mark */
7213
7179
VOID(strmov((char*) pa->str+pa->length,name));
7214
7180
pa->length+=length;
7215
7181
return(0);
Loggerhead is a web-based interface for Breezy
Version: 2.0.1