summaryrefslogtreecommitdiffstats
path: root/sql-bench/crash-me.sh
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--sql-bench/crash-me.sh5036
1 files changed, 5036 insertions, 0 deletions
diff --git a/sql-bench/crash-me.sh b/sql-bench/crash-me.sh
new file mode 100644
index 00000000..26f66f94
--- /dev/null
+++ b/sql-bench/crash-me.sh
@@ -0,0 +1,5036 @@
+#!/usr/bin/env perl
+# -*- perl -*-
+# Copyright (c) 2000-2006 MySQL AB, 2009 Sun Microsystems, Inc.
+# Use is subject to license terms.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public
+# License as published by the Free Software Foundation; version 2
+# of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Library General Public License for more details.
+#
+# You should have received a copy of the GNU Library General Public
+# License along with this library; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+# MA 02110-1335 USA
+
+# Written by Monty for the TCX/Monty Program/Detron benchmark suite.
+# Empress and PostgreSQL patches by Luuk de Boer
+# Extensions for ANSI SQL and Mimer by Bengt Gunne
+# Some additions and corrections by Matthias Urlich
+#
+# This programs tries to find all limits for a sql server
+# It gets the name from what it does to most servers :)
+#
+# Be sure to use --help before running this!
+#
+# If you want to add support for another server, add a new package for the
+# server in server-cfg. You only have to support the 'new' and 'version'
+# functions. new doesn't need to have any limits if one doesn't want to
+# use the benchmarks.
+#
+
+# TODO:
+# CMT includes types and functions which are synonyms for other types
+# and functions, including those in SQL9x. It should label those synonyms
+# as such, and clarify ones such as "mediumint" with comments such as
+# "3-byte int" or "same as xxx".
+
+$version="1.62";
+
+use Cwd;
+use DBI;
+use Getopt::Long;
+use POSIX;
+$pwd = cwd(); $pwd = "." if ($pwd eq '');
+require "$pwd/server-cfg" || die "Can't read Configuration file: $!\n";
+
+$opt_server="mysql"; $opt_host="localhost"; $opt_database="test";
+$opt_dir="limits";
+$opt_user=$opt_password="";$opt_verbose=1;
+$opt_debug=$opt_help=$opt_Information=$opt_restart=$opt_force=$opt_quick=0;
+$opt_log_all_queries=$opt_fix_limit_file=$opt_batch_mode=$opt_version=0;
+$opt_db_start_cmd=""; # the db server start command
+$opt_check_server=0; # Check if server is alive before each query
+$opt_sleep=10; # time to sleep while starting the db server
+$limit_changed=0; # For configure file
+$reconnect_count=0;
+$opt_suffix="";
+$opt_comment=$opt_config_file=$opt_log_queries_to_file="";
+$limits{'crash_me_safe'}='yes';
+$prompts{'crash_me_safe'}='crash me safe';
+$limits{'operating_system'}= machine();
+$prompts{'operating_system'}='crash-me tested on';
+$retry_limit=3;
+
+GetOptions("Information","help","server=s","debug","user=s","password=s",
+"database=s","restart","force","quick","log-all-queries","comment=s",
+"host=s","fix-limit-file","dir=s","db-start-cmd=s","sleep=s","suffix=s",
+"batch-mode","config-file=s","log-queries-to-file=s","check-server",
+"version",
+"verbose!" => \$opt_verbose) || usage();
+usage() if ($opt_help || $opt_Information);
+version() && exit(0) if ($opt_version);
+
+$opt_suffix = '-'.$opt_suffix if (length($opt_suffix) != 0);
+$opt_config_file = "$pwd/$opt_dir/$opt_server$opt_suffix.cfg"
+ if (length($opt_config_file) == 0);
+$log_prefix=' ###'; # prefix for log lines in result file
+$safe_query_log='';
+$safe_query_result_log='';
+$log{"crash-me"}="";
+
+#!!!
+
+if ($opt_fix_limit_file)
+{
+ print "Fixing limit file for $opt_server\n";
+ read_config_data();
+ $limit_changed=1;
+ save_all_config_data();
+ exit 0;
+}
+
+$server=get_server($opt_server,$opt_host,$opt_database);
+$opt_server=$server->{'cmp_name'};
+
+$|=1; # For debugging
+
+print "Running $0 $version on '",($server_version=$server->version()),"'\n\n";
+print "I hope you didn't have anything important running on this server....\n";
+read_config_data();
+if ($limit_changed) # Must have been restarted
+{
+ save_config_data('crash_me_safe','no',"crash me safe");
+}
+
+if (!$opt_force && !$opt_batch_mode)
+{
+ server_info();
+}
+else
+{
+ print "Using --force. I assume you know what you are doing...\n";
+}
+print "\n";
+
+save_config_data('crash_me_version',$version,"crash me version");
+if ($server_version)
+{
+ save_config_data('server_version',$server_version,"server version");
+}
+if (length($opt_comment))
+{
+ save_config_data('user_comment',$opt_comment,"comment");
+}
+
+$opt_log=0;
+if (length($opt_log_queries_to_file))
+{
+ open(LOG,">$opt_log_queries_to_file") ||
+ die "Can't open file $opt_log_queries_to_file\n";
+ $opt_log=1;
+}
+
+#
+# Set up some limits that's regared as unlimited
+# We don't want to take up all resources from the server...
+#
+
+$max_connections="+1000"; # Number of simultaneous connections
+$max_buffer_size="+16000000"; # size of communication buffer.
+$max_string_size="+8000000"; # Enough for this test
+$max_name_length="+512"; # Actually 256, but ...
+$max_keys="+64"; # Probably too big.
+$max_join_tables="+64"; # Probably too big.
+$max_columns="+8192"; # Probably too big.
+$max_row_length=$max_string_size;
+$max_key_length="+8192"; # Big enough
+$max_order_by="+64"; # Big enough
+$max_expressions="+10000";
+$max_big_expressions="+100";
+$max_stacked_expressions="+2000";
+$query_size=$max_buffer_size;
+$longreadlen=16000000; # For retrieval buffer
+
+
+#
+# First do some checks that needed for the rest of the benchmark
+#
+use sigtrap; # Must be removed with perl5.005_2 on Win98
+$SIG{PIPE} = 'IGNORE';
+$problem_counter=0;
+$SIG{SEGV} = sub {
+ $problem_counter +=1;
+ if ($problem_counter >= 100) {
+ die("Too many problems, try to restart");
+ } else {
+ warn('SEGFAULT');
+ };
+};
+$dbh=safe_connect();
+
+#
+# Test if the database require RESTRICT/CASCADE after DROP TABLE
+#
+
+# Really remove the crash_me table
+$prompt="drop table require cascade/restrict";
+$drop_attr="";
+$dbh->do("drop table crash_me");
+$dbh->do("drop table crash_me cascade");
+if (!safe_query_l('drop_requires_cascade',
+ ["create table crash_me (a integer not null)",
+ "drop table crash_me"]))
+{
+ $dbh->do("drop table crash_me cascade");
+ if (safe_query_l('drop_requires_cascade',
+ ["create table crash_me (a integer not null)",
+ "drop table crash_me cascade"]))
+ {
+ save_config_data('drop_requires_cascade',"yes","$prompt");
+ $drop_attr="cascade";
+ }
+ else
+ {
+ die "Can't create and drop table 'crash_me'\n";
+ }
+}
+else
+{
+ save_config_data('drop_requires_cascade',"no","$prompt");
+ $drop_attr="";
+}
+
+# Remove tables from old runs
+$dbh->do("drop table crash_me $drop_attr");
+$dbh->do("drop table crash_me2 $drop_attr");
+$dbh->do("drop table crash_me3 $drop_attr");
+$dbh->do("drop table crash_q $drop_attr");
+$dbh->do("drop table crash_q1 $drop_attr");
+
+$prompt="Tables without primary key";
+if (!safe_query_l('no_primary_key',
+ ["create table crash_me (a integer not null,b char(10) not null)",
+ "insert into crash_me (a,b) values (1,'a')"]))
+{
+ if (!safe_query_l('no_primary_key',
+ ["create table crash_me (a integer not null,b char(10) not null".
+ ", primary key (a))",
+ "insert into crash_me (a,b) values (1,'a')"]))
+ {
+ die "Can't create table 'crash_me' with one record: $DBI::errstr\n";
+ }
+ save_config_data('no_primary_key',"no",$prompt);
+}
+else
+{
+ save_config_data('no_primary_key',"yes",$prompt);
+}
+
+#
+# Define strings for character NULL and numeric NULL used in expressions
+#
+$char_null=$server->{'char_null'};
+$numeric_null=$server->{'numeric_null'};
+if ($char_null eq '')
+{
+ $char_null="NULL";
+}
+if ($numeric_null eq '')
+{
+ $numeric_null="NULL";
+}
+
+print "$prompt: $limits{'no_primary_key'}\n";
+
+report("SELECT without FROM",'select_without_from',"select 1");
+if ($limits{'select_without_from'} ne "yes")
+{
+ $end_query=" from crash_me";
+ $check_connect="select a from crash_me";
+}
+else
+{
+ $end_query="";
+ $check_connect="select 1";
+}
+
+assert($check_connect);
+assert("select a from crash_me where b<'b'");
+
+report("Select constants",'select_constants',"select 1 $end_query");
+report("Select table_name.*",'table_wildcard',
+ "select crash_me.* from crash_me");
+report("Allows \' and \" as string markers",'quote_with_"',
+ 'select a from crash_me where b<"c"');
+check_and_report("Double '' as ' in strings",'double_quotes',[],
+ "select 'Walker''s' $end_query",[],"Walker's",1);
+check_and_report("Multiple line strings","multi_strings",[],
+ "select a from crash_me where b < 'a'\n'b'",[],"1",0);
+check_and_report("\" as identifier quote (ANSI SQL)",'quote_ident_with_"',[],
+ 'select "A" from crash_me',[],"1",0);
+check_and_report("\` as identifier quote",'quote_ident_with_`',[],
+ 'select `A` from crash_me',[],"1",0);
+check_and_report("[] as identifier quote",'quote_ident_with_[',[],
+ 'select [A] from crash_me',[],"1",0);
+report('Double "" in identifiers as "','quote_ident_with_dbl_"',
+ 'create table crash_me1 ("abc""d" integer)',
+ 'drop table crash_me1');
+
+report("Column alias","column_alias","select a as ab from crash_me");
+report("Table alias","table_alias","select b.a from crash_me as b");
+report("Functions",'functions',"select 1+1 $end_query");
+report("Group functions",'group_functions',"select count(*) from crash_me");
+report("Group functions with distinct",'group_distinct_functions',
+ "select count(distinct a) from crash_me");
+report("Group functions with several distinct",'group_many_distinct_functions',
+ "select count(distinct a), count(distinct b) from crash_me");
+report("Group by",'group_by',"select a from crash_me group by a");
+report("Group by position",'group_by_position',
+ "select a from crash_me group by 1");
+report("Group by alias",'group_by_alias',
+ "select a as ab from crash_me group by ab");
+report("Group on unused column",'group_on_unused',
+ "select count(*) from crash_me group by a");
+
+report("Order by",'order_by',"select a from crash_me order by a");
+report("Order by position",'order_by_position',
+ "select a from crash_me order by 1");
+report("Order by function","order_by_function",
+ "select a from crash_me order by a+1");
+report("Order by on unused column",'order_on_unused',
+ "select b from crash_me order by a");
+# little bit deprecated
+#check_and_report("Order by DESC is remembered",'order_by_remember_desc',
+# ["create table crash_q (s int,s1 int)",
+# "insert into crash_q values(1,1)",
+# "insert into crash_q values(3,1)",
+# "insert into crash_q values(2,1)"],
+# "select s,s1 from crash_q order by s1 DESC,s",
+# ["drop table crash_q $drop_attr"],[3,2,1],7,undef(),3);
+report("Compute",'compute',
+ "select a from crash_me order by a compute sum(a) by a");
+report("INSERT with Value lists",'insert_multi_value',
+ "create table crash_q (s char(10))",
+ "insert into crash_q values ('a'),('b')",
+ "drop table crash_q $drop_attr");
+report("INSERT with set syntax",'insert_with_set',
+ "create table crash_q (a integer)",
+ "insert into crash_q SET a=1",
+ "drop table crash_q $drop_attr");
+report("INSERT with DEFAULT","insert_with_default",
+ "create table crash_me_q (a int)",
+ "insert into crash_me_q (a) values (DEFAULT)",
+ "drop table crash_me_q $drop_attr");
+
+report("INSERT with empty value list","insert_with_empty_value_list",
+ "create table crash_me_q (a int)",
+ "insert into crash_me_q (a) values ()",
+ "drop table crash_me_q $drop_attr");
+
+report("INSERT DEFAULT VALUES","insert_default_values",
+ "create table crash_me_q (a int)",
+ "insert into crash_me_q DEFAULT VALUES",
+ "drop table crash_me_q $drop_attr");
+
+report("allows end ';'","end_colon", "select * from crash_me;");
+try_and_report("LIMIT number of rows","select_limit",
+ ["with LIMIT",
+ "select * from crash_me limit 1"],
+ ["with TOP",
+ "select TOP 1 * from crash_me"]);
+report("SELECT with LIMIT #,#","select_limit2",
+ "select * from crash_me limit 1,1");
+report("SELECT with LIMIT # OFFSET #",
+ "select_limit3", "select * from crash_me limit 1 offset 1");
+
+# The following alter table commands MUST be kept together!
+if ($dbh->do("create table crash_q (a integer, b integer,c1 CHAR(10))"))
+{
+ report("Alter table add column",'alter_add_col',
+ "alter table crash_q add d integer");
+ report_one("Alter table add many columns",'alter_add_multi_col',
+ [["alter table crash_q add (f integer,g integer)","yes"],
+ ["alter table crash_q add f integer, add g integer","with add"],
+ ["alter table crash_q add f integer,g integer","without add"]] );
+ report("Alter table change column",'alter_change_col',
+ "alter table crash_q change a e char(50)");
+
+ # informix can only change data type with modify
+ report_one("Alter table modify column",'alter_modify_col',
+ [["alter table crash_q modify c1 CHAR(20)","yes"],
+ ["alter table crash_q alter c1 CHAR(20)","with alter"]]);
+ report("Alter table alter column default",'alter_alter_col',
+ "alter table crash_q alter b set default 10");
+ report_one("Alter table drop column",'alter_drop_col',
+ [["alter table crash_q drop column b","yes"],
+ ["alter table crash_q drop column b restrict",
+ "with restrict/cascade"]]);
+ report("Alter table rename table",'alter_rename_table',
+ "alter table crash_q rename to crash_q1");
+}
+# Make sure both tables will be dropped, even if rename fails.
+$dbh->do("drop table crash_q1 $drop_attr");
+$dbh->do("drop table crash_q $drop_attr");
+
+report("rename table","rename_table",
+ "create table crash_q (a integer, b integer,c1 CHAR(10))",
+ "rename table crash_q to crash_q1",
+ "drop table crash_q1 $drop_attr");
+# Make sure both tables will be dropped, even if rename fails.
+$dbh->do("drop table crash_q1 $drop_attr");
+$dbh->do("drop table crash_q $drop_attr");
+
+report("truncate","truncate_table",
+ "create table crash_q (a integer, b integer,c1 CHAR(10))",
+ "truncate table crash_q",
+ "drop table crash_q $drop_attr");
+
+if ($dbh->do("create table crash_q (a integer, b integer,c1 CHAR(10))") &&
+ $dbh->do("create table crash_q1 (a integer, b integer,c1 CHAR(10) not null)"))
+{
+ report("Alter table add constraint",'alter_add_constraint',
+ "alter table crash_q add constraint c2 check(a > b)");
+ report_one("Alter table drop constraint",'alter_drop_constraint',
+ [["alter table crash_q drop constraint c2","yes"],
+ ["alter table crash_q drop constraint c2 restrict",
+ "with restrict/cascade"]]);
+ report("Alter table add unique",'alter_add_unique',
+ "alter table crash_q add constraint u1 unique(c1)");
+ try_and_report("Alter table drop unique",'alter_drop_unique',
+ ["with constraint",
+ "alter table crash_q drop constraint u1"],
+ ["with constraint and restrict/cascade",
+ "alter table crash_q drop constraint u1 restrict"],
+ ["with drop key",
+ "alter table crash_q drop key u1"]);
+ try_and_report("Alter table add primary key",'alter_add_primary_key',
+ ["with constraint",
+ "alter table crash_q1 add constraint p1 primary key(c1)"],
+ ["with add primary key",
+ "alter table crash_q1 add primary key(c1)"]);
+ report("Alter table add foreign key",'alter_add_foreign_key',
+ "alter table crash_q add constraint f1 foreign key(c1) references crash_q1(c1)");
+ try_and_report("Alter table drop foreign key",'alter_drop_foreign_key',
+ ["with drop constraint",
+ "alter table crash_q drop constraint f1"],
+ ["with drop constraint and restrict/cascade",
+ "alter table crash_q drop constraint f1 restrict"],
+ ["with drop foreign key",
+ "alter table crash_q drop foreign key f1"]);
+ try_and_report("Alter table drop primary key",'alter_drop_primary_key',
+ ["drop constraint",
+ "alter table crash_q1 drop constraint p1 restrict"],
+ ["drop primary key",
+ "alter table crash_q1 drop primary key"]);
+}
+$dbh->do("drop table crash_q $drop_attr");
+$dbh->do("drop table crash_q1 $drop_attr");
+
+check_and_report("Case insensitive compare","case_insensitive_strings",
+ [],"select b from crash_me where b = 'A'",[],'a',1);
+check_and_report("Ignore end space in compare","ignore_end_space",
+ [],"select b from crash_me where b = 'a '",[],'a',1);
+check_and_report("Group on column with null values",'group_by_null',
+ ["create table crash_q (s char(10))",
+ "insert into crash_q values(null)",
+ "insert into crash_q values(null)"],
+ "select count(*),s from crash_q group by s",
+ ["drop table crash_q $drop_attr"],2,0);
+
+$prompt="Having";
+if (!defined($limits{'having'}))
+{ # Complicated because of postgreSQL
+ if (!safe_query_result_l("having",
+ "select a from crash_me group by a having a > 0",1,0))
+ {
+ if (!safe_query_result_l("having",
+ "select a from crash_me group by a having a < 0",
+ 1,0))
+ { save_config_data("having","error",$prompt); }
+ else
+ { save_config_data("having","yes",$prompt); }
+ }
+ else
+ { save_config_data("having","no",$prompt); }
+}
+print "$prompt: $limits{'having'}\n";
+
+if ($limits{'having'} eq 'yes')
+{
+ report("Having with group function","having_with_group",
+ "select a from crash_me group by a having count(*) = 1");
+}
+
+if ($limits{'column_alias'} eq 'yes')
+{
+ report("Order by alias",'order_by_alias',
+ "select a as ab from crash_me order by ab");
+ if ($limits{'having'} eq 'yes')
+ {
+ report("Having on alias","having_with_alias",
+ "select a as ab from crash_me group by a having ab > 0");
+ }
+}
+report("binary numbers (0b1001)","binary_numbers","select 0b1001 $end_query");
+report("hex numbers (0x41)","hex_numbers","select 0x41 $end_query");
+report("binary strings (b'0110')","binary_strings","select b'0110' $end_query");
+report("hex strings (x'1ace')","hex_strings","select x'1ace' $end_query");
+
+report_result("Value of logical operation (1=1)","logical_value",
+ "select (1=1) $end_query");
+
+report_result("Value of TRUE","value_of_true","select TRUE $end_query");
+report_result("Value of FALSE","value_of_false","select FALSE $end_query");
+
+$logical_value= $limits{'logical_value'};
+
+$false=0;
+$result="no";
+if ($res=safe_query_l('has_true_false',"select (1=1)=true $end_query")) {
+ $false="false";
+ $result="yes";
+}
+save_config_data('has_true_false',$result,"TRUE and FALSE");
+
+#
+# Check how many connections the server can handle:
+# We can't test unlimited connections, because this may take down the
+# server...
+#
+
+$prompt="Simultaneous connections (installation default)";
+print "$prompt: ";
+if (defined($limits{'connections'}))
+{
+ print "$limits{'connections'}\n";
+}
+else
+{
+ @connect=($dbh);
+
+ for ($i=1; $i < $max_connections ; $i++)
+ {
+ if (!($dbh=DBI->connect($server->{'data_source'},$opt_user,$opt_password,
+ { PrintError => 0})))
+ {
+ print "Last connect error: $DBI::errstr\n" if ($opt_debug);
+ last;
+ }
+ $dbh->{LongReadLen}= $longreadlen; # Set retrieval buffer
+ print "." if ($opt_debug);
+ push(@connect,$dbh);
+ }
+ print "$i\n";
+ save_config_data('connections',$i,$prompt);
+ foreach $dbh (@connect)
+ {
+ print "#" if ($opt_debug);
+ $dbh->disconnect || warn $dbh->errstr; # close connection
+ }
+
+ $#connect=-1; # Free connections
+
+ if ($i == 0)
+ {
+ print "Can't connect to server: $DBI::errstr.".
+ " Please start it and try again\n";
+ exit 1;
+ }
+ $dbh=retry_connect();
+}
+
+
+#
+# Check size of communication buffer, strings...
+#
+
+$prompt="query size";
+print "$prompt: ";
+if (!defined($limits{'query_size'}))
+{
+ $query="select ";
+ $first=64;
+ $end=$max_buffer_size;
+ $select= $limits{'select_without_from'} eq 'yes' ? 1 : 'a';
+
+ assert($query . "$select$end_query");
+
+ $first=$limits{'restart'}{'low'} if ($limits{'restart'}{'low'});
+
+ if ($limits{'restart'}{'tohigh'})
+ {
+ $end = $limits{'restart'}{'tohigh'} - 1;
+ print "\nRestarting this with low limit: $first and high limit: $end\n";
+ delete $limits{'restart'};
+ $first=$first+int(($end-$first+4)/5); # Prefere lower on errors
+ }
+ for ($i=$first ; $i < $end ; $i*=2)
+ {
+ last if (!safe_query($query .
+ (" " x ($i - length($query)-length($end_query) -1))
+ . "$select$end_query"));
+ $first=$i;
+ save_config_data("restart",$i,"") if ($opt_restart);
+ }
+ $end=$i;
+
+ if ($i < $max_buffer_size)
+ {
+ while ($first != $end)
+ {
+ $i=int(($first+$end+1)/2);
+ if (safe_query($query .
+ (" " x ($i - length($query)-length($end_query) -1)) .
+ "$select$end_query"))
+ {
+ $first=$i;
+ }
+ else
+ {
+ $end=$i-1;
+ }
+ }
+ }
+ save_config_data('query_size',$end,$prompt);
+}
+$query_size=$limits{'query_size'};
+
+print "$limits{'query_size'}\n";
+
+#
+# Check for reserved words
+#
+
+check_reserved_words($dbh);
+
+#
+# Test database types
+#
+
+@sql_types=("character(1)","char(1)","char varying(1)", "character varying(1)",
+ "boolean",
+ "varchar(1)",
+ "integer","int","smallint",
+ "numeric(9,2)","decimal(6,2)","dec(6,2)",
+ "bit", "bit(2)","bit varying(2)","float","float(8)","real",
+ "double precision", "date","time","timestamp",
+ "time(6)", "timestamp(6)",
+ "datetime", "datetime(6)",
+ "interval year", "interval year to month",
+ "interval month",
+ "interval day", "interval day to hour", "interval day to minute",
+ "interval day to second",
+ "interval hour", "interval hour to minute",
+ "interval hour to second",
+ "interval minute", "interval minute to second",
+ "interval second",
+ "national character varying(20)",
+ "national character(20)","nchar(1)",
+ "national char varying(20)","nchar varying(20)",
+ "national character varying(20)",
+ "timestamp with time zone");
+@odbc_types=("binary(1)","varbinary(1)","tinyint","bigint");
+@extra_types=("blob","byte","long varbinary","image","text","text(10)",
+ "mediumtext",
+ "long varchar(1)", "varchar2(257)",
+ "mediumint","middleint","int unsigned",
+ "int1","int2","int3","int4","int8","uint",
+ "money","smallmoney","float4","float8","smallfloat",
+ "float(6,2)","double",
+ "enum('red')","set('red')", "int(5) zerofill", "serial",
+ "char(10) binary","int not null auto_increment,unique(q)",
+ "abstime","year","datetime","smalldatetime","timespan","reltime",
+ # Sybase types
+ "int not null identity,unique(q)",
+ # postgres types
+ "box","bool","circle","polygon","point","line","lseg","path",
+ "interval", "inet", "cidr", "macaddr",
+
+ # oracle types
+ "varchar2(16)","nvarchar2(16)","number(9,2)","number(9)",
+ "number", "long","raw(16)","long raw","rowid","mlslabel","clob",
+ "nclob","bfile"
+ );
+
+@types=(["sql",\@sql_types],
+ ["odbc",\@odbc_types],
+ ["extra",\@extra_types]);
+
+foreach $types (@types)
+{
+ print "\nSupported $types->[0] types\n";
+ $tmp= $types->[1];
+ foreach $use_type (@$tmp)
+ {
+ $type=$use_type;
+ $type =~ s/\(.*\)/(1 arg)/;
+ if (index($use_type,",")>= 0)
+ {
+ $type =~ s/\(1 arg\)/(2 arg)/;
+ }
+ if (($tmp2=index($type,",unique")) >= 0)
+ {
+ $type=substr($type,0,$tmp2);
+ }
+ $tmp2=$type;
+ $tmp2 =~ s/ /_/g;
+ $tmp2 =~ s/_not_null//g;
+ report("Type $type","type_$types->[0]_$tmp2",
+ "create table crash_q (q $use_type)",
+ "drop table crash_q $drop_attr");
+ }
+}
+
+#
+# Test some type limits
+#
+
+
+check_and_report("Remembers end space in char()","remember_end_space",
+ ["create table crash_q (a char(10))",
+ "insert into crash_q values('hello ')"],
+ "select a from crash_q where a = 'hello '",
+ ["drop table crash_q $drop_attr"],
+ 'hello ',6);
+
+check_and_report("Remembers end space in varchar()",
+ "remember_end_space_varchar",
+ ["create table crash_q (a varchar(10))",
+ "insert into crash_q values('hello ')"],
+ "select a from crash_q where a = 'hello '",
+ ["drop table crash_q $drop_attr"],
+ 'hello ',6);
+
+if (($limits{'type_extra_float(2_arg)'} eq "yes" ||
+ $limits{'type_sql_decimal(2_arg)'} eq "yes") &&
+ (!defined($limits{'storage_of_float'})))
+{
+ my $type=$limits{'type_extra_float(2_arg)'} eq "yes" ? "float(4,1)" :
+ "decimal(4,1)";
+ my $result="undefined";
+ if (execute_and_check("storage_of_float",["create table crash_q (q1 $type)",
+ "insert into crash_q values(1.14)"],
+ "select q1 from crash_q",
+ ["drop table crash_q $drop_attr"],1.1,0) &&
+ execute_and_check("storage_of_float",["create table crash_q (q1 $type)",
+ "insert into crash_q values(1.16)"],
+ "select q1 from crash_q",
+ ["drop table crash_q $drop_attr"],1.1,0))
+ {
+ $result="truncate";
+ }
+ elsif (execute_and_check("storage_of_float",["create table crash_q (q1 $type)",
+ "insert into crash_q values(1.14)"],
+ "select q1 from crash_q",
+ ["drop table crash_q $drop_attr"],1.1,0) &&
+ execute_and_check("storage_of_float",["create table crash_q (q1 $type)",
+ "insert into crash_q values(1.16)"],
+ "select q1 from crash_q",
+ ["drop table crash_q $drop_attr"],1.2,0))
+ {
+ $result="round";
+ }
+ elsif (execute_and_check("storage_of_float",["create table crash_q (q1 $type)",
+ "insert into crash_q values(1.14)"],
+ "select q1 from crash_q",
+ ["drop table crash_q $drop_attr"],1.14,0) &&
+ execute_and_check("storage_of_float",["create table crash_q (q1 $type)",
+ "insert into crash_q values(1.16)"],
+ "select q1 from crash_q",
+ ["drop table crash_q $drop_attr"],1.16,0))
+ {
+ $result="exact";
+ }
+ $prompt="Storage of float values";
+ save_config_data("storage_of_float", $result, $prompt);
+}
+
+if (defined($limits{'storage_of_float'}))
+{
+ print "Storage of float values: $limits{'storage_of_float'}\n";
+}
+
+try_and_report("Type for row id", "rowid",
+ ["rowid",
+ "create table crash_q (a rowid)",
+ "drop table crash_q $drop_attr"],
+ ["auto_increment",
+ "create table crash_q (a int not null auto_increment".
+ ", primary key(a))","drop table crash_q $drop_attr"],
+ ["oid",
+ "create table crash_q (a oid, primary key(a))",
+ "drop table crash_q $drop_attr"],
+ ["serial",
+ "create table crash_q (a serial, primary key(a))",
+ "drop table crash_q $drop_attr"]);
+
+try_and_report("Automatic row id", "automatic_rowid",
+ ["_rowid",
+ "create table crash_q (a int not null, primary key(a))",
+ "insert into crash_q values (1)",
+ "select _rowid from crash_q",
+ "drop table crash_q $drop_attr"]);
+
+#
+# Test functions
+#
+
+@sql_functions=
+ (["+, -, * and /","+","5*3-4/2+1",14,0],
+ ["ANSI SQL SUBSTRING","substring","substring('abcd' from 2 for 2)","bc",1],
+ ["BIT_LENGTH","bit_length","bit_length('abc')",24,0],
+ ["searched CASE","searched_case",
+ "case when 1 > 2 then 'false' when 2 > 1 then 'true' end", "true",1],
+ ["simple CASE","simple_case",
+ "case 2 when 1 then 'false' when 2 then 'true' end", "true",1],
+ ["CAST","cast","CAST(1 as CHAR)","1",1],
+ ["CHARACTER_LENGTH","character_length","character_length('abcd')","4",0],
+ ["CHAR_LENGTH","char_length","char_length(b)","10",0],
+ ["CHAR_LENGTH(constant)","char_length(constant)",
+ "char_length('abcd')","4",0],
+ ["COALESCE","coalesce","coalesce($char_null,'bcd','qwe')","bcd",1],
+ ["CURRENT_DATE","current_date","current_date",0,2],
+ ["CURRENT_TIME","current_time","current_time",0,2],
+ ["CURRENT_TIMESTAMP","current_timestamp","current_timestamp",0,2],
+ ["EXTRACT","extract_sql",
+ "extract(minute from timestamp '2000-02-23 18:43:12.987')",43,0],
+ ["LOCALTIME","localtime","localtime",0,2],
+ ["LOCALTIMESTAMP","localtimestamp","localtimestamp",0,2],
+ ["LOWER","lower","LOWER('ABC')","abc",1],
+ ["NULLIF with strings","nullif_string",
+ "NULLIF(NULLIF('first','second'),'first')",undef(),4],
+ ["NULLIF with numbers","nullif_num","NULLIF(NULLIF(1,2),1)",undef(),4],
+ ["OCTET_LENGTH","octet_length","octet_length('abc')",3,0],
+ ["POSITION","position","position('ll' in 'hello')",3,0],
+ ["TRIM","trim","trim(trailing from trim(LEADING FROM ' abc '))","abc",3],
+ ["UPPER","upper","UPPER('abc')","ABC",1],
+ ["concatenation with ||","concat_as_||","'abc' || 'def'","abcdef",1],
+ );
+
+@odbc_functions=
+ (["ASCII", "ascii", "ASCII('A')","65",0],
+ ["CHAR", "char", "CHAR(65)" ,"A",1],
+ ["CONCAT(2 arg)","concat", "concat('a','b')","ab",1],
+ ["DIFFERENCE()","difference","difference('abc','abe')",3,0],
+ ["INSERT","insert","insert('abcd',2,2,'ef')","aefd",1],
+ ["LEFT","left","left('abcd',2)","ab",1],
+ ["LTRIM","ltrim","ltrim(' abcd')","abcd",1],
+ ["REAL LENGTH","length","length('abcd ')","5",0],
+ ["ODBC LENGTH","length_without_space","length('abcd ')","4",0],
+ ["LOCATE(2 arg)","locate_2","locate('bcd','abcd')","2",0],
+ ["LOCATE(3 arg)","locate_3","locate('bcd','abcd',3)","0",0],
+ ["LCASE","lcase","lcase('ABC')","abc",1],
+ ["REPEAT","repeat","repeat('ab',3)","ababab",1],
+ ["REPLACE","replace","replace('abbaab','ab','ba')","bababa",1],
+ ["RIGHT","right","right('abcd',2)","cd",1],
+ ["RTRIM","rtrim","rtrim(' abcd ')"," abcd",1],
+ ["SPACE","space","space(5)"," ",3],
+ ["SOUNDEX","soundex","soundex('hello')",0,2],
+ ["ODBC SUBSTRING","substring","substring('abcd',3,2)","cd",1],
+ ["UCASE","ucase","ucase('abc')","ABC",1],
+
+ ["ABS","abs","abs(-5)",5,0],
+ ["ACOS","acos","acos(0)","1.570796",0],
+ ["ASIN","asin","asin(1)","1.570796",0],
+ ["ATAN","atan","atan(1)","0.785398",0],
+ ["ATAN2","atan2","atan2(1,0)","1.570796",0],
+ ["CEILING","ceiling","ceiling(-4.5)",-4,0],
+ ["COS","cos","cos(0)","1.00000",0],
+ ["COT","cot","cot(1)","0.64209262",0],
+ ["DEGREES","degrees","degrees(6.283185)","360",0],
+ ["EXP","exp","exp(1.0)","2.718282",0],
+ ["FLOOR","floor","floor(2.5)","2",0],
+ ["LOG","log","log(2)","0.693147",0],
+ ["LOG10","log10","log10(10)","1",0],
+ ["MOD","mod","mod(11,7)","4",0],
+ ["PI","pi","pi()","3.141593",0],
+ ["POWER","power","power(2,4)","16",0],
+ ["RAND","rand","rand(1)",0,2], # Any value is acceptable
+ ["RADIANS","radians","radians(360)","6.283185",0],
+ ["ROUND(2 arg)","round","round(5.63,2)","5.6",0],
+ ["SIGN","sign","sign(-5)",-1,0],
+ ["SIN","sin","sin(1)","0.841471",0],
+ ["SQRT","sqrt","sqrt(4)",2,0],
+ ["TAN","tan","tan(1)","1.557408",0],
+ ["TRUNCATE","truncate","truncate(18.18,-1)",10,0],
+ ["NOW","now","now()",0,2], # Any value is acceptable
+ ["CURDATE","curdate","curdate()",0,2],
+ ["CURTIME","curtime","curtime()",0,2],
+ ["TIMESTAMPADD","timestampadd",
+ "timestampadd(SQL_TSI_SECOND,1,'1997-01-01 00:00:00')",
+ "1997-01-01 00:00:01",1],
+ ["TIMESTAMPDIFF","timestampdiff",
+ "timestampdiff(SQL_TSI_SECOND,'1997-01-01 00:00:02',".
+ " '1997-01-01 00:00:01')","1",0],
+ ["USER()","user()","user()",0,2],
+ ["DATABASE","database","database()",0,2],
+ ["IFNULL","ifnull","ifnull(2,3)",2,0],
+ ["ODBC syntax LEFT & RIGHT", "fn_left",
+ "{ fn LEFT( { fn RIGHT('abcd',2) },1) }","c",1],
+ );
+
+@extra_functions=
+ (
+ ["& (bitwise and)",'&',"5 & 3",1,0],
+ ["| (bitwise or)",'|',"1 | 2",3,0],
+ ["<< and >> (bitwise shifts)",'binary_shifts',"(1 << 4) >> 2",4,0],
+ ["<> in SELECT","<>","1<>1","0",0],
+ ["=","=","(1=1)",1,$logical_value],
+ ["~* (case insensitive compare)","~*","'hi' ~* 'HI'",1,$logical_value],
+ ["AND and OR in SELECT","and_or","1=1 AND 2=2",$logical_value,0],
+ ["AND as '&&'",'&&',"1=1 && 2=2",$logical_value,0],
+ ["ASCII_CHAR", "ascii_char", "ASCII_CHAR(65)","A",1],
+ ["ASCII_CODE", "ascii_code", "ASCII_CODE('A')","65",0],
+ ["ATN2","atn2","atn2(1,0)","1.570796",0],
+ ["BETWEEN in SELECT","between","5 between 4 and 6",$logical_value,0],
+ ["BIT_COUNT","bit_count","bit_count(5)",2,0],
+ ["CEIL","ceil","ceil(-4.5)",-4,0], # oracle
+ ["CHARINDEX","charindex","charindex('a','crash')",3,0],
+ ["CHR", "chr", "CHR(65)" ,"A",1], # oracle
+ ["CONCAT(list)","concat_list", "concat('a','b','c','d')","abcd",1],
+ ["CONVERT","convert","convert(CHAR,5)","5",1],
+ ["COSH","cosh","cosh(0)","1",0], # oracle hyperbolic cosine of n.
+ ["ELT","elt","elt(2,'ONE','TWO','THREE')","TWO",1],
+ ["ENCRYPT","encrypt","encrypt('hello')",0,2],
+ ["FIELD","field","field('IBM','NCA','ICL','SUN','IBM','DIGITAL')",4,0],
+ ["FORMAT","format","format(1234.5555,2)","1,234.56",1],
+ ["GETDATE","getdate","getdate()",0,2],
+ ["GREATEST","greatest","greatest('HARRY','HARRIOT','HAROLD')","HARRY",1],
+ ["IF","if", "if(5,6,7)",6,0],
+ ["IN on numbers in SELECT","in_num","2 in (3,2,5,9,5,1)",$logical_value,0],
+ ["IN on strings in SELECT","in_str","'monty' in ('david','monty','allan')", $logical_value,0],
+ ["INITCAP","initcap","initcap('the soap')","The Soap",1],
+ # oracle Returns char, with the first letter of each word in uppercase
+ ["INSTR (Oracle syntax)", "instr_oracle", "INSTR('CORPORATE FLOOR','OR',3,2)" ,"14",0], # oracle instring
+ ["INSTRB", "instrb", "INSTRB('CORPORATE FLOOR','OR',5,2)" ,"27",0],
+ # oracle instring in bytes
+ ["INTERVAL","interval","interval(55,10,20,30,40,50,60,70,80,90,100)",5,0],
+ ["LAST_INSERT_ID","last_insert_id","last_insert_id()",0,2],
+ ["LEAST","least","least('HARRY','HARRIOT','HAROLD')","HAROLD",1],
+ # oracle
+ ["LENGTHB","lengthb","lengthb('CANDIDE')","14",0],
+ # oracle length in bytes
+ ["LIKE ESCAPE in SELECT","like_escape",
+ "'%' like 'a%' escape 'a'",$logical_value,0],
+ ["LIKE in SELECT","like","'a' like 'a%'",$logical_value,0],
+ ["LN","ln","ln(95)","4.55387689",0],
+ # oracle natural logarithm of n
+ ["LOCATE as INSTR","instr","instr('hello','ll')",3,0],
+ ["LOG(m,n)","log(m_n)","log(10,100)","2",0],
+ # oracle logarithm, base m, of n
+ ["LOGN","logn","logn(2)","0.693147",0],
+ # informix
+ ["LPAD","lpad","lpad('hi',4,'??')",'??hi',3],
+ ["MOD as %","%","10%7","3",0],
+ ["NOT BETWEEN in SELECT","not_between","5 not between 4 and 6",0,0],
+ ["NOT LIKE in SELECT","not_like","'a' not like 'a%'",0,0],
+ ["NOT as '!' in SELECT","!","! 1",0,0],
+ ["NOT in SELECT","not","not $false",$logical_value,0],
+ ["ODBC CONVERT","odbc_convert","convert(5,SQL_CHAR)","5",1],
+ ["OR as '||'",'||',"1=0 || 1=1",$logical_value,0],
+ ["PASSWORD","password","password('hello')",0,2],
+ ["PASTE", "paste", "paste('ABCDEFG',3,2,'1234')","AB1234EFG",1],
+ ["PATINDEX","patindex","patindex('%a%','crash')",3,0],
+ ["POW","pow","pow(3,2)",9,0],
+ ["RANGE","range","range(a)","0.0",0],
+ # informix range(a) = max(a) - min(a)
+ ["REGEXP in SELECT","regexp","'a' regexp '^(a|b)*\$'",$logical_value,0],
+ ["REPLICATE","replicate","replicate('a',5)","aaaaa",1],
+ ["REVERSE","reverse","reverse('abcd')","dcba",1],
+ ["ROOT","root","root(4)",2,0], # informix
+ ["ROUND(1 arg)","round1","round(5.63)","6",0],
+ ["RPAD","rpad","rpad('hi',4,'??')",'hi??',3],
+ ["SINH","sinh","sinh(1)","1.17520119",0], # oracle hyperbolic sine of n
+ ["STR","str","str(123.45,5,1)",123.5,3],
+ ["STRCMP","strcmp","strcmp('abc','adc')",-1,0],
+ ["STUFF","stuff","stuff('abc',2,3,'xyz')",'axyz',3],
+ ["SUBSTRB", "substrb", "SUBSTRB('ABCDEFG',5,4.2)" ,"CD",1],
+ # oracle substring with bytes
+ ["SUBSTRING as MID","mid","mid('hello',3,2)","ll",1],
+ ["SUBSTRING_INDEX","substring_index",
+ "substring_index('www.tcx.se','.',-2)", "tcx.se",1],
+ ["SYSDATE","sysdate","sysdate()",0,2],
+ ["TAIL","tail","tail('ABCDEFG',3)","EFG",0],
+ ["TANH","tanh","tanh(1)","0.462117157",0],
+ # oracle hyperbolic tangent of n
+ ["TRANSLATE","translate","translate('abc','bc','de')",'ade',3],
+ ["TRIM; Many char extension",
+ "trim_many_char","trim(':!' FROM ':abc!')","abc",3],
+ ["TRIM; Substring extension",
+ "trim_substring","trim('cb' FROM 'abccb')","abc",3],
+ ["TRUNC","trunc","trunc(18.18,-1)",10,0], # oracle
+ ["UID","uid","uid",0,2], # oracle uid from user
+ ["UNIX_TIMESTAMP","unix_timestamp","unix_timestamp()",0,2],
+ ["USERENV","userenv","userenv",0,2], # oracle user enviroment
+ ["VERSION","version","version()",0,2],
+ ["automatic num->string convert","auto_num2string","concat('a',2)","a2",1],
+ ["automatic string->num convert","auto_string2num","'1'+2",3,0],
+ ["concatenation with +","concat_as_+","'abc' + 'def'","abcdef",1],
+ ["SUBSTR (2 arg)",'substr2arg',"substr('abcd',2)",'bcd',1], #sapdb func
+ ["SUBSTR (3 arg)",'substr3arg',"substr('abcd',2,2)",'bc',1],
+ ["LFILL (3 arg)",'lfill3arg',"lfill('abcd','.',6)",'..abcd',1],
+ ["RFILL (3 arg)",'rfill3arg',"rfill('abcd','.',6)",'abcd..',1],
+ ["RPAD (4 arg)",'rpad4arg',"rpad('abcd',2,'+-',8)",'abcd+-+-',1],
+ ["LPAD (4 arg)",'rpad4arg',"lpad('abcd',2,'+-',8)",'+-+-abcd',1],
+ ["TRIM (1 arg)",'trim1arg',"trim(' abcd ')",'abcd',1],
+ ["TRIM (2 arg)",'trim2arg',"trim('..abcd..','.')",'abcd',1],
+ ["LTRIM (2 arg)",'ltrim2arg',"ltrim('..abcd..','.')",'abcd..',1],
+ ["RTRIM (2 arg)",'rtrim2arg',"rtrim('..abcd..','.')",'..abcd',1],
+ ["EXPAND",'expand2arg',"expand('abcd',6)",'abcd ',0],
+ ["REPLACE (2 arg) ",'replace2arg',"replace('AbCd','bC')",'Ad',1],
+ ["MAPCHAR",'mapchar',"mapchar('Aâ')",'Aa',1],
+ ["ALPHA",'alpha',"alpha('Aâ',2)",'AA',1],
+ ["ASCII in string cast",'ascii_string',"ascii('a')",'a',1],
+ ["EBCDIC in string cast",'ebcdic_string',"ebcdic('a')",'a',1],
+ ["TRUNC (1 arg)",'trunc1arg',"trunc(222.6)",222,0],
+ ["FIXED",'fixed',"fixed(222.6666,10,2)",'222.67',0],
+ ["FLOAT",'float',"float(6666.66,4)",6667,0],
+ ["LENGTH",'length',"length(1)",2,0],
+ ["INDEX",'index',"index('abcdefg','cd',1,1)",3,0],
+ ["MICROSECOND",'microsecond',
+ "MICROSECOND('19630816200212111111')",'111111',0],
+ ["TIMESTAMP",'timestamp',
+ "timestamp('19630816','00200212')",'19630816200212000000',0],
+ ["VALUE",'value',"value(NULL,'WALRUS')",'WALRUS',0],
+ ["DECODE",'decode',"DECODE('S-103','T72',1,'S-103',2,'Leopard',3)",2,0],
+ ["NUM",'num',"NUM('2123')",2123,0],
+ ["CHR (any type to string)",'chr_str',"CHR(67)",'67',0],
+ ["HEX",'hex',"HEX('A')",41,0],
+ );
+
+
+@sql_group_functions=
+ (
+ ["AVG","avg","avg(a)",1,0],
+ ["COUNT (*)","count_*","count(*)",1,0],
+ ["COUNT column name","count_column","count(a)",1,0],
+ ["COUNT(DISTINCT expr)","count_distinct","count(distinct a)",1,0],
+ ["MAX on numbers","max","max(a)",1,0],
+ ["MAX on strings","max_str","max(b)","a",1],
+ ["MIN on numbers","min","min(a)",1,0],
+ ["MIN on strings","min_str","min(b)","a",1],
+ ["SUM","sum","sum(a)",1,0],
+ ["ANY","any","any(a)",$logical_value,0],
+ ["EVERY","every","every(a)",$logical_value,0],
+ ["SOME","some","some(a)",$logical_value,0],
+ );
+
+@extra_group_functions=
+ (
+ ["BIT_AND",'bit_and',"bit_and(a)",1,0],
+ ["BIT_OR", 'bit_or', "bit_or(a)",1,0],
+ ["COUNT(DISTINCT expr,expr,...)",
+ "count_distinct_list","count(distinct a,b)",1,0],
+ ["STD","std","std(a)",0,0],
+ ["STDDEV","stddev","stddev(a)",0,0],
+ ["VARIANCE","variance","variance(a)",0,0],
+ );
+
+@where_functions=
+(
+ ["= ALL","eq_all","b =all (select b from crash_me)",1,0],
+ ["= ANY","eq_any","b =any (select b from crash_me)",1,0],
+ ["= SOME","eq_some","b =some (select b from crash_me)",1,0],
+ ["BETWEEN","between","5 between 4 and 6",1,0],
+ ["EXISTS","exists","exists (select * from crash_me)",1,0],
+ ["IN on numbers","in_num","2 in (3,2,5,9,5,1)",1,0],
+ ["LIKE ESCAPE","like_escape","b like '%' escape 'a'",1,0],
+ ["LIKE","like","b like 'a%'",1,0],
+ ["MATCH UNIQUE","match_unique",
+ "1 match unique (select a from crash_me)",1,0],
+ ["MATCH","match","1 match (select a from crash_me)",1,0],
+ ["MATCHES","matches","b matches 'a*'",1,0],
+ ["NOT BETWEEN","not_between","7 not between 4 and 6",1,0],
+ ["NOT EXISTS","not_exists",
+ "not exists (select * from crash_me where a = 2)",1,0],
+ ["NOT LIKE","not_like","b not like 'b%'",1,0],
+ ["NOT UNIQUE","not_unique",
+ "not unique (select * from crash_me where a = 2)",1,0],
+ ["UNIQUE","unique","unique (select * from crash_me)",1,0],
+ );
+
+@types=(["sql",\@sql_functions,0],
+ ["odbc",\@odbc_functions,0],
+ ["extra",\@extra_functions,0],
+ ["where",\@where_functions,0]);
+
+@group_types=(["sql",\@sql_group_functions,0],
+ ["extra",\@extra_group_functions,0]);
+
+
+foreach $types (@types)
+{
+ print "\nSupported $types->[0] functions\n";
+ $tmp= $types->[1];
+ foreach $type (@$tmp)
+ {
+ if (defined($limits{"func_$types->[0]_$type->[1]"}))
+ {
+ next;
+ }
+ if ($types->[0] eq "where")
+ {
+ check_and_report("Function $type->[0]","func_$types->[0]_$type->[1]",
+ [],"select a from crash_me where $type->[2]",[],
+ $type->[3],$type->[4]);
+ }
+ elsif ($limits{'functions'} eq 'yes')
+ {
+ if (($type->[2] =~ /char_length\(b\)/) && (!$end_query))
+ {
+ my $tmp= $type->[2];
+ $tmp .= " from crash_me ";
+ undef($limits{"func_$types->[0]_$type->[1]"});
+ check_and_report("Function $type->[0]",
+ "func_$types->[0]_$type->[1]",
+ [],"select $tmp ",[],
+ $type->[3],$type->[4]);
+ }
+ else
+ {
+ undef($limits{"func_$types->[0]_$type->[1]"});
+ $result = check_and_report("Function $type->[0]",
+ "func_$types->[0]_$type->[1]",
+ [],"select $type->[2] $end_query",[],
+ $type->[3],$type->[4]);
+ if (!$result)
+ {
+ # check without type specifyer
+ if ($type->[2] =~ /DATE /)
+ {
+ my $tmp= $type->[2];
+ $tmp =~ s/DATE //;
+ undef($limits{"func_$types->[0]_$type->[1]"});
+ $result = check_and_report("Function $type->[0]",
+ "func_$types->[0]_$type->[1]",
+ [],"select $tmp $end_query",[],
+ $type->[3],$type->[4]);
+ }
+ if (!$result)
+ {
+ if ($types->[0] eq "odbc" && ! ($type->[2] =~ /\{fn/))
+ {
+ my $tmp= $type->[2];
+ # Check by converting to ODBC format
+ undef($limits{"func_$types->[0]_$type->[1]"});
+ $tmp= "{fn $tmp }";
+ $tmp =~ s/('1997-\d\d-\d\d \d\d:\d\d:\d\d')/{ts $1}/g;
+ $tmp =~ s/(DATE '1997-\d\d-\d\d')/{d $1}/g;
+ $tmp =~ s/(TIME '12:13:14')/{t $1}/g;
+ $tmp =~ s/DATE //;
+ $tmp =~ s/TIME //;
+ check_and_report("Function $type->[0]",
+ "func_$types->[0]_$type->[1]",
+ [],"select $tmp $end_query",[],
+ $type->[3],$type->[4]);
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+if ($limits{'functions'} eq 'yes')
+{
+ foreach $types (@group_types)
+ {
+ print "\nSupported $types->[0] group functions\n";
+ $tmp= $types->[1];
+ foreach $type (@$tmp)
+ {
+ check_and_report("Group function $type->[0]",
+ "group_func_$types->[0]_$type->[1]",
+ [],"select $type->[2],a from crash_me group by a",[],
+ $type->[3],$type->[4]);
+ }
+ }
+ print "\n";
+ report("mixing of integer and float in expression","float_int_expr",
+ "select 1+1.0 $end_query");
+ if ($limits{'func_odbc_exp'} eq 'yes')
+ {
+ report("No need to cast from integer to float",
+ "dont_require_cast_to_float", "select exp(1) $end_query");
+ }
+ check_and_report("Is 1+NULL = NULL","null_num_expr",
+ [],"select 1+$numeric_null $end_query",[],undef(),4);
+ $tmp=sql_concat("'a'",$char_null);
+ if (defined($tmp))
+ {
+ check_and_report("Is $tmp = NULL", "null_concat_expr", [],
+ "select $tmp $end_query",[], undef(),4);
+ }
+ $prompt="Need to cast NULL for arithmetic";
+ add_log("Need_cast_for_null",
+ " Check if numeric_null ($numeric_null) is 'NULL'");
+ save_config_data("Need_cast_for_null",
+ ($numeric_null eq "NULL") ? "no" : "yes",
+ $prompt);
+}
+else
+{
+ print "\n";
+}
+
+
+# Test: NOROUND
+{
+ my $result = 'undefined';
+ my $error;
+ print "NOROUND: ";
+ save_incomplete('func_extra_noround','Function NOROUND');
+
+# 1) check if noround() function is supported
+ $error = safe_query_l('func_extra_noround',"select noround(22.6) $end_query");
+ if ($error ne 1) # syntax error -- noround is not supported
+ {
+ $result = 'no'
+ }
+ else # Ok, now check if it really works
+ {
+ $error=safe_query_l('func_extra_noround',
+ ["create table crash_me_nr (a int)",
+ "insert into crash_me_nr values(noround(10.2))",
+ "drop table crash_me_nr $drop_attr"]);
+ if ($error == 1)
+ {
+ $result= "syntax only";
+ }
+ else
+ {
+ $result= 'yes';
+ }
+ }
+ print "$result\n";
+ save_config_data('func_extra_noround',$result,"Function NOROUND");
+}
+
+check_parenthesis("func_sql_","CURRENT_USER");
+check_parenthesis("func_sql_","SESSION_USER");
+check_parenthesis("func_sql_","SYSTEM_USER");
+check_parenthesis("func_sql_","USER");
+
+
+if ($limits{'type_sql_date'} eq 'yes')
+{ #
+ # Checking the format of date in result.
+
+ safe_query("drop table crash_me_d $drop_attr");
+ assert("create table crash_me_d (a date)");
+ # find the example of date
+ my $dateexample;
+ if ($limits{'func_extra_sysdate'} eq 'yes') {
+ $dateexample=' sysdate() ';
+ }
+ elsif ($limits{'func_sql_current_date'} eq 'yes') {
+ $dateexample='CURRENT_DATE';
+ }
+ elsif ($limits{'func_odbc_curdate'} eq 'yes') {
+ $dateexample='curdate()';
+ }
+ elsif ($limits{'func_extra_getdate'} eq 'yes') {
+ $dateexample='getdate()';
+ }
+ elsif ($limits{'func_odbc_now'} eq 'yes') {
+ $dateexample='now()';
+ } else {
+ #try to guess
+ $dateexample="DATE '1963-08-16'";
+ } ;
+
+ my $key = 'date_format_inresult';
+ my $prompt = "Date format in result";
+ if (! safe_query_l('date_format_inresult',
+ "insert into crash_me_d values($dateexample) "))
+ {
+ die "Cannot insert date ($dateexample):".$last_error;
+ };
+ my $sth= $dbh->prepare("select a from crash_me_d");
+ add_log('date_format_inresult',"< select a from crash_me_d");
+ $sth->execute;
+ $_= $sth->fetchrow_array;
+ add_log('date_format_inresult',"> $_");
+ safe_query_l($key,"delete from crash_me_d");
+ if (/\d{4}-\d{2}-\d{2}/){ save_config_data($key,"iso",$prompt);}
+ elsif (/\d{2}-\d{2}-\d{2}/){ save_config_data($key,"short iso",$prompt);}
+ elsif (/\d{2}\.\d{2}\.\d{4}/){ save_config_data($key,"euro",$prompt);}
+ elsif (/\d{2}\.\d{2}\.\d{2}/){ save_config_data($key,"short euro",$prompt);}
+ elsif (/\d{2}\/\d{2}\/\d{4}/){ save_config_data($key,"usa",$prompt);}
+ elsif (/\d{2}\/\d{2}\/\d{2}/){ save_config_data($key,"short usa",$prompt);}
+ elsif (/\d*/){ save_config_data($key,"YYYYMMDD",$prompt);}
+ else { save_config_data($key,"unknown",$prompt);};
+ $sth->finish;
+
+ check_and_report("Supports YYYY-MM-DD (ISO) format","date_format_ISO",
+ [ "insert into crash_me_d(a) values ('1963-08-16')"],
+ "select a from crash_me_d",
+ ["delete from crash_me_d"],
+ make_date_r(1963,8,16),1);
+
+ check_and_report("Supports DATE 'YYYY-MM-DD' (ISO) format",
+ "date_format_ISO_with_date",
+ [ "insert into crash_me_d(a) values (DATE '1963-08-16')"],
+ "select a from crash_me_d",
+ ["delete from crash_me_d"],
+ make_date_r(1963,8,16),1);
+
+ check_and_report("Supports DD.MM.YYYY (EUR) format","date_format_EUR",
+ [ "insert into crash_me_d(a) values ('16.08.1963')"],
+ "select a from crash_me_d",
+ ["delete from crash_me_d"],
+ make_date_r(1963,8,16),1);
+ check_and_report("Supports DATE 'DD.MM.YYYY' (EUR) format",
+ "date_format_EUR_with_date",
+ [ "insert into crash_me_d(a) values (DATE '16.08.1963')"],
+ "select a from crash_me_d",
+ ["delete from crash_me_d"],
+ make_date_r(1963,8,16),1);
+
+ check_and_report("Supports YYYYMMDD format",
+ "date_format_YYYYMMDD",
+ [ "insert into crash_me_d(a) values ('19630816')"],
+ "select a from crash_me_d",
+ ["delete from crash_me_d"],
+ make_date_r(1963,8,16),1);
+ check_and_report("Supports DATE 'YYYYMMDD' format",
+ "date_format_YYYYMMDD_with_date",
+ [ "insert into crash_me_d(a) values (DATE '19630816')"],
+ "select a from crash_me_d",
+ ["delete from crash_me_d"],
+ make_date_r(1963,8,16),1);
+
+ check_and_report("Supports MM/DD/YYYY format",
+ "date_format_USA",
+ [ "insert into crash_me_d(a) values ('08/16/1963')"],
+ "select a from crash_me_d",
+ ["delete from crash_me_d"],
+ make_date_r(1963,8,16),1);
+ check_and_report("Supports DATE 'MM/DD/YYYY' format",
+ "date_format_USA_with_date",
+ [ "insert into crash_me_d(a) values (DATE '08/16/1963')"],
+ "select a from crash_me_d",
+ ["delete from crash_me_d"],
+ make_date_r(1963,8,16),1);
+
+
+
+
+ check_and_report("Supports 0000-00-00 dates","date_zero",
+ ["create table crash_me2 (a date not null)",
+ "insert into crash_me2 values (".make_date(0,0,0).")"],
+ "select a from crash_me2",
+ ["drop table crash_me2 $drop_attr"],
+ make_date_r(0,0,0),1);
+
+ check_and_report("Supports 0001-01-01 dates","date_one",
+ ["create table crash_me2 (a date not null)",
+ "insert into crash_me2 values (".make_date(1,1,1).")"],
+ "select a from crash_me2",
+ ["drop table crash_me2 $drop_attr"],
+ make_date_r(1,1,1),1);
+
+ check_and_report("Supports 9999-12-31 dates","date_last",
+ ["create table crash_me2 (a date not null)",
+ "insert into crash_me2 values (".make_date(9999,12,31).")"],
+ "select a from crash_me2",
+ ["drop table crash_me2 $drop_attr"],
+ make_date_r(9999,12,31),1);
+
+ check_and_report("Supports 'infinity dates","date_infinity",
+ ["create table crash_me2 (a date not null)",
+ "insert into crash_me2 values ('infinity')"],
+ "select a from crash_me2",
+ ["drop table crash_me2 $drop_attr"],
+ "infinity",1);
+
+ if (!defined($limits{'date_with_YY'}))
+ {
+ check_and_report("Supports YY-MM-DD dates","date_with_YY",
+ ["create table crash_me2 (a date not null)",
+ "insert into crash_me2 values ('98-03-03')"],
+ "select a from crash_me2",
+ ["drop table crash_me2 $drop_attr"],
+ make_date_r(1998,3,3),5);
+ if ($limits{'date_with_YY'} eq "yes")
+ {
+ undef($limits{'date_with_YY'});
+ check_and_report("Supports YY-MM-DD 2000 compilant dates",
+ "date_with_YY",
+ ["create table crash_me2 (a date not null)",
+ "insert into crash_me2 values ('10-03-03')"],
+ "select a from crash_me2",
+ ["drop table crash_me2 $drop_attr"],
+ make_date_r(2010,3,3),5);
+ }
+ }
+
+# Test: WEEK()
+ {
+ my $result="no";
+ my $error;
+ print "WEEK:";
+ save_incomplete('func_odbc_week','WEEK');
+ $error = safe_query_result_l('func_odbc_week',
+ "select week(".make_date(1997,2,1).") $end_query",5,0);
+ # actually this query must return 4 or 5 in the $last_result,
+ # $error can be 1 (not supported at all) , -1 ( probably USA weeks)
+ # and 0 - EURO weeks
+ if ($error == -1) {
+ if ($last_result == 4) {
+ $result = 'USA';
+ } else {
+ $result='error';
+ add_log('func_odbc_week',
+ " must return 4 or 5, but $last_result");
+ }
+ } elsif ($error == 0) {
+ $result = 'EURO';
+ }
+ print " $result\n";
+ save_config_data('func_odbc_week',$result,"WEEK");
+ }
+
+ my $insert_query ='insert into crash_me_d values('.
+ make_date(1997,2,1).')';
+ safe_query($insert_query);
+
+ foreach $fn ( (
+ ["DAYNAME","dayname","dayname(a)","",2],
+ ["MONTH","month","month(a)","",2],
+ ["MONTHNAME","monthname","monthname(a)","",2],
+ ["DAYOFMONTH","dayofmonth","dayofmonth(a)",1,0],
+ ["DAYOFWEEK","dayofweek","dayofweek(a)",7,0],
+ ["DAYOFYEAR","dayofyear","dayofyear(a)",32,0],
+ ["QUARTER","quarter","quarter(a)",1,0],
+ ["YEAR","year","year(a)",1997,0]))
+ {
+ $prompt='Function '.$fn->[0];
+ $key='func_odbc_'.$fn->[1];
+ add_log($key,"< ".$insert_query);
+ check_and_report($prompt,$key,
+ [],"select ".$fn->[2]." from crash_me_d",[],
+ $fn->[3],$fn->[4]
+ );
+
+ };
+ safe_query(['delete from crash_me_d',
+ 'insert into crash_me_d values('.make_date(1963,8,16).')']);
+ foreach $fn ((
+ ["DATEADD","dateadd","dateadd(day,3,make_date(1997,11,30))",0,2],
+ ["MDY","mdy","mdy(7,1,1998)","make_date_r(1998,07,01)",0], # informix
+ ["DATEDIFF","datediff",
+ "datediff(month,'Oct 21 1997','Nov 30 1997')",0,2],
+ ["DATENAME","datename","datename(month,'Nov 30 1997')",0,2],
+ ["DATEPART","datepart","datepart(month,'July 20 1997')",0,2],
+ ["DATE_FORMAT","date_format",
+ "date_format('1997-01-02 03:04:05','M W D Y y m d h i s w')", 0,2],
+ ["FROM_DAYS","from_days",
+ "from_days(729024)","make_date_r(1996,1,1)",1],
+ ["FROM_UNIXTIME","from_unixtime","from_unixtime(0)",0,2],
+ ["MONTHS_BETWEEN","months_between",
+ "months_between(make_date(1997,2,2),make_date(1997,1,1))",
+ "1.03225806",0], # oracle number of months between 2 dates
+ ["PERIOD_ADD","period_add","period_add(9602,-12)",199502,0],
+ ["PERIOD_DIFF","period_diff","period_diff(199505,199404)",13,0],
+ ["WEEKDAY","weekday","weekday(make_date(1997,11,29))",5,0],
+ ["ADDDATE",'adddate',
+ "ADDDATE(make_date(2002,12,01),3)",'make_date_r(2002,12,04)',0],
+ ["SUBDATE",'subdate',
+ "SUBDATE(make_date(2002,12,04),3)",'make_date_r(2002,12,01)',0],
+ ["DATEDIFF (2 arg)",'datediff2arg',
+ "DATEDIFF(make_date(2002,12,04),make_date(2002,12,01))",'3',0],
+ ["WEEKOFYEAR",'weekofyear',
+ "WEEKOFYEAR(make_date(1963,08,16))",'33',0],
+# table crash_me_d must contain record with 1963-08-16 (for CHAR)
+ ["CHAR (conversation date)",'char_date',
+ "CHAR(a,EUR)",'16.08.1963',0],
+ ["MAKEDATE",'makedate',"MAKEDATE(1963,228)"
+ ,'make_date_r(1963,08,16)',0],
+ ["TO_DAYS","to_days",
+ "to_days(make_date(1996,01,01))",729024,0],
+ ["ADD_MONTHS","add_months",
+ "add_months(make_date(1997,01,01),1)","make_date_r(1997,02,01)",0],
+ # oracle the date plus n months
+ ["LAST_DAY","last_day",
+ "last_day(make_date(1997,04,01))","make_date_r(1997,04,30)",0],
+ # oracle last day of month of date
+ ["DATE",'date',"date(make_date(1963,8,16))",
+ 'make_date_r(1963,8,16)',0],
+ ["DAY",'day',"DAY(make_date(2002,12,01))",1,0]))
+ {
+ $prompt='Function '.$fn->[0];
+ $key='func_extra_'.$fn->[1];
+ my $qry="select ".$fn->[2]." from crash_me_d";
+ while( $qry =~ /^(.*)make_date\((\d+),(\d+),(\d+)\)(.*)$/)
+ {
+ my $dt= &make_date($2,$3,$4);
+ $qry=$1.$dt.$5;
+ };
+ my $result=$fn->[3];
+ while( $result =~ /^(.*)make_date_r\((\d+),(\d+),(\d+)\)(.*)$/)
+ {
+ my $dt= &make_date_r($2,$3,$4);
+ $result=$1.$dt.$5;
+ };
+ check_and_report($prompt,$key,
+ [],$qry,[],
+ $result,$fn->[4]
+ );
+
+ }
+
+ safe_query("drop table crash_me_d $drop_attr");
+
+}
+
+if ($limits{'type_sql_time'} eq 'yes')
+{ #
+ # Checking the format of date in result.
+
+ safe_query("drop table crash_me_t $drop_attr");
+ assert("create table crash_me_t (a time)");
+ # find the example of time
+ my $timeexample;
+ if ($limits{'func_sql_current_time'} eq 'yes') {
+ $timeexample='CURRENT_TIME';
+ }
+ elsif ($limits{'func_odbc_curtime'} eq 'yes') {
+ $timeexample='curtime()';
+ }
+ elsif ($limits{'func_sql_localtime'} eq 'yes') {
+ $timeexample='localtime';
+ }
+ elsif ($limits{'func_odbc_now'} eq 'yes') {
+ $timeexample='now()';
+ } else {
+ #try to guess
+ $timeexample="'02:55:12'";
+ } ;
+
+ my $key = 'time_format_inresult';
+ my $prompt = "Time format in result";
+ if (! safe_query_l('time_format_inresult',
+ "insert into crash_me_t values($timeexample) "))
+ {
+ die "Cannot insert time ($timeexample):".$last_error;
+ };
+ my $sth= $dbh->prepare("select a from crash_me_t");
+ add_log('time_format_inresult',"< select a from crash_me_t");
+ $sth->execute;
+ $_= $sth->fetchrow_array;
+ add_log('time_format_inresult',"> $_");
+ safe_query_l($key,"delete from crash_me_t");
+ if (/\d{2}:\d{2}:\d{2}/){ save_config_data($key,"iso",$prompt);}
+ elsif (/\d{2}\.\d{2}\.\d{2}/){ save_config_data($key,"euro",$prompt);}
+ elsif (/\d{2}:\d{2}\s+(AM|PM)/i){ save_config_data($key,"usa",$prompt);}
+ elsif (/\d{8}$/){ save_config_data($key,"HHHHMMSS",$prompt);}
+ elsif (/\d{4}$/){ save_config_data($key,"HHMMSS",$prompt);}
+ else { save_config_data($key,"unknown",$prompt);};
+ $sth->finish;
+
+ check_and_report("Supports HH:MM:SS (ISO) time format","time_format_ISO",
+ [ "insert into crash_me_t(a) values ('20:08:16')"],
+ "select a from crash_me_t",
+ ["delete from crash_me_t"],
+ make_time_r(20,8,16),1);
+
+ check_and_report("Supports HH.MM.SS (EUR) time format","time_format_EUR",
+ [ "insert into crash_me_t(a) values ('20.08.16')"],
+ "select a from crash_me_t",
+ ["delete from crash_me_t"],
+ make_time_r(20,8,16),1);
+
+ check_and_report("Supports HHHHmmSS time format",
+ "time_format_HHHHMMSS",
+ [ "insert into crash_me_t(a) values ('00200816')"],
+ "select a from crash_me_t",
+ ["delete from crash_me_t"],
+ make_time_r(20,8,16),1);
+
+ check_and_report("Supports HHmmSS time format",
+ "time_format_HHHHMMSS",
+ [ "insert into crash_me_t(a) values ('200816')"],
+ "select a from crash_me_t",
+ ["delete from crash_me_t"],
+ make_time_r(20,8,16),1);
+
+ check_and_report("Supports HH:MM:SS (AM|PM) time format",
+ "time_format_USA",
+ [ "insert into crash_me_t(a) values ('08:08:16 PM')"],
+ "select a from crash_me_t",
+ ["delete from crash_me_t"],
+ make_time_r(20,8,16),1);
+
+ my $insert_query ='insert into crash_me_t values('.
+ make_time(20,8,16).')';
+ safe_query($insert_query);
+
+ foreach $fn ( (
+ ["HOUR","hour","hour('".make_time(12,13,14)."')",12,0],
+ ["ANSI HOUR","hour_time","hour(TIME '".make_time(12,13,14)."')",12,0],
+ ["MINUTE","minute","minute('".make_time(12,13,14)."')",13,0],
+ ["SECOND","second","second('".make_time(12,13,14)."')",14,0]
+
+ ))
+ {
+ $prompt='Function '.$fn->[0];
+ $key='func_odbc_'.$fn->[1];
+ add_log($key,"< ".$insert_query);
+ check_and_report($prompt,$key,
+ [],"select ".$fn->[2]." $end_query",[],
+ $fn->[3],$fn->[4]
+ );
+
+ };
+# safe_query(['delete from crash_me_t',
+# 'insert into crash_me_t values('.make_time(20,8,16).')']);
+ foreach $fn ((
+ ["TIME_TO_SEC","time_to_sec","time_to_sec('".
+ make_time(1,23,21)."')","5001",0],
+ ["SEC_TO_TIME","sec_to_time","sec_to_time(5001)",
+ make_time_r(01,23,21),1],
+ ["ADDTIME",'addtime',"ADDTIME('".make_time(20,2,12).
+ "','".make_time(0,0,3)."')",make_time_r(20,2,15),0],
+ ["SUBTIME",'subtime',"SUBTIME('".make_time(20,2,15)
+ ."','".make_time(0,0,3)."')",make_time_r(20,2,12),0],
+ ["TIMEDIFF",'timediff',"TIMEDIFF('".make_time(20,2,15)."','".
+ make_time(20,2,12)."')",make_time_r(0,0,3),0],
+ ["MAKETIME",'maketime',"MAKETIME(20,02,12)",make_time_r(20,2,12),0],
+ ["TIME",'time',"time('".make_time(20,2,12)."')",make_time_r(20,2,12),0]
+ ))
+ {
+ $prompt='Function '.$fn->[0];
+ $key='func_extra_'.$fn->[1];
+ my $qry="select ".$fn->[2]." $end_query";
+ my $result=$fn->[3];
+ check_and_report($prompt,$key,
+ [],$qry,[],
+ $result,$fn->[4]
+ );
+
+ }
+
+ safe_query("drop table crash_me_t $drop_attr");
+
+}
+
+
+# NOT id BETWEEN a and b
+if ($limits{'func_where_not_between'} eq 'yes')
+{
+ my $result = 'error';
+ my $err;
+ my $key='not_id_between';
+ my $prompt='NOT ID BETWEEN interprets as ID NOT BETWEEN';
+ print "$prompt:";
+ save_incomplete($key,$prompt);
+ safe_query_l($key,["create table crash_me_b (i int)",
+ "insert into crash_me_b values(2)",
+ "insert into crash_me_b values(5)"]);
+ $err =safe_query_result_l($key,
+ "select i from crash_me_b where not i between 1 and 3",
+ 5,0);
+ if ($err eq 1) {
+ if (not defined($last_result)) {
+ $result='no';
+ };
+ };
+ if ( $err eq 0) {
+ $result = 'yes';
+ };
+ safe_query_l($key,["drop table crash_me_b"]);
+ save_config_data($key,$result,$prompt);
+ print "$result\n";
+};
+
+
+
+
+report("LIKE on numbers","like_with_number",
+ "create table crash_q (a int,b int)",
+ "insert into crash_q values(10,10)",
+ "select * from crash_q where a like '10'",
+ "drop table crash_q $drop_attr");
+
+report("column LIKE column","like_with_column",
+ "create table crash_q (a char(10),b char(10))",
+ "insert into crash_q values('abc','abc')",
+ "select * from crash_q where a like b",
+ "drop table crash_q $drop_attr");
+
+report("update of column= -column","NEG",
+ "create table crash_q (a integer)",
+ "insert into crash_q values(10)",
+ "update crash_q set a=-a",
+ "drop table crash_q $drop_attr");
+
+if ($limits{'func_odbc_left'} eq 'yes' ||
+ $limits{'func_odbc_substring'} eq 'yes')
+{
+ my $type= ($limits{'func_odbc_left'} eq 'yes' ?
+ "left(a,4)" : "substring(a for 4)");
+
+ check_and_report("String functions on date columns","date_as_string",
+ ["create table crash_me2 (a date not null)",
+ "insert into crash_me2 values ('1998-03-03')"],
+ "select $type from crash_me2",
+ ["drop table crash_me2 $drop_attr"],
+ "1998",1);
+}
+
+
+$tmp=sql_concat("b","b");
+if (defined($tmp))
+{
+ check_and_report("char are space filled","char_is_space_filled",
+ [],"select $tmp from crash_me where b = 'a '",[],
+ 'a a ',6);
+}
+
+if (!defined($limits{'multi_table_update'}))
+{
+ if (check_and_report("Update with many tables","multi_table_update",
+ ["create table crash_q (a integer,b char(10))",
+ "insert into crash_q values(1,'c')",
+ "update crash_q left join crash_me on crash_q.a=crash_me.a set crash_q.b=crash_me.b"],
+ "select b from crash_q",
+ ["drop table crash_q $drop_attr"],
+ "a",1,undef(),2))
+ {
+ check_and_report("Update with many tables","multi_table_update",
+ ["create table crash_q (a integer,b char(10))",
+ "insert into crash_q values(1,'c')",
+ "update crash_q,crash_me set crash_q.b=crash_me.b ".
+ "where crash_q.a=crash_me.a"],
+ "select b from crash_q",
+ ["drop table crash_q $drop_attr"],
+ "a",1,
+ 1);
+ }
+}
+
+report("DELETE FROM table1,table2...","multi_table_delete",
+ "create table crash_q (a integer,b char(10))",
+ "insert into crash_q values(1,'c')",
+ "delete crash_q.* from crash_q,crash_me where crash_q.a=crash_me.a",
+ "drop table crash_q $drop_attr");
+
+check_and_report("Update with sub select","select_table_update",
+ ["create table crash_q (a integer,b char(10))",
+ "insert into crash_q values(1,'c')",
+ "update crash_q set b= ".
+ "(select b from crash_me where crash_q.a = crash_me.a)"],
+ "select b from crash_q",
+ ["drop table crash_q $drop_attr"],
+ "a",1);
+
+check_and_report("Calculate 1--1","minus_neg",[],
+ "select a--1 from crash_me",[],0,2);
+
+report("ANSI SQL simple joins","simple_joins",
+ "select crash_me.a from crash_me, crash_me t0");
+
+#
+# Check max string size, and expression limits
+#
+$found=undef;
+foreach $type (('mediumtext','text','text()','blob','long'))
+{
+ if ($limits{"type_extra_$type"} eq 'yes')
+ {
+ $found=$type;
+ last;
+ }
+}
+if (defined($found))
+{
+ $found =~ s/\(\)/\(%d\)/;
+ find_limit("max text or blob size","max_text_size",
+ new query_many(["create table crash_q (q $found)",
+ "insert into crash_q values ('%s')"],
+ "select * from crash_q","%s",
+ ["drop table crash_q $drop_attr"],
+ min($max_string_size,$limits{'query_size'}-30)));
+
+}
+
+# It doesn't make lots of sense to check for string lengths much bigger than
+# what can be stored...
+
+find_limit(($prompt="constant string size in where"),"where_string_size",
+ new query_repeat([],"select a from crash_me where b >='",
+ "","","1","","'"));
+if ($limits{'where_string_size'} == 10)
+{
+ save_config_data('where_string_size','nonstandard',$prompt);
+}
+
+if ($limits{'select_constants'} eq 'yes')
+{
+ find_limit("constant string size in SELECT","select_string_size",
+ new query_repeat([],"select '","","","a","","'$end_query"));
+}
+
+goto no_functions if ($limits{'functions'} ne "yes");
+
+if ($limits{'func_odbc_repeat'} eq 'yes')
+{
+ find_limit("return string size from function","repeat_string_size",
+ new query_many([],
+ "select repeat('a',%d) $end_query","%s",
+ [],
+ $max_string_size,0));
+}
+
+$tmp=find_limit("simple expressions","max_expressions",
+ new query_repeat([],"select 1","","","+1","",$end_query,
+ undef(),$max_expressions));
+
+if ($tmp > 10)
+{
+ $tmp= "(1" . ( '+1' x ($tmp-10) ) . ")";
+ find_limit("big expressions", "max_big_expressions",
+ new query_repeat([],"select 0","","","+$tmp","",$end_query,
+ undef(),$max_big_expressions));
+}
+
+find_limit("stacked expressions", "max_stack_expression",
+ new query_repeat([],"select 1","","","+(1",")",$end_query,
+ undef(),$max_stacked_expressions));
+
+no_functions:
+
+if (!defined($limits{'max_conditions'}))
+{
+ find_limit("OR and AND in WHERE","max_conditions",
+ new query_repeat([],
+ "select a from crash_me where a=1 and b='a'","",
+ "", " or a=%d and b='%d'","","","",
+ [],($query_size-42)/29,undef,2));
+ $limits{'max_conditions'}*=2;
+}
+# The 42 is the length of the constant part.
+# The 29 is the length of the variable part, plus two seven-digit numbers.
+
+find_limit("tables in join", "join_tables",
+ new query_repeat([],
+ "select crash_me.a",",t%d.a","from crash_me",
+ ",crash_me t%d","","",[],$max_join_tables,undef,
+ 1));
+
+# Different CREATE TABLE options
+
+report("primary key in create table",'primary_key_in_create',
+ "create table crash_q (q integer not null,primary key (q))",
+ "drop table crash_q $drop_attr");
+
+report("unique in create table",'unique_in_create',
+ "create table crash_q (q integer not null,unique (q))",
+ "drop table crash_q $drop_attr");
+
+if ($limits{'unique_in_create'} eq 'yes')
+{
+ report("unique null in create",'unique_null_in_create',
+ "create table crash_q (q integer,unique (q))",
+ "insert into crash_q (q) values (NULL)",
+ "insert into crash_q (q) values (NULL)",
+ "insert into crash_q (q) values (1)",
+ "drop table crash_q $drop_attr");
+}
+
+report("default value for column",'create_default',
+ "create table crash_q (q integer default 10 not null)",
+ "drop table crash_q $drop_attr");
+
+report("default value function for column",'create_default_func',
+ "create table crash_q (q integer not null,q1 integer default (1+1))",
+ "drop table crash_q $drop_attr");
+
+report("temporary tables",'temporary_table',
+ "create temporary table crash_q (q integer not null)",
+ "drop table crash_q $drop_attr");
+
+report_one("create table from select",'create_table_select',
+ [["create table crash_q SELECT * from crash_me","yes"],
+ ["create table crash_q AS SELECT * from crash_me","with AS"]]);
+$dbh->do("drop table crash_q $drop_attr");
+
+report("index in create table",'index_in_create',
+ "create table crash_q (q integer not null,index (q))",
+ "drop table crash_q $drop_attr");
+
+# The following must be executed as we need the value of end_drop_keyword
+# later
+if (!(defined($limits{'create_index'}) && defined($limits{'drop_index'})))
+{
+ if ($res=safe_query_l('create_index',"create index crash_q on crash_me (a)"))
+ {
+ $res="yes";
+ $drop_res="yes";
+ $end_drop_keyword="";
+ if (!safe_query_l('drop_index',"drop index crash_q"))
+ {
+ # Can't drop the standard way; Check if mSQL
+ if (safe_query_l('drop_index',"drop index crash_q from crash_me"))
+ {
+ $drop_res="with 'FROM'"; # Drop is not ANSI SQL
+ $end_drop_keyword="drop index %i from %t";
+ }
+ # else check if Access or MySQL
+ elsif (safe_query_l('drop_index',"drop index crash_q on crash_me"))
+ {
+ $drop_res="with 'ON'"; # Drop is not ANSI SQL
+ $end_drop_keyword="drop index %i on %t";
+ }
+ # else check if MS-SQL
+ elsif (safe_query_l('drop_index',"drop index crash_me.crash_q"))
+ {
+ $drop_res="with 'table.index'"; # Drop is not ANSI SQL
+ $end_drop_keyword="drop index %t.%i";
+ }
+ }
+ else
+ {
+ # Old MySQL 3.21 supports only the create index syntax
+ # This means that the second create doesn't give an error.
+ $res=safe_query_l('create_index',["create index crash_q on crash_me (a)",
+ "create index crash_q on crash_me (a)",
+ "drop index crash_q"]);
+ $res= $res ? 'ignored' : 'yes';
+ }
+ }
+ else
+ {
+ $drop_res=$res='no';
+ }
+ save_config_data('create_index',$res,"create index");
+ save_config_data('drop_index',$drop_res,"drop index");
+
+ print "create index: $limits{'create_index'}\n";
+ print "drop index: $limits{'drop_index'}\n";
+}
+
+# check if we can have 'NULL' as a key
+check_and_report("null in index","null_in_index",
+ [create_table("crash_q",["a char(10)"],["(a)"]),
+ "insert into crash_q values (NULL)"],
+ "select * from crash_q",
+ ["drop table crash_q $drop_attr"],
+ undef(),4);
+
+if ($limits{'unique_in_create'} eq 'yes')
+{
+ report("null in unique index",'null_in_unique',
+ create_table("crash_q",["q integer"],["unique(q)"]),
+ "insert into crash_q (q) values(NULL)",
+ "insert into crash_q (q) values(NULL)",
+ "drop table crash_q $drop_attr");
+ report("null combination in unique index",'nulls_in_unique',
+ create_table("crash_q",["q integer,q1 integer"],["unique(q,q1)"]),
+ "insert into crash_q (q,q1) values(1,NULL)",
+ "insert into crash_q (q,q1) values(1,NULL)",
+ "drop table crash_q $drop_attr");
+}
+
+if ($limits{'null_in_unique'} eq 'yes')
+{
+ report("null in unique index",'multi_null_in_unique',
+ create_table("crash_q",["q integer, x integer"],["unique(q)"]),
+ "insert into crash_q(x) values(1)",
+ "insert into crash_q(x) values(2)",
+ "drop table crash_q $drop_attr");
+}
+
+if ($limits{'create_index'} ne 'no')
+{
+ $end_drop=$end_drop_keyword;
+ $end_drop =~ s/%i/crash_q/;
+ $end_drop =~ s/%t/crash_me/;
+ report("index on column part (extension)","index_parts",,
+ "create index crash_q on crash_me (b(5))",
+ $end_drop);
+ $end_drop=$end_drop_keyword;
+ $end_drop =~ s/%i/crash_me/;
+ $end_drop =~ s/%t/crash_me/;
+ report("different namespace for index",
+ "index_namespace",
+ "create index crash_me on crash_me (b)",
+ $end_drop);
+}
+
+if (!report("case independent table names","table_name_case",
+ "create table crash_q (q integer)",
+ "drop table CRASH_Q $drop_attr"))
+{
+ safe_query("drop table crash_q $drop_attr");
+}
+
+if (!report("case independent field names","field_name_case",
+ "create table crash_q (q integer)",
+ "insert into crash_q(Q) values (1)",
+ "drop table crash_q $drop_attr"))
+{
+ safe_query("drop table crash_q $drop_attr");
+}
+
+if (!report("drop table if exists","drop_if_exists",
+ "create table crash_q (q integer)",
+ "drop table if exists crash_q $drop_attr"))
+{
+ safe_query("drop table crash_q $drop_attr");
+}
+
+report("create table if not exists","create_if_not_exists",
+ "create table crash_q (q integer)",
+ "create table if not exists crash_q (q integer)");
+safe_query("drop table crash_q $drop_attr");
+
+#
+# test of different join types
+#
+
+assert("create table crash_me2 (a integer not null,b char(10) not null,".
+ " c1 integer)");
+assert("insert into crash_me2 (a,b,c1) values (1,'b',1)");
+assert("create table crash_me3 (a integer not null,b char(10) not null)");
+assert("insert into crash_me3 (a,b) values (1,'b')");
+
+report("inner join","inner_join",
+ "select crash_me.a from crash_me inner join crash_me2 ON ".
+ "crash_me.a=crash_me2.a");
+report("left outer join","left_outer_join",
+ "select crash_me.a from crash_me left join crash_me2 ON ".
+ "crash_me.a=crash_me2.a");
+report("natural left outer join","natural_left_outer_join",
+ "select c1 from crash_me natural left join crash_me2");
+report("left outer join using","left_outer_join_using",
+ "select c1 from crash_me left join crash_me2 using (a)");
+report("left outer join odbc style","odbc_left_outer_join",
+ "select crash_me.a from { oj crash_me left outer join crash_me2 ON".
+ " crash_me.a=crash_me2.a }");
+report("right outer join","right_outer_join",
+ "select crash_me.a from crash_me right join crash_me2 ON ".
+ "crash_me.a=crash_me2.a");
+report("full outer join","full_outer_join",
+ "select crash_me.a from crash_me full join crash_me2 ON "."
+ crash_me.a=crash_me2.a");
+report("cross join (same as from a,b)","cross_join",
+ "select crash_me.a from crash_me cross join crash_me3");
+report("natural join","natural_join",
+ "select * from crash_me natural join crash_me3");
+report("union","union",
+ "select * from crash_me union select a,b from crash_me3");
+report("union all","union_all",
+ "select * from crash_me union all select a,b from crash_me3");
+report("intersect","intersect",
+ "select * from crash_me intersect select * from crash_me3");
+report("intersect all","intersect_all",
+ "select * from crash_me intersect all select * from crash_me3");
+report("except","except",
+ "select * from crash_me except select * from crash_me3");
+report("except all","except_all",
+ "select * from crash_me except all select * from crash_me3");
+report("except","except",
+ "select * from crash_me except select * from crash_me3");
+report("except all","except_all",
+ "select * from crash_me except all select * from crash_me3");
+report("minus","minus",
+ "select * from crash_me minus select * from crash_me3"); # oracle ...
+
+report("natural join (incompatible lists)","natural_join_incompat",
+ "select c1 from crash_me natural join crash_me2");
+report("union (incompatible lists)","union_incompat",
+ "select * from crash_me union select a,b from crash_me2");
+report("union all (incompatible lists)","union_all_incompat",
+ "select * from crash_me union all select a,b from crash_me2");
+report("intersect (incompatible lists)","intersect_incompat",
+ "select * from crash_me intersect select * from crash_me2");
+report("intersect all (incompatible lists)","intersect_all_incompat",
+ "select * from crash_me intersect all select * from crash_me2");
+report("except (incompatible lists)","except_incompat",
+ "select * from crash_me except select * from crash_me2");
+report("except all (incompatible lists)","except_all_incompat",
+ "select * from crash_me except all select * from crash_me2");
+report("except (incompatible lists)","except_incompat",
+ "select * from crash_me except select * from crash_me2");
+report("except all (incompatible lists)","except_all_incompat",
+ "select * from crash_me except all select * from crash_me2");
+report("minus (incompatible lists)","minus_incompat",
+ "select * from crash_me minus select * from crash_me2"); # oracle ...
+
+assert("drop table crash_me2 $drop_attr");
+assert("drop table crash_me3 $drop_attr");
+
+# somethings to be added here ....
+# FOR UNION - INTERSECT - EXCEPT -> CORRESPONDING [ BY ]
+# after subqueries:
+# >ALL | ANY | SOME - EXISTS - UNIQUE
+
+if (report("subqueries","subqueries",
+ "select a from crash_me where crash_me.a in ".
+ "(select max(a) from crash_me)"))
+{
+ $tmp=new query_repeat([],"select a from crash_me","","",
+ " where a in (select a from crash_me",")",
+ "",[],$max_join_tables);
+ find_limit("recursive subqueries", "recursive_subqueries",$tmp);
+}
+
+report("insert INTO ... SELECT ...","insert_select",
+ "create table crash_q (a int)",
+ "insert into crash_q (a) SELECT crash_me.a from crash_me",
+ "drop table crash_q $drop_attr");
+
+if (!defined($limits{"transactions"}))
+{
+ my ($limit,$type);
+ $limit="transactions";
+ $limit_r="rollback_metadata";
+ print "$limit: ";
+ foreach $type (('', 'type=bdb', 'type=innodb', 'type=gemini'))
+ {
+ undef($limits{$limit});
+ if (!report_trans($limit,
+ [create_table("crash_q",["a integer not null"],[],
+ $type),
+ "insert into crash_q values (1)"],
+ "select * from crash_q",
+ "drop table crash_q $drop_attr"
+ ))
+ {
+ report_rollback($limit_r,
+ [create_table("crash_q",["a integer not null"],[],
+ $type)],
+ "insert into crash_q values (1)",
+ "drop table crash_q $drop_attr" );
+ last;
+ };
+ }
+ print "$limits{$limit}\n";
+ print "$limit_r: $limits{$limit_r}\n";
+}
+
+report("atomic updates","atomic_updates",
+ create_table("crash_q",["a integer not null"],["primary key (a)"]),
+ "insert into crash_q values (2)",
+ "insert into crash_q values (3)",
+ "insert into crash_q values (1)",
+ "update crash_q set a=a+1",
+ "drop table crash_q $drop_attr");
+
+if ($limits{'atomic_updates'} eq 'yes')
+{
+ report_fail("atomic_updates_with_rollback","atomic_updates_with_rollback",
+ create_table("crash_q",["a integer not null"],
+ ["primary key (a)"]),
+ "insert into crash_q values (2)",
+ "insert into crash_q values (3)",
+ "insert into crash_q values (1)",
+ "update crash_q set a=a+1 where a < 3",
+ "drop table crash_q $drop_attr");
+}
+
+# To add with the views:
+# DROP VIEW - CREAT VIEW *** [ WITH [ CASCADE | LOCAL ] CHECK OPTION ]
+report("views","views",
+ "create view crash_q as select a from crash_me",
+ "drop view crash_q $drop_attr");
+
+# Test: foreign key
+{
+ my $result = 'undefined';
+ my $error;
+ print "foreign keys: ";
+ save_incomplete('foreign_key','foreign keys');
+
+# 1) check if foreign keys are supported
+ safe_query_l('foreign_key',
+ create_table("crash_me_qf",
+ ["a integer not null"],
+ ["primary key (a)"]));
+ $error= safe_query_l('foreign_key',
+ create_table("crash_me_qf2",
+ ["a integer not null",
+ "foreign key (a) references crash_me_qf (a)"],
+ []));
+
+ if ($error == 1) # OK -- syntax is supported
+ {
+ $result = 'error';
+ # now check if foreign key really works
+ safe_query_l('foreign_key', "insert into crash_me_qf values (1)");
+ if (safe_query_l('foreign_key', "insert into crash_me_qf2 values (2)") eq 1)
+ {
+ $result = 'syntax only';
+ }
+ else
+ {
+ $result = 'yes';
+ }
+ }
+ else
+ {
+ $result = "no";
+ }
+ safe_query_l('foreign_key', "drop table crash_me_qf2 $drop_attr");
+ safe_query_l('foreign_key', "drop table crash_me_qf $drop_attr");
+ print "$result\n";
+ save_config_data('foreign_key',$result,"foreign keys");
+}
+
+if ($limits{'foreign_key'} eq 'yes')
+{
+ report("allows to update of foreign key values",'foreign_update',
+ "create table crash_me1 (a int not null primary key)",
+ "create table crash_me2 (a int not null," .
+ " foreign key (a) references crash_me1 (a))",
+ "insert into crash_me1 values (1)",
+ "insert into crash_me2 values (1)",
+ "update crash_me1 set a = 2", ## <- must fail
+ "drop table crash_me2 $drop_attr",
+ "drop table crash_me1 $drop_attr"
+ );
+}
+
+report("Create SCHEMA","create_schema",
+ "create schema crash_schema create table crash_q (a int) ".
+ "create table crash_q2(b int)",
+ "drop schema crash_schema cascade");
+
+if ($limits{'foreign_key'} eq 'yes')
+{
+ if ($limits{'create_schema'} eq 'yes')
+ {
+ report("Circular foreign keys","foreign_key_circular",
+ "create schema crash_schema create table crash_q ".
+ "(a int primary key, b int, foreign key (b) references ".
+ "crash_q2(a)) create table crash_q2(a int, b int, ".
+ "primary key(a), foreign key (b) references crash_q(a))",
+ "drop schema crash_schema cascade");
+ }
+}
+
+if ($limits{'func_sql_character_length'} eq 'yes')
+{
+ my $result = 'error';
+ my ($resultset);
+ my $key = 'length_of_varchar_field';
+ my $prompt='CHARACTER_LENGTH(varchar_field)';
+ print $prompt," = ";
+ if (!defined($limits{$key})) {
+ save_incomplete($key,$prompt);
+ safe_query_l($key,[
+ "CREATE TABLE crash_me1 (S1 VARCHAR(100))",
+ "INSERT INTO crash_me1 VALUES ('X')"
+ ]);
+ my $recset = get_recordset($key,
+ "SELECT CHARACTER_LENGTH(S1) FROM crash_me1");
+ print_recordset($key,$recset);
+ if (defined($recset)){
+ if ( $recset->[0][0] eq 1 ) {
+ $result = 'actual length';
+ } elsif( $recset->[0][0] eq 100 ) {
+ $result = 'defined length';
+ };
+ } else {
+ add_log($key,$DBI::errstr);
+ }
+ safe_query_l($key, "drop table crash_me1 $drop_attr");
+ save_config_data($key,$result,$prompt);
+ } else {
+ $result = $limits{$key};
+ };
+ print "$result\n";
+}
+
+
+check_constraint("Column constraints","constraint_check",
+ "create table crash_q (a int check (a>0))",
+ "insert into crash_q values(0)",
+ "drop table crash_q $drop_attr");
+
+
+check_constraint("Table constraints","constraint_check_table",
+ "create table crash_q (a int ,b int, check (a>b))",
+ "insert into crash_q values(0,0)",
+ "drop table crash_q $drop_attr");
+
+check_constraint("Named constraints","constraint_check_named",
+ "create table crash_q (a int ,b int, constraint abc check (a>b))",
+ "insert into crash_q values(0,0)",
+ "drop table crash_q $drop_attr");
+
+
+report("NULL constraint (SyBase style)","constraint_null",
+ "create table crash_q (a int null)",
+ "drop table crash_q $drop_attr");
+
+report("Triggers (ANSI SQL)","psm_trigger",
+ "create table crash_q (a int ,b int)",
+ "create trigger crash_trigger after insert on crash_q referencing ".
+ "new table as new_a when (localtime > time '18:00:00') ".
+ "begin atomic end",
+ "insert into crash_q values(1,2)",
+ "drop trigger crash_trigger",
+ "drop table crash_q $drop_attr");
+
+report("PSM procedures (ANSI SQL)","psm_procedures",
+ "create table crash_q (a int,b int)",
+ "create procedure crash_proc(in a1 int, in b1 int) language ".
+ "sql modifies sql data begin declare c1 int; set c1 = a1 + b1;".
+ " insert into crash_q(a,b) values (a1,c1); end",
+ "call crash_proc(1,10)",
+ "drop procedure crash_proc",
+ "drop table crash_q $drop_attr");
+
+report("PSM modules (ANSI SQL)","psm_modules",
+ "create table crash_q (a int,b int)",
+ "create module crash_m declare procedure ".
+ "crash_proc(in a1 int, in b1 int) language sql modifies sql ".
+ "data begin declare c1 int; set c1 = a1 + b1; ".
+ "insert into crash_q(a,b) values (a1,c1); end; ".
+ "declare procedure crash_proc2(INOUT a int, in b int) ".
+ "contains sql set a = b + 10; end module",
+ "call crash_proc(1,10)",
+ "drop module crash_m cascade",
+ "drop table crash_q cascade $drop_attr");
+
+report("PSM functions (ANSI SQL)","psm_functions",
+ "create table crash_q (a int)",
+ "create function crash_func(in a1 int, in b1 int) returns int".
+ " language sql deterministic contains sql ".
+ " begin return a1 * b1; end",
+ "insert into crash_q values(crash_func(2,4))",
+ "select a,crash_func(a,2) from crash_q",
+ "drop function crash_func cascade",
+ "drop table crash_q $drop_attr");
+
+report("Domains (ANSI SQL)","domains",
+ "create domain crash_d as varchar(10) default 'Empty' ".
+ "check (value <> 'abcd')",
+ "create table crash_q(a crash_d, b int)",
+ "insert into crash_q(a,b) values('xyz',10)",
+ "insert into crash_q(b) values(10)",
+ "drop table crash_q $drop_attr",
+ "drop domain crash_d");
+
+
+if (!defined($limits{'lock_tables'}))
+{
+ report("lock table","lock_tables",
+ "lock table crash_me READ",
+ "unlock tables");
+ if ($limits{'lock_tables'} eq 'no')
+ {
+ delete $limits{'lock_tables'};
+ report("lock table","lock_tables",
+ "lock table crash_me IN SHARE MODE");
+ }
+}
+
+if (!report("many tables to drop table","multi_drop",
+ "create table crash_q (a int)",
+ "create table crash_q2 (a int)",
+ "drop table crash_q,crash_q2 $drop_attr"))
+{
+ $dbh->do("drop table crash_q $drop_attr");
+ $dbh->do("drop table crash_q2 $drop_attr");
+}
+
+if (!report("drop table with cascade/restrict","drop_restrict",
+ "create table crash_q (a int)",
+ "drop table crash_q restrict"))
+{
+ $dbh->do("drop table crash_q $drop_attr");
+}
+
+
+report("-- as comment (ANSI)","comment_--",
+ "select * from crash_me -- Testing of comments");
+report("// as comment","comment_//",
+ "select * from crash_me // Testing of comments");
+report("# as comment","comment_#",
+ "select * from crash_me # Testing of comments");
+report("/* */ as comment","comment_/**/",
+ "select * from crash_me /* Testing of comments */");
+
+#
+# Check things that fails one some servers
+#
+
+# Empress can't insert empty strings in a char() field
+report("insert empty string","insert_empty_string",
+ create_table("crash_q",["a char(10) not null,b char(10)"],[]),
+ "insert into crash_q values ('','')",
+ "drop table crash_q $drop_attr");
+
+report("Having with alias","having_with_alias",
+ create_table("crash_q",["a integer"],[]),
+ "insert into crash_q values (10)",
+ "select sum(a) as b from crash_q group by a having b > 0",
+ "drop table crash_q $drop_attr");
+
+#
+# test name limits
+#
+
+find_limit("table name length","max_table_name",
+ new query_many(["create table crash_q%s (q integer)",
+ "insert into crash_q%s values(1)"],
+ "select * from crash_q%s",1,
+ ["drop table crash_q%s $drop_attr"],
+ $max_name_length,7,1));
+
+find_limit("column name length","max_column_name",
+ new query_many(["create table crash_q (q%s integer)",
+ "insert into crash_q (q%s) values(1)"],
+ "select q%s from crash_q",1,
+ ["drop table crash_q $drop_attr"],
+ $max_name_length,1));
+
+if ($limits{'column_alias'} eq 'yes')
+{
+ find_limit("select alias name length","max_select_alias_name",
+ new query_many(undef,
+ "select b as %s from crash_me",undef,
+ undef, $max_name_length));
+}
+
+find_limit("table alias name length","max_table_alias_name",
+ new query_many(undef,
+ "select %s.b from crash_me %s",
+ undef,
+ undef, $max_name_length));
+
+$end_drop_keyword = "drop index %i" if (!$end_drop_keyword);
+$end_drop=$end_drop_keyword;
+$end_drop =~ s/%i/crash_q%s/;
+$end_drop =~ s/%t/crash_me/;
+
+if ($limits{'create_index'} ne 'no')
+{
+ find_limit("index name length","max_index_name",
+ new query_many(["create index crash_q%s on crash_me (a)"],
+ undef,undef,
+ [$end_drop],
+ $max_name_length,7));
+}
+
+find_limit("max char() size","max_char_size",
+ new query_many(["create table crash_q (q char(%d))",
+ "insert into crash_q values ('%s')"],
+ "select * from crash_q","%s",
+ ["drop table crash_q $drop_attr"],
+ min($max_string_size,$limits{'query_size'})));
+
+if ($limits{'type_sql_varchar(1_arg)'} eq 'yes')
+{
+ find_limit("max varchar() size","max_varchar_size",
+ new query_many(["create table crash_q (q varchar(%d))",
+ "insert into crash_q values ('%s')"],
+ "select * from crash_q","%s",
+ ["drop table crash_q $drop_attr"],
+ min($max_string_size,$limits{'query_size'})));
+}
+
+$found=undef;
+foreach $type (('mediumtext','text','text()','blob','long'))
+{
+ if ($limits{"type_extra_$type"} eq 'yes')
+ {
+ $found=$type;
+ last;
+ }
+}
+if (defined($found))
+{
+ $found =~ s/\(\)/\(%d\)/;
+ find_limit("max text or blob size","max_text_size",
+ new query_many(["create table crash_q (q $found)",
+ "insert into crash_q values ('%s')"],
+ "select * from crash_q","%s",
+ ["drop table crash_q $drop_attr"],
+ min($max_string_size,$limits{'query_size'}-30)));
+
+}
+
+$tmp=new query_repeat([],"create table crash_q (a integer","","",
+ ",a%d integer","",")",["drop table crash_q $drop_attr"],
+ $max_columns);
+$tmp->{'offset'}=1;
+find_limit("Columns in table","max_columns",$tmp);
+
+# Make a field definition to be used when testing keys
+
+$key_definitions="q0 integer not null";
+$key_fields="q0";
+for ($i=1; $i < min($limits{'max_columns'},$max_keys) ; $i++)
+{
+ $key_definitions.=",q$i integer not null";
+ $key_fields.=",q$i";
+}
+$key_values="1," x $i;
+chop($key_values);
+
+if ($limits{'unique_in_create'} eq 'yes')
+{
+ find_limit("unique indexes","max_unique_index",
+ new query_table("create table crash_q (q integer",
+ ",q%d integer not null,unique (q%d)",")",
+ ["insert into crash_q (q,%f) values (1,%v)"],
+ "select q from crash_q",1,
+ "drop table crash_q $drop_attr",
+ $max_keys,0));
+
+ find_limit("index parts","max_index_parts",
+ new query_table("create table crash_q ".
+ "($key_definitions,unique (q0",
+ ",q%d","))",
+ ["insert into crash_q ($key_fields) values ($key_values)"],
+ "select q0 from crash_q",1,
+ "drop table crash_q $drop_attr",
+ $max_keys,1));
+
+ find_limit("max index part length","max_index_part_length",
+ new query_many(["create table crash_q (q char(%d) not null,".
+ "unique(q))",
+ "insert into crash_q (q) values ('%s')"],
+ "select q from crash_q","%s",
+ ["drop table crash_q $drop_attr"],
+ $limits{'max_char_size'},0));
+
+ if ($limits{'type_sql_varchar(1_arg)'} eq 'yes')
+ {
+ find_limit("index varchar part length","max_index_varchar_part_length",
+ new query_many(["create table crash_q (q varchar(%d) not null,".
+ "unique(q))",
+ "insert into crash_q (q) values ('%s')"],
+ "select q from crash_q","%s",
+ ["drop table crash_q $drop_attr"],
+ $limits{'max_varchar_size'},0));
+ }
+}
+
+
+if ($limits{'create_index'} ne 'no')
+{
+ if ($limits{'create_index'} eq 'ignored' ||
+ $limits{'unique_in_create'} eq 'yes')
+ { # This should be true
+ add_log('max_index',
+ " max_unique_index=$limits{'max_unique_index'} ,".
+ "so max_index must be same");
+ save_config_data('max_index',$limits{'max_unique_index'},"max index");
+ print "indexes: $limits{'max_index'}\n";
+ }
+ else
+ {
+ if (!defined($limits{'max_index'}))
+ {
+ safe_query_l('max_index',"create table crash_q ($key_definitions)");
+ for ($i=1; $i <= min($limits{'max_columns'},$max_keys) ; $i++)
+ {
+ last if (!safe_query_l('max_index',
+ "create index crash_q$i on crash_q (q$i)"));
+ }
+ save_config_data('max_index',$i == $max_keys ? $max_keys : $i,
+ "max index");
+ while ( --$i > 0)
+ {
+ $end_drop=$end_drop_keyword;
+ $end_drop =~ s/%i/crash_q$i/;
+ $end_drop =~ s/%t/crash_q/;
+ assert($end_drop);
+ }
+ assert("drop table crash_q $drop_attr");
+ }
+ print "indexs: $limits{'max_index'}\n";
+ if (!defined($limits{'max_unique_index'}))
+ {
+ safe_query_l('max_unique_index',
+ "create table crash_q ($key_definitions)");
+ for ($i=0; $i < min($limits{'max_columns'},$max_keys) ; $i++)
+ {
+ last if (!safe_query_l('max_unique_index',
+ "create unique index crash_q$i on crash_q (q$i)"));
+ }
+ save_config_data('max_unique_index',$i == $max_keys ? $max_keys : $i,
+ "max unique index");
+ while ( --$i >= 0)
+ {
+ $end_drop=$end_drop_keyword;
+ $end_drop =~ s/%i/crash_q$i/;
+ $end_drop =~ s/%t/crash_q/;
+ assert($end_drop);
+ }
+ assert("drop table crash_q $drop_attr");
+ }
+ print "unique indexes: $limits{'max_unique_index'}\n";
+ if (!defined($limits{'max_index_parts'}))
+ {
+ safe_query_l('max_index_parts',
+ "create table crash_q ($key_definitions)");
+ $end_drop=$end_drop_keyword;
+ $end_drop =~ s/%i/crash_q1%d/;
+ $end_drop =~ s/%t/crash_q/;
+ find_limit("index parts","max_index_parts",
+ new query_table("create index crash_q1%d on crash_q (q0",
+ ",q%d",")",
+ [],
+ undef,undef,
+ $end_drop,
+ $max_keys,1));
+ assert("drop table crash_q $drop_attr");
+ }
+ else
+ {
+ print "index parts: $limits{'max_index_parts'}\n";
+ }
+ $end_drop=$end_drop_keyword;
+ $end_drop =~ s/%i/crash_q2%d/;
+ $end_drop =~ s/%t/crash_me/;
+
+ find_limit("index part length","max_index_part_length",
+ new query_many(["create table crash_q (q char(%d))",
+ "create index crash_q2%d on crash_q (q)",
+ "insert into crash_q values('%s')"],
+ "select q from crash_q",
+ "%s",
+ [ $end_drop,
+ "drop table crash_q $drop_attr"],
+ min($limits{'max_char_size'},"+8192")));
+ }
+}
+
+find_limit("index length","max_index_length",
+ new query_index_length("create table crash_q ",
+ "drop table crash_q $drop_attr",
+ $max_key_length));
+
+find_limit("max table row length (without blobs)","max_row_length",
+ new query_row_length("crash_q ",
+ "not null",
+ "drop table crash_q $drop_attr",
+ min($max_row_length,
+ $limits{'max_columns'}*
+ min($limits{'max_char_size'},255))));
+
+find_limit("table row length with nulls (without blobs)",
+ "max_row_length_with_null",
+ new query_row_length("crash_q ",
+ "",
+ "drop table crash_q $drop_attr",
+ $limits{'max_row_length'}*2));
+
+find_limit("number of columns in order by","columns_in_order_by",
+ new query_many(["create table crash_q (%F)",
+ "insert into crash_q values(%v)",
+ "insert into crash_q values(%v)"],
+ "select * from crash_q order by %f",
+ undef(),
+ ["drop table crash_q $drop_attr"],
+ $max_order_by));
+
+find_limit("number of columns in group by","columns_in_group_by",
+ new query_many(["create table crash_q (%F)",
+ "insert into crash_q values(%v)",
+ "insert into crash_q values(%v)"],
+ "select %f from crash_q group by %f",
+ undef(),
+ ["drop table crash_q $drop_attr"],
+ $max_order_by));
+
+
+
+# Safe arithmetic test
+
+$prompt="safe decimal arithmetic";
+$key="safe_decimal_arithmetic";
+if (!defined($limits{$key}))
+{
+ print "$prompt=";
+ save_incomplete($key,$prompt);
+ if (!safe_query_l($key,$server->create("crash_me_a",
+ ["a decimal(10,2)","b decimal(10,2)"])))
+ {
+ print DBI->errstr();
+ die "Can't create table 'crash_me_a' $DBI::errstr\n";
+ };
+
+ if (!safe_query_l($key,
+ ["insert into crash_me_a (a,b) values (11.4,18.9)"]))
+ {
+ die "Can't insert into table 'crash_me_a' a record: $DBI::errstr\n";
+ };
+
+ $arithmetic_safe = 'no';
+ $arithmetic_safe = 'yes'
+ if ( (safe_query_result_l($key,
+ 'select count(*) from crash_me_a where a+b=30.3',1,0) == 0)
+ and (safe_query_result_l($key,
+ 'select count(*) from crash_me_a where a+b-30.3 = 0',1,0) == 0)
+ and (safe_query_result_l($key,
+ 'select count(*) from crash_me_a where a+b-30.3 < 0',0,0) == 0)
+ and (safe_query_result_l($key,
+ 'select count(*) from crash_me_a where a+b-30.3 > 0',0,0) == 0));
+ save_config_data($key,$arithmetic_safe,$prompt);
+ print "$arithmetic_safe\n";
+ assert("drop table crash_me_a $drop_attr");
+}
+ else
+{
+ print "$prompt=$limits{$key} (cached)\n";
+}
+
+# Check where is null values in sorted recordset
+if (!safe_query($server->create("crash_me_n",["i integer","r integer"])))
+ {
+ print DBI->errstr();
+ die "Can't create table 'crash_me_n' $DBI::errstr\n";
+ };
+
+safe_query_l("position_of_null",["insert into crash_me_n (i) values(1)",
+"insert into crash_me_n values(2,2)",
+"insert into crash_me_n values(3,3)",
+"insert into crash_me_n values(4,4)",
+"insert into crash_me_n (i) values(5)"]);
+
+$key = "position_of_null";
+$prompt ="Where is null values in sorted recordset";
+if (!defined($limits{$key}))
+{
+ save_incomplete($key,$prompt);
+ print "$prompt=";
+ $sth=$dbh->prepare("select r from crash_me_n order by r ");
+ $sth->execute;
+ add_log($key,"< select r from crash_me_n order by r ");
+ $limit= detect_null_position($key,$sth);
+ $sth->finish;
+ print "$limit\n";
+ save_config_data($key,$limit,$prompt);
+} else {
+ print "$prompt=$limits{$key} (cache)\n";
+}
+
+$key = "position_of_null_desc";
+$prompt ="Where is null values in sorted recordset (DESC)";
+if (!defined($limits{$key}))
+{
+ save_incomplete($key,$prompt);
+ print "$prompt=";
+ $sth=$dbh->prepare("select r from crash_me_n order by r desc");
+ $sth->execute;
+ add_log($key,"< select r from crash_me_n order by r desc");
+ $limit= detect_null_position($key,$sth);
+ $sth->finish;
+ print "$limit\n";
+ save_config_data($key,$limit,$prompt);
+} else {
+ print "$prompt=$limits{$key} (cache)\n";
+}
+
+
+assert("drop table crash_me_n $drop_attr");
+
+
+
+$key = 'sorted_group_by';
+$prompt = 'Group by always sorted';
+if (!defined($limits{$key}))
+{
+ save_incomplete($key,$prompt);
+ print "$prompt=";
+ safe_query_l($key,[
+ "create table crash_me_t1 (a int not null, b int not null)",
+ "insert into crash_me_t1 values (1,1)",
+ "insert into crash_me_t1 values (1,2)",
+ "insert into crash_me_t1 values (3,1)",
+ "insert into crash_me_t1 values (3,2)",
+ "insert into crash_me_t1 values (2,2)",
+ "insert into crash_me_t1 values (2,1)",
+ "create table crash_me_t2 (a int not null, b int not null)",
+ "create index crash_me_t2_ind on crash_me_t2 (a)",
+ "insert into crash_me_t2 values (1,3)",
+ "insert into crash_me_t2 values (3,1)",
+ "insert into crash_me_t2 values (2,2)",
+ "insert into crash_me_t2 values (1,1)"]);
+
+ my $bigqry = "select crash_me_t1.a,crash_me_t2.b from ".
+ "crash_me_t1,crash_me_t2 where crash_me_t1.a=crash_me_t2.a ".
+ "group by crash_me_t1.a,crash_me_t2.b";
+
+ my $limit='no';
+ my $rs = get_recordset($key,$bigqry);
+ print_recordset($key,$rs);
+ if ( defined ($rs)) {
+ if (compare_recordset($key,$rs,[[1,1],[1,3],[2,2],[3,1]]) eq 0)
+ {
+ $limit='yes'
+ }
+ } else {
+ add_log($key,"error: ".$DBI::errstr);
+ }
+
+ print "$limit\n";
+ safe_query_l($key,["drop table crash_me_t1",
+ "drop table crash_me_t2"]);
+ save_config_data($key,$limit,$prompt);
+
+} else {
+ print "$prompt=$limits{$key} (cashed)\n";
+}
+
+
+#
+# End of test
+#
+
+$dbh->do("drop table crash_me $drop_attr"); # Remove temporary table
+
+print "crash-me safe: $limits{'crash_me_safe'}\n";
+print "reconnected $reconnect_count times\n";
+
+$dbh->disconnect || warn $dbh->errstr;
+save_all_config_data();
+exit 0;
+
+# End of test
+#
+
+$dbh->do("drop table crash_me $drop_attr"); # Remove temporary table
+
+print "crash-me safe: $limits{'crash_me_safe'}\n";
+print "reconnected $reconnect_count times\n";
+
+$dbh->disconnect || warn $dbh->errstr;
+save_all_config_data();
+exit 0;
+
+# Check where is nulls in the sorted result (for)
+# it expects exactly 5 rows in the result
+
+sub detect_null_position
+{
+ my $key = shift;
+ my $sth = shift;
+ my ($z,$r1,$r2,$r3,$r4,$r5);
+ $r1 = $sth->fetchrow_array; add_log($key,"> $r1");
+ $r2 = $sth->fetchrow_array; add_log($key,"> $r2");
+ $r3 = $sth->fetchrow_array; add_log($key,"> $r3");
+ $r4 = $sth->fetchrow_array; add_log($key,"> $r4");
+ $r5 = $sth->fetchrow_array; add_log($key,"> $r5");
+ return "first" if ( !defined($r1) && !defined($r2) && defined($r3));
+ return "last" if ( !defined($r5) && !defined($r4) && defined($r3));
+ return "random";
+}
+
+sub check_parenthesis {
+ my $prefix=shift;
+ my $fn=shift;
+ my $result='no';
+ my $param_name=$prefix.lc($fn);
+ my $r;
+
+ save_incomplete($param_name,$fn);
+ $r = safe_query("select $fn $end_query");
+ add_log($param_name,$safe_query_log);
+ if ($r == 1)
+ {
+ $result="yes";
+ }
+ else{
+ $r = safe_query("select $fn() $end_query");
+ add_log($param_name,$safe_query_log);
+ if ( $r == 1)
+ {
+ $result="with_parenthesis";
+ }
+ }
+
+ save_config_data($param_name,$result,$fn);
+}
+
+sub check_constraint {
+ my $prompt = shift;
+ my $key = shift;
+ my $create = shift;
+ my $check = shift;
+ my $drop = shift;
+ save_incomplete($key,$prompt);
+ print "$prompt=";
+ my $res = 'no';
+ my $t;
+ $t=safe_query($create);
+ add_log($key,$safe_query_log);
+ if ( $t == 1)
+ {
+ $res='yes';
+ $t= safe_query($check);
+ add_log($key,$safe_query_log);
+ if ($t == 1)
+ {
+ $res='syntax only';
+ }
+ }
+ safe_query($drop);
+ add_log($key,$safe_query_log);
+
+ save_config_data($key,$res,$prompt);
+ print "$res\n";
+}
+
+sub make_time_r {
+ my $hour=shift;
+ my $minute=shift;
+ my $second=shift;
+ $_ = $limits{'time_format_inresult'};
+ return sprintf "%02d:%02d:%02d", ($hour%24),$minute,$second if (/^iso$/);
+ return sprintf "%02d.%02d.%02d", ($hour%24),$minute,$second if (/^euro/);
+ return sprintf "%02d:%02d %s",
+ ($hour >= 13? ($hour-12) : $hour),$minute,($hour >=13 ? 'PM':'AM')
+ if (/^usa/);
+ return sprintf "%02d%02d%02d", ($hour%24),$minute,$second if (/^HHMMSS/);
+ return sprintf "%04d%02d%02d", ($hour%24),$minute,$second if (/^HHHHMMSS/);
+ return "UNKNOWN FORMAT";
+}
+
+sub make_time {
+ my $hour=shift;
+ my $minute=shift;
+ my $second=shift;
+ return sprintf "%02d:%02d:%02d", ($hour%24),$minute,$second
+ if ($limits{'time_format_ISO'} eq "yes");
+ return sprintf "%02d.%02d.%02d", ($hour%24),$minute,$second
+ if ($limits{'time_format_EUR'} eq "yes");
+ return sprintf "%02d:%02d %s",
+ ($hour >= 13? ($hour-12) : $hour),$minute,($hour >=13 ? 'PM':'AM')
+ if ($limits{'time_format_USA'} eq "yes");
+ return sprintf "%02d%02d%02d", ($hour%24),$minute,$second
+ if ($limits{'time_format_HHMMSS'} eq "yes");
+ return sprintf "%04d%02d%02d", ($hour%24),$minute,$second
+ if ($limits{'time_format_HHHHMMSS'} eq "yes");
+ return "UNKNOWN FORMAT";
+}
+
+sub make_date_r {
+ my $year=shift;
+ my $month=shift;
+ my $day=shift;
+ $_ = $limits{'date_format_inresult'};
+ return sprintf "%02d-%02d-%02d", ($year%100),$month,$day if (/^short iso$/);
+ return sprintf "%04d-%02d-%02d", $year,$month,$day if (/^iso/);
+ return sprintf "%02d.%02d.%02d", $day,$month,($year%100) if (/^short euro/);
+ return sprintf "%02d.%02d.%04d", $day,$month,$year if (/^euro/);
+ return sprintf "%02d/%02d/%02d", $month,$day,($year%100) if (/^short usa/);
+ return sprintf "%02d/%02d/%04d", $month,$day,$year if (/^usa/);
+ return sprintf "%04d%02d%02d", $year,$month,$day if (/^YYYYMMDD/);
+ return "UNKNOWN FORMAT";
+}
+
+
+sub make_date {
+ my $year=shift;
+ my $month=shift;
+ my $day=shift;
+ return sprintf "'%04d-%02d-%02d'", $year,$month,$day
+ if ($limits{'date_format_ISO'} eq yes);
+ return sprintf "DATE '%04d-%02d-%02d'", $year,$month,$day
+ if ($limits{'date_format_ISO_with_date'} eq yes);
+ return sprintf "'%02d.%02d.%04d'", $day,$month,$year
+ if ($limits{'date_format_EUR'} eq 'yes');
+ return sprintf "DATE '%02d.%02d.%04d'", $day,$month,$year
+ if ($limits{'date_format_EUR_with_date'} eq 'yes');
+ return sprintf "'%02d/%02d/%04d'", $month,$day,$year
+ if ($limits{'date_format_USA'} eq 'yes');
+ return sprintf "DATE '%02d/%02d/%04d'", $month,$day,$year
+ if ($limits{'date_format_USA_with_date'} eq 'yes');
+ return sprintf "'%04d%02d%02d'", $year,$month,$day
+ if ($limits{'date_format_YYYYMMDD'} eq 'yes');
+ return sprintf "DATE '%04d%02d%02d'", $year,$month,$day
+ if ($limits{'date_format_YYYYMMDD_with_date'} eq 'yes');
+ return "UNKNOWN FORMAT";
+}
+
+
+sub print_recordset{
+ my ($key,$recset) = @_;
+ my $rec;
+ foreach $rec (@$recset)
+ {
+ add_log($key, " > ".join(',', map(repr($_), @$rec)));
+ }
+}
+
+#
+# read result recordset from sql server.
+# returns arrayref to (arrayref to) values
+# or undef (in case of sql errors)
+#
+sub get_recordset{
+ my ($key,$query) = @_;
+ add_log($key, "< $query");
+ return $dbh->selectall_arrayref($query);
+}
+
+# function for comparing recordset (that was returned by get_recordset)
+# and arrayref of (arrayref of) values.
+#
+# returns : zero if recordset equal that array, 1 if it doesn't equal
+#
+# parameters:
+# $key - current operation (for logging)
+# $recset - recordset
+# $mustbe - array of values that we expect
+#
+# example: $a=get_recordset('some_parameter','select a,b from c');
+# if (compare_recordset('some_parameter',$a,[[1,1],[1,2],[1,3]]) neq 0)
+# {
+# print "unexpected result\n";
+# } ;
+#
+sub compare_recordset {
+ my ($key,$recset,$mustbe) = @_;
+ my $rec,$recno,$fld,$fldno,$fcount;
+ add_log($key,"\n Check recordset:");
+ $recno=0;
+ foreach $rec (@$recset)
+ {
+ add_log($key," " . join(',', map(repr($_),@$rec)) . " expected: " .
+ join(',', map(repr($_), @{$mustbe->[$recno]} ) ));
+ $fcount = @$rec;
+ $fcount--;
+ foreach $fldno (0 .. $fcount )
+ {
+ if ($mustbe->[$recno][$fldno] ne $rec->[$fldno])
+ {
+ add_log($key," Recordset doesn't correspond with template");
+ return 1;
+ };
+ }
+ $recno++;
+ }
+ add_log($key," Recordset corresponds with template");
+ return 0;
+}
+
+#
+# converts inner perl value to printable representation
+# for example: undef maps to 'NULL',
+# string -> 'string'
+# int -> int
+#
+sub repr {
+ my $s = shift;
+ return "'$s'"if ($s =~ /\D/);
+ return 'NULL'if ( not defined($s));
+ return $s;
+}
+
+
+sub version
+{
+ print "$0 Ver $version\n";
+}
+
+
+sub usage
+{
+ version();
+ print <<EOF;
+
+This program tries to find all limits and capabilities for a SQL
+server. As it will use the server in some 'unexpected' ways, one
+shouldn\'t have anything important running on it at the same time this
+program runs! There is a slight chance that something unexpected may
+happen....
+
+As all used queries are legal according to some SQL standard. any
+reasonable SQL server should be able to run this test without any
+problems.
+
+All questions is cached in $opt_dir/'server_name'[-suffix].cfg that
+future runs will use limits found in previous runs. Remove this file
+if you want to find the current limits for your version of the
+database server.
+
+This program uses some table names while testing things. If you have any
+tables with the name of 'crash_me' or 'crash_qxxxx' where 'x' is a number,
+they will be deleted by this test!
+
+$0 takes the following options:
+
+--help or --Information
+ Shows this help
+
+--batch-mode
+ Don\'t ask any questions, quit on errors.
+
+--config-file='filename'
+ Read limit results from specific file
+
+--comment='some comment'
+ Add this comment to the crash-me limit file
+
+--check-server
+ Do a new connection to the server every time crash-me checks if the server
+ is alive. This can help in cases where the server starts returning wrong
+ data because of an earlier select.
+
+--database='database' (Default $opt_database)
+ Create test tables in this database.
+
+--dir='limits'
+ Save crash-me output in this directory
+
+--debug
+ Lots of printing to help debugging if something goes wrong.
+
+--fix-limit-file
+ Reformat the crash-me limit file. crash-me is not run!
+
+--force
+ Start test at once, without a warning screen and without questions.
+ This is a option for the very brave.
+ Use this in your cron scripts to test your database every night.
+
+--log-all-queries
+ Prints all queries that are executed. Mostly used for debugging crash-me.
+
+--log-queries-to-file='filename'
+ Log full queries to file.
+
+--host='hostname' (Default $opt_host)
+ Run tests on this host.
+
+--password='password'
+ Password for the current user.
+
+--restart
+ Save states during each limit tests. This will make it possible to continue
+ by restarting with the same options if there is some bug in the DBI or
+ DBD driver that caused $0 to die!
+
+--server='server name' (Default $opt_server)
+ Run the test on the given server.
+ Known servers names are: Access, Adabas, AdabasD, Empress, Oracle,
+ Informix, DB2, Mimer, mSQL, MS-SQL, MySQL, Pg, Solid or Sybase.
+ For others $0 can\'t report the server version.
+
+--suffix='suffix' (Default '')
+ Add suffix to the output filename. For instance if you run crash-me like
+ "crash-me --suffix="myisam",
+ then output filename will look "mysql-myisam.cfg".
+
+--user='user_name'
+ User name to log into the SQL server.
+
+--db-start-cmd='command to restart server'
+ Automaticly restarts server with this command if the database server dies.
+
+--sleep='time in seconds' (Default $opt_sleep)
+ Wait this long before restarting server.
+
+--verbose
+ Log into the result file queries performed for determination parameter value
+ This causes rows starting with ' ###' to be logged into the .cnf file
+
+--noverbose
+ Don't log '###' quries to the .cnf file.
+
+EOF
+ exit(0);
+}
+
+
+sub server_info
+{
+ my ($ok,$tmp);
+ $ok=0;
+ print "\nNOTE: You should be familiar with '$0 --help' before continuing!\n\n";
+ if (lc($opt_server) eq "mysql")
+ {
+ $ok=1;
+ print <<EOF;
+This test should not crash MySQL if it was distributed together with the
+running MySQL version.
+If this is the case you can probably continue without having to worry about
+destroying something.
+EOF
+ }
+ elsif (lc($opt_server) eq "msql")
+ {
+ print <<EOF;
+This test will take down mSQL repeatedly while finding limits.
+To make this test easier, start mSQL in another terminal with something like:
+
+while (true); do /usr/local/mSQL/bin/msql2d ; done
+
+You should be sure that no one is doing anything important with mSQL and that
+you have privileges to restart it!
+It may take awhile to determinate the number of joinable tables, so prepare to
+wait!
+EOF
+ }
+ elsif (lc($opt_server) eq "solid")
+ {
+ print <<EOF;
+This test will take down Solid server repeatedly while finding limits.
+You should be sure that no one is doing anything important with Solid
+and that you have privileges to restart it!
+
+If you are running Solid without logging and/or backup YOU WILL LOSE!
+Solid does not write data from the cache often enough. So if you continue
+you may lose tables and data that you entered hours ago!
+
+Solid will also take a lot of memory running this test. You will nead
+at least 234M free!
+
+When doing the connect test Solid server or the perl api will hang when
+freeing connections. Kill this program and restart it to continue with the
+test. You don\'t have to use --restart for this case.
+EOF
+ if (!$opt_restart)
+ {
+ print "\nWhen DBI/Solid dies you should run this program repeatedly\n";
+ print "with --restart until all tests have completed\n";
+ }
+ }
+ elsif (lc($opt_server) eq "pg")
+ {
+ print <<EOF;
+This test will crash postgreSQL when calculating the number of joinable tables!
+You should be sure that no one is doing anything important with postgreSQL
+and that you have privileges to restart it!
+EOF
+ }
+ else
+ {
+ print <<EOF;
+This test may crash $opt_server repeatedly while finding limits!
+You should be sure that no one is doing anything important with $opt_server
+and that you have privileges to restart it!
+EOF
+ }
+ print <<EOF;
+
+Some of the tests you are about to execute may require a lot of
+memory. Your tests WILL adversely affect system performance. It\'s
+not uncommon that either this crash-me test program, or the actual
+database back-end, will DIE with an out-of-memory error. So might
+any other program on your system if it requests more memory at the
+wrong time.
+
+Note also that while crash-me tries to find limits for the database server
+it will make a lot of queries that can\'t be categorized as \'normal\'. It\'s
+not unlikely that crash-me finds some limit bug in your server so if you
+run this test you have to be prepared that your server may die during it!
+
+We, the creators of this utility, are not responsible in any way if your
+database server unexpectedly crashes while this program tries to find the
+limitations of your server. By accepting the following question with \'yes\',
+you agree to the above!
+
+You have been warned!
+
+EOF
+
+ #
+ # No default reply here so no one can blame us for starting the test
+ # automaticly.
+ #
+ for (;;)
+ {
+ print "Start test (yes/no) ? ";
+ $tmp=<STDIN>; chomp($tmp); $tmp=lc($tmp);
+ last if ($tmp =~ /^yes$/i);
+ exit 1 if ($tmp =~ /^n/i);
+ print "\n";
+ }
+}
+
+sub machine
+{
+ my @name = POSIX::uname();
+ my $name= $name[0] . " " . $name[2] . " " . $name[4];
+ return $name;
+}
+
+
+#
+# Help functions that we need
+#
+
+sub safe_connect
+{
+ my ($object)=@_;
+ my ($dbh,$tmp);
+
+ for (;;)
+ {
+ if (($dbh=DBI->connect($server->{'data_source'},$opt_user,$opt_password,
+ { PrintError => 0, AutoCommit => 1})))
+ {
+ $dbh->{LongReadLen}= 16000000; # Set max retrieval buffer
+ return $dbh;
+ }
+ print "Error: $DBI::errstr; $server->{'data_source'} ".
+ " - '$opt_user' - '$opt_password'\n";
+ print "I got the above error when connecting to $opt_server\n";
+ if (defined($object) && defined($object->{'limit'}))
+ {
+ print "This check was done with limit: $object->{'limit'}.".
+ "\nNext check will be done with a smaller limit!\n";
+ $object=undef();
+ }
+ save_config_data('crash_me_safe','no',"crash me safe");
+ if ($opt_db_start_cmd)
+ {
+ print "Restarting the db server with:\n'$opt_db_start_cmd'\n";
+ system("$opt_db_start_cmd");
+ print "Waiting $opt_sleep seconds so the server can initialize\n";
+ sleep $opt_sleep;
+ }
+ else
+ {
+ exit(1) if ($opt_batch_mode);
+ print "Can you check/restart it so I can continue testing?\n";
+ for (;;)
+ {
+ print "Continue test (yes/no) ? [yes] ";
+ $tmp=<STDIN>; chomp($tmp); $tmp=lc($tmp);
+ $tmp = "yes" if ($tmp eq "");
+ last if (index("yes",$tmp) >= 0);
+ exit 1 if (index("no",$tmp) >= 0);
+ print "\n";
+ }
+ }
+ }
+}
+
+#
+# Test connecting a couple of times before giving an error
+# This is needed to get the server time to free old connections
+# after the connect test
+#
+
+sub retry_connect
+{
+ my ($dbh, $i);
+ for ($i=0 ; $i < 10 ; $i++)
+ {
+ if (($dbh=DBI->connect($server->{'data_source'},$opt_user,$opt_password,
+ { PrintError => 0, AutoCommit => 1})))
+ {
+ $dbh->{LongReadLen}= 16000000; # Set max retrieval buffer
+ return $dbh;
+ }
+ sleep(1);
+ }
+ return safe_connect();
+}
+
+#
+# Check if the server is up and running. If not, ask the user to restart it
+#
+
+sub check_connect
+{
+ my ($object)=@_;
+ my ($sth);
+ print "Checking connection\n" if ($opt_log_all_queries);
+ # The following line will not work properly with interbase
+ if ($opt_check_server && defined($check_connect) && $dbh->{AutoCommit} != 0)
+ {
+
+ $dbh->disconnect;
+ $dbh=safe_connect($object);
+ return;
+ }
+ return if (defined($check_connect) && defined($dbh->do($check_connect)));
+ $dbh->disconnect || warn $dbh->errstr;
+ print "\nreconnecting\n" if ($opt_debug);
+ $reconnect_count++;
+ undef($dbh);
+ $dbh=safe_connect($object);
+}
+
+#
+# print query if debugging
+#
+sub repr_query {
+ my $query=shift;
+ if (length($query) > 130)
+ {
+ $query=substr($query,0,120) . "...(" . (length($query)-120) . ")";
+ }
+ return $query;
+}
+
+sub print_query
+{
+ my ($query)=@_;
+ $last_error=$DBI::errstr;
+ if ($opt_debug)
+ {
+ if (length($query) > 130)
+ {
+ $query=substr($query,0,120) . "...(" . (length($query)-120) . ")";
+ }
+ printf "\nGot error from query: '%s'\n%s\n",$query,$DBI::errstr;
+ }
+}
+
+#
+# Do one or many queries. Return 1 if all was ok
+# Note that all rows are executed
+# (to ensure that we execute drop table commands)
+#
+
+sub safe_query_l {
+ my $key = shift;
+ my $q = shift;
+ my $r = safe_query($q);
+ add_log($key,$safe_query_log);
+ return $r;
+}
+
+sub safe_query
+{
+ my($queries)=@_;
+ my($query,$ok,$retry_ok,$retry,@tmp,$sth);
+ $safe_query_log="";
+ $ok=1;
+ if (ref($queries) ne "ARRAY")
+ {
+ push(@tmp,$queries);
+ $queries= \@tmp;
+ }
+ foreach $query (@$queries)
+ {
+ printf "query1: %-80.80s ...(%d - %d)\n",$query,
+ length($query),$retry_limit if ($opt_log_all_queries);
+ print LOG "$query;\n" if ($opt_log);
+ $safe_query_log .= "< $query\n";
+ if (length($query) > $query_size)
+ {
+ $ok=0;
+ $safe_query_log .= "Query is too long\n";
+ next;
+ }
+
+ $retry_ok=0;
+ for ($retry=0; $retry < $retry_limit ; $retry++)
+ {
+ if (! ($sth=$dbh->prepare($query)))
+ {
+ print_query($query);
+ $safe_query_log .= "> couldn't prepare:". $dbh->errstr. "\n";
+ $retry=100 if (!$server->abort_if_fatal_error());
+ # Force a reconnect because of Access drop table bug!
+ if ($retry == $retry_limit-2)
+ {
+ print "Forcing disconnect to retry query\n" if ($opt_debug);
+ $dbh->disconnect || warn $dbh->errstr;
+ }
+ check_connect(); # Check that server is still up
+ }
+ else
+ {
+ if (!$sth->execute())
+ {
+ print_query($query);
+ $safe_query_log .= "> execute error:". $dbh->errstr. "\n";
+ $retry=100 if (!$server->abort_if_fatal_error());
+ # Force a reconnect because of Access drop table bug!
+ if ($retry == $retry_limit-2)
+ {
+ print "Forcing disconnect to retry query\n" if ($opt_debug);
+ $dbh->disconnect || warn $dbh->errstr;
+ }
+ check_connect(); # Check that server is still up
+ }
+ else
+ {
+ $retry = $retry_limit;
+ $retry_ok = 1;
+ $safe_query_log .= "> OK\n";
+ }
+ $sth->finish;
+ }
+ }
+ $ok=0 if (!$retry_ok);
+ if ($query =~ /create/i && $server->reconnect_on_errors())
+ {
+ print "Forcing disconnect to retry query\n" if ($opt_debug);
+ $dbh->disconnect || warn $dbh->errstr;
+ $dbh=safe_connect();
+ }
+ }
+ return $ok;
+}
+
+sub check_reserved_words
+{
+ my ($dbh)= @_;
+
+ my $answer, $prompt, $config, $keyword_type;
+
+ my @keywords_ext = ( "ansi-92/99", "ansi92", "ansi99", "extra");
+
+ my %reserved_words = (
+ 'ABSOLUTE' => 0, 'ACTION' => 0, 'ADD' => 0,
+ 'AFTER' => 0, 'ALIAS' => 0, 'ALL' => 0,
+ 'ALLOCATE' => 0, 'ALTER' => 0, 'AND' => 0,
+ 'ANY' => 0, 'ARE' => 0, 'AS' => 0,
+ 'ASC' => 0, 'ASSERTION' => 0, 'AT' => 0,
+ 'AUTHORIZATION' => 0, 'BEFORE' => 0, 'BEGIN' => 0,
+ 'BIT' => 0, 'BOOLEAN' => 0, 'BOTH' => 0,
+ 'BREADTH' => 0, 'BY' => 0, 'CALL' => 0,
+ 'CASCADE' => 0, 'CASCADED' => 0, 'CASE' => 0,
+ 'CAST' => 0, 'CATALOG' => 0, 'CHAR' => 0,
+ 'CHARACTER' => 0, 'CHECK' => 0, 'CLOSE' => 0,
+ 'COLLATE' => 0, 'COLLATION' => 0, 'COLUMN' => 0,
+ 'COMMIT' => 0, 'COMPLETION' => 0, 'CONNECT' => 0,
+ 'CONNECTION' => 0, 'CONSTRAINT' => 0, 'CONSTRAINTS' => 0,
+ 'CONTINUE' => 0, 'CORRESPONDING' => 0, 'CREATE' => 0,
+ 'CROSS' => 0, 'CURRENT' => 0, 'CURRENT_DATE' => 0,
+ 'CURRENT_TIME' => 0,'CURRENT_TIMESTAMP' => 0, 'CURRENT_USER' => 0,
+ 'CURSOR' => 0, 'CYCLE' => 0, 'DATA' => 0,
+ 'DATE' => 0, 'DAY' => 0, 'DEALLOCATE' => 0,
+ 'DEC' => 0, 'DECIMAL' => 0, 'DECLARE' => 0,
+ 'DEFAULT' => 0, 'DEFERRABLE' => 0, 'DEFERRED' => 0,
+ 'DELETE' => 0, 'DEPTH' => 0, 'DESC' => 0,
+ 'DESCRIBE' => 0, 'DESCRIPTOR' => 0, 'DIAGNOSTICS' => 0,
+ 'DICTIONARY' => 0, 'DISCONNECT' => 0, 'DISTINCT' => 0,
+ 'DOMAIN' => 0, 'DOUBLE' => 0, 'DROP' => 0,
+ 'EACH' => 0, 'ELSE' => 0, 'ELSEIF' => 0,
+ 'END' => 0, 'END-EXEC' => 0, 'EQUALS' => 0,
+ 'ESCAPE' => 0, 'EXCEPT' => 0, 'EXCEPTION' => 0,
+ 'EXEC' => 0, 'EXECUTE' => 0, 'EXTERNAL' => 0,
+ 'FALSE' => 0, 'FETCH' => 0, 'FIRST' => 0,
+ 'FLOAT' => 0, 'FOR' => 0, 'FOREIGN' => 0,
+ 'FOUND' => 0, 'FROM' => 0, 'FULL' => 0,
+ 'GENERAL' => 0, 'GET' => 0, 'GLOBAL' => 0,
+ 'GO' => 0, 'GOTO' => 0, 'GRANT' => 0,
+ 'GROUP' => 0, 'HAVING' => 0, 'HOUR' => 0,
+ 'IDENTITY' => 0, 'IF' => 0, 'IGNORE' => 0,
+ 'IMMEDIATE' => 0, 'IN' => 0, 'INDICATOR' => 0,
+ 'INITIALLY' => 0, 'INNER' => 0, 'INPUT' => 0,
+ 'INSERT' => 0, 'INT' => 0, 'INTEGER' => 0,
+ 'INTERSECT' => 0, 'INTERVAL' => 0, 'INTO' => 0,
+ 'IS' => 0, 'ISOLATION' => 0, 'JOIN' => 0,
+ 'KEY' => 0, 'LANGUAGE' => 0, 'LAST' => 0,
+ 'LEADING' => 0, 'LEAVE' => 0, 'LEFT' => 0,
+ 'LESS' => 0, 'LEVEL' => 0, 'LIKE' => 0,
+ 'LIMIT' => 0, 'LOCAL' => 0, 'LOOP' => 0,
+ 'MATCH' => 0, 'MINUTE' => 0, 'MODIFY' => 0,
+ 'MODULE' => 0, 'MONTH' => 0, 'NAMES' => 0,
+ 'NATIONAL' => 0, 'NATURAL' => 0, 'NCHAR' => 0,
+ 'NEW' => 0, 'NEXT' => 0, 'NO' => 0,
+ 'NONE' => 0, 'NOT' => 0, 'NULL' => 0,
+ 'NUMERIC' => 0, 'OBJECT' => 0, 'OF' => 0,
+ 'OFF' => 0, 'OLD' => 0, 'ON' => 0,
+ 'ONLY' => 0, 'OPEN' => 0, 'OPERATION' => 0,
+ 'OPTION' => 0, 'OR' => 0, 'ORDER' => 0,
+ 'OUTER' => 0, 'OUTPUT' => 0, 'PAD' => 0,
+ 'PARAMETERS' => 0, 'PARTIAL' => 0, 'PRECISION' => 0,
+ 'PREORDER' => 0, 'PREPARE' => 0, 'PRESERVE' => 0,
+ 'PRIMARY' => 0, 'PRIOR' => 0, 'PRIVILEGES' => 0,
+ 'PROCEDURE' => 0, 'PUBLIC' => 0, 'READ' => 0,
+ 'REAL' => 0, 'RECURSIVE' => 0, 'REF' => 0,
+ 'REFERENCES' => 0, 'REFERENCING' => 0, 'RELATIVE' => 0,
+ 'RESIGNAL' => 0, 'RESTRICT' => 0, 'RETURN' => 0,
+ 'RETURNS' => 0, 'REVOKE' => 0, 'RIGHT' => 0,
+ 'ROLE' => 0, 'ROLLBACK' => 0, 'ROUTINE' => 0,
+ 'ROW' => 0, 'ROWS' => 0, 'SAVEPOINT' => 0,
+ 'SCHEMA' => 0, 'SCROLL' => 0, 'SEARCH' => 0,
+ 'SECOND' => 0, 'SECTION' => 0, 'SELECT' => 0,
+ 'SEQUENCE' => 0, 'SESSION' => 0, 'SESSION_USER' => 0,
+ 'SET' => 0, 'SIGNAL' => 0, 'SIZE' => 0,
+ 'SMALLINT' => 0, 'SOME' => 0, 'SPACE' => 0,
+ 'SQL' => 0, 'SQLEXCEPTION' => 0, 'SQLSTATE' => 0,
+ 'SQLWARNING' => 0, 'STRUCTURE' => 0, 'SYSTEM_USER' => 0,
+ 'TABLE' => 0, 'TEMPORARY' => 0, 'THEN' => 0,
+ 'TIME' => 0, 'TIMESTAMP' => 0, 'TIMEZONE_HOUR' => 0,
+ 'TIMEZONE_MINUTE' => 0, 'TO' => 0, 'TRAILING' => 0,
+ 'TRANSACTION' => 0, 'TRANSLATION' => 0, 'TRIGGER' => 0,
+ 'TRUE' => 0, 'UNDER' => 0, 'UNION' => 0,
+ 'UNIQUE' => 0, 'UNKNOWN' => 0, 'UPDATE' => 0,
+ 'USAGE' => 0, 'USER' => 0, 'USING' => 0,
+ 'VALUE' => 0, 'VALUES' => 0, 'VARCHAR' => 0,
+ 'VARIABLE' => 0, 'VARYING' => 0, 'VIEW' => 0,
+ 'WHEN' => 0, 'WHENEVER' => 0, 'WHERE' => 0,
+ 'WHILE' => 0, 'WITH' => 0, 'WITHOUT' => 0,
+ 'WORK' => 0, 'WRITE' => 0, 'YEAR' => 0,
+ 'ZONE' => 0,
+
+ 'ASYNC' => 1, 'AVG' => 1, 'BETWEEN' => 1,
+ 'BIT_LENGTH' => 1,'CHARACTER_LENGTH' => 1, 'CHAR_LENGTH' => 1,
+ 'COALESCE' => 1, 'CONVERT' => 1, 'COUNT' => 1,
+ 'EXISTS' => 1, 'EXTRACT' => 1, 'INSENSITIVE' => 1,
+ 'LOWER' => 1, 'MAX' => 1, 'MIN' => 1,
+ 'NULLIF' => 1, 'OCTET_LENGTH' => 1, 'OID' => 1,
+ 'OPERATORS' => 1, 'OTHERS' => 1, 'OVERLAPS' => 1,
+ 'PENDANT' => 1, 'POSITION' => 1, 'PRIVATE' => 1,
+ 'PROTECTED' => 1, 'REPLACE' => 1, 'SENSITIVE' => 1,
+ 'SIMILAR' => 1, 'SQLCODE' => 1, 'SQLERROR' => 1,
+ 'SUBSTRING' => 1, 'SUM' => 1, 'TEST' => 1,
+ 'THERE' => 1, 'TRANSLATE' => 1, 'TRIM' => 1,
+ 'TYPE' => 1, 'UPPER' => 1, 'VIRTUAL' => 1,
+ 'VISIBLE' => 1, 'WAIT' => 1,
+
+ 'ADMIN' => 2, 'AGGREGATE' => 2, 'ARRAY' => 2,
+ 'BINARY' => 2, 'BLOB' => 2, 'CLASS' => 2,
+ 'CLOB' => 2, 'CONDITION' => 2, 'CONSTRUCTOR' => 2,
+ 'CONTAINS' => 2, 'CUBE' => 2, 'CURRENT_PATH' => 2,
+ 'CURRENT_ROLE' => 2, 'DATALINK' => 2, 'DEREF' => 2,
+ 'DESTROY' => 2, 'DESTRUCTOR' => 2, 'DETERMINISTIC' => 2,
+ 'DO' => 2, 'DYNAMIC' => 2, 'EVERY' => 2,
+ 'EXIT' => 2, 'EXPAND' => 2, 'EXPANDING' => 2,
+ 'FREE' => 2, 'FUNCTION' => 2, 'GROUPING' => 2,
+ 'HANDLER' => 2, 'HAST' => 2, 'HOST' => 2,
+ 'INITIALIZE' => 2, 'INOUT' => 2, 'ITERATE' => 2,
+ 'LARGE' => 2, 'LATERAL' => 2, 'LOCALTIME' => 2,
+ 'LOCALTIMESTAMP' => 2, 'LOCATOR' => 2, 'MEETS' => 2,
+ 'MODIFIES' => 2, 'NCLOB' => 2, 'NORMALIZE' => 2,
+ 'ORDINALITY' => 2, 'OUT' => 2, 'PARAMETER' => 2,
+ 'PATH' => 2, 'PERIOD' => 2, 'POSTFIX' => 2,
+ 'PRECEDES' => 2, 'PREFIX' => 2, 'READS' => 2,
+ 'REDO' => 2, 'REPEAT' => 2, 'RESULT' => 2,
+ 'ROLLUP' => 2, 'SETS' => 2, 'SPECIFIC' => 2,
+ 'SPECIFICTYPE' => 2, 'START' => 2, 'STATE' => 2,
+ 'STATIC' => 2, 'SUCCEEDS' => 2, 'TERMINATE' => 2,
+ 'THAN' => 2, 'TREAT' => 2, 'UNDO' => 2,
+ 'UNTIL' => 2,
+
+ 'ACCESS' => 3, 'ANALYZE' => 3, 'AUDIT' => 3,
+ 'AUTO_INCREMENT' => 3, 'BACKUP' => 3, 'BDB' => 3,
+ 'BERKELEYDB' => 3, 'BIGINT' => 3, 'BREAK' => 3,
+ 'BROWSE' => 3, 'BTREE' => 3, 'BULK' => 3,
+ 'CHANGE' => 3, 'CHECKPOINT' => 3, 'CLUSTER' => 3,
+ 'CLUSTERED' => 3, 'COLUMNS' => 3, 'COMMENT' => 3,
+ 'COMPRESS' => 3, 'COMPUTE' => 3, 'CONTAINSTABLE' => 3,
+ 'DATABASE' => 3, 'DATABASES' => 3, 'DAY_HOUR' => 3,
+ 'DAY_MINUTE' => 3, 'DAY_SECOND' => 3, 'DBCC' => 3,
+ 'DELAYED' => 3, 'DENY' => 3, 'DISK' => 3,
+ 'DISTINCTROW' => 3, 'DISTRIBUTED' => 3, 'DUMMY' => 3,
+ 'DUMP' => 3, 'ENCLOSED' => 3, 'ERRLVL' => 3,
+ 'ERRORS' => 3, 'ESCAPED' => 3, 'EXCLUSIVE' => 3,
+ 'EXPLAIN' => 3, 'FIELDS' => 3, 'FILE' => 3,
+ 'FILLFACTOR' => 3, 'FREETEXT' => 3, 'FREETEXTTABLE' => 3,
+ 'FULLTEXT' => 3, 'GEOMETRY' => 3, 'HASH' => 3,
+ 'HIGH_PRIORITY' => 3, 'HOLDLOCK' => 3, 'HOUR_MINUTE' => 3,
+ 'HOUR_SECOND' => 3, 'IDENTIFIED' => 3, 'IDENTITYCOL' => 3,
+ 'IDENTITY_INSERT' => 3, 'INCREMENT' => 3, 'INDEX' => 3,
+ 'INFILE' => 3, 'INITIAL' => 3, 'INNODB' => 3,
+ 'KEYS' => 3, 'KILL' => 3, 'LINENO' => 3,
+ 'LINES' => 3, 'LOAD' => 3, 'LOCK' => 3,
+ 'LONG' => 3, 'LONGBLOB' => 3, 'LONGTEXT' => 3,
+ 'LOW_PRIORITY' => 3, 'MASTER_SERVER_ID' => 3, 'MAXEXTENTS' => 3,
+ 'MEDIUMBLOB' => 3, 'MEDIUMINT' => 3, 'MEDIUMTEXT' => 3,
+ 'MIDDLEINT' => 3, 'MINUS' => 3, 'MINUTE_SECOND' => 3,
+ 'MLSLABEL' => 3, 'MODE' => 3, 'MRG_MYISAM' => 3,
+ 'NOAUDIT' => 3, 'NOCHECK' => 3, 'NOCOMPRESS' => 3,
+ 'NONCLUSTERED' => 3, 'NOWAIT' => 3, 'NUMBER' => 3,
+ 'OFFLINE' => 3, 'OFFSETS' => 3, 'ONLINE' => 3,
+ 'OPENDATASOURCE' => 3, 'OPENQUERY' => 3, 'OPENROWSET' => 3,
+ 'OPENXML' => 3, 'OPTIMIZE' => 3, 'OPTIONALLY' => 3,
+ 'OUTFILE' => 3, 'OVER' => 3, 'PCTFREE' => 3,
+ 'PERCENT' => 3, 'PLAN' => 3, 'PRINT' => 3,
+ 'PROC' => 3, 'PURGE' => 3, 'RAISERROR' => 3,
+ 'RAW' => 3, 'READTEXT' => 3, 'RECONFIGURE' => 3,
+ 'REGEXP' => 3, 'RENAME' => 3, 'REPLICATION' => 3,
+ 'REQUIRE' => 3, 'RESOURCE' => 3, 'RESTORE' => 3,
+ 'RLIKE' => 3, 'ROWCOUNT' => 3, 'ROWGUIDCOL' => 3,
+ 'ROWID' => 3, 'ROWNUM' => 3, 'RTREE' => 3,
+ 'RULE' => 3, 'SAVE' => 3, 'SETUSER' => 3,
+ 'SHARE' => 3, 'SHOW' => 3, 'SHUTDOWN' => 3,
+ 'SONAME' => 3, 'SPATIAL' => 3, 'SQL_BIG_RESULT' => 3,
+'SQL_CALC_FOUND_ROWS' => 3,'SQL_SMALL_RESULT' => 3, 'SSL' => 3,
+ 'STARTING' => 3, 'STATISTICS' => 3, 'STRAIGHT_JOIN' => 3,
+ 'STRIPED' => 3, 'SUCCESSFUL' => 3, 'SYNONYM' => 3,
+ 'SYSDATE' => 3, 'TABLES' => 3, 'TERMINATED' => 3,
+ 'TEXTSIZE' => 3, 'TINYBLOB' => 3, 'TINYINT' => 3,
+ 'TINYTEXT' => 3, 'TOP' => 3, 'TRAN' => 3,
+ 'TRUNCATE' => 3, 'TSEQUAL' => 3, 'TYPES' => 3,
+ 'UID' => 3, 'UNLOCK' => 3, 'UNSIGNED' => 3,
+ 'UPDATETEXT' => 3, 'USE' => 3, 'USER_RESOURCES' => 3,
+ 'VALIDATE' => 3, 'VARBINARY' => 3, 'VARCHAR2' => 3,
+ 'WAITFOR' => 3, 'WARNINGS' => 3, 'WRITETEXT' => 3,
+ 'XOR' => 3, 'YEAR_MONTH' => 3, 'ZEROFILL' => 3
+);
+
+
+ safe_query("drop table crash_me10 $drop_attr");
+
+ foreach my $keyword (sort {$a cmp $b} keys %reserved_words)
+ {
+ $keyword_type= $reserved_words{$keyword};
+
+ $prompt= "Keyword ".$keyword;
+ $config= "reserved_word_".$keywords_ext[$keyword_type]."_".lc($keyword);
+
+ report_fail($prompt,$config,
+ "create table crash_me10 ($keyword int not null)",
+ "drop table crash_me10 $drop_attr"
+ );
+ }
+}
+
+#
+# Do a query on a query package object.
+#
+
+sub limit_query
+{
+ my($object,$limit)=@_;
+ my ($query,$result,$retry,$sth);
+
+ $query=$object->query($limit);
+ $result=safe_query($query);
+ if (!$result)
+ {
+ $object->cleanup();
+ return 0;
+ }
+ if (defined($query=$object->check_query()))
+ {
+ for ($retry=0 ; $retry < $retry_limit ; $retry++)
+ {
+ printf "query2: %-80.80s\n",$query if ($opt_log_all_queries);
+ print LOG "$query;\n" if ($opt_log);
+ if (($sth= $dbh->prepare($query)))
+ {
+ if ($sth->execute)
+ {
+ $result= $object->check($sth);
+ $sth->finish;
+ $object->cleanup();
+ return $result;
+ }
+ print_query($query);
+ $sth->finish;
+ }
+ else
+ {
+ print_query($query);
+ }
+ $retry=100 if (!$server->abort_if_fatal_error()); # No need to continue
+ if ($retry == $retry_limit-2)
+ {
+ print "Forcing discoennect to retry query\n" if ($opt_debug);
+ $dbh->disconnect || warn $dbh->errstr;
+ }
+ check_connect($object); # Check that server is still up
+ }
+ $result=0; # Query failed
+ }
+ $object->cleanup();
+ return $result; # Server couldn't handle the query
+}
+
+
+sub report
+{
+ my ($prompt,$limit,@queries)=@_;
+ print "$prompt: ";
+ if (!defined($limits{$limit}))
+ {
+ my $queries_result = safe_query(\@queries);
+ add_log($limit, $safe_query_log);
+ my $report_result;
+ if ( $queries_result) {
+ $report_result= "yes";
+ add_log($limit,"As far as all queries returned OK, result is YES");
+ } else {
+ $report_result= "no";
+ add_log($limit,"As far as some queries didnt return OK, result is NO");
+ }
+ save_config_data($limit,$report_result,$prompt);
+ }
+ print "$limits{$limit}\n";
+ return $limits{$limit} ne "no";
+}
+
+sub report_fail
+{
+ my ($prompt,$limit,@queries)=@_;
+ print "$prompt: ";
+ if (!defined($limits{$limit}))
+ {
+ my $queries_result = safe_query(\@queries);
+ add_log($limit, $safe_query_log);
+ my $report_result;
+ if ( $queries_result) {
+ $report_result= "no";
+ add_log($limit,"As far as all queries returned OK, result is NO");
+ } else {
+ $report_result= "yes";
+ add_log($limit,"As far as some queries didnt return OK, result is YES");
+ }
+ save_config_data($limit,$report_result,$prompt);
+ }
+ print "$limits{$limit}\n";
+ return $limits{$limit} ne "no";
+}
+
+
+# Return true if one of the queries is ok
+
+sub report_one
+{
+ my ($prompt,$limit,$queries)=@_;
+ my ($query,$res,$result);
+ print "$prompt: ";
+ if (!defined($limits{$limit}))
+ {
+ save_incomplete($limit,$prompt);
+ $result="no";
+ foreach $query (@$queries)
+ {
+ if (safe_query_l($limit,$query->[0]))
+ {
+ $result= $query->[1];
+ last;
+ }
+ }
+ save_config_data($limit,$result,$prompt);
+ }
+ print "$limits{$limit}\n";
+ return $limits{$limit} ne "no";
+}
+
+
+# Execute query and save result as limit value.
+
+sub report_result
+{
+ my ($prompt,$limit,$query)=@_;
+ my($error);
+ print "$prompt: ";
+ if (!defined($limits{$limit}))
+ {
+ save_incomplete($limit,$prompt);
+ $error=safe_query_result($query,"1",2);
+ add_log($limit,$safe_query_result_log);
+ save_config_data($limit,$error ? "not supported" :$last_result,$prompt);
+ }
+ print "$limits{$limit}\n";
+ return $limits{$limit} ne "not supported";
+}
+
+sub report_trans
+{
+ my ($limit,$queries,$check,$clear)=@_;
+ if (!defined($limits{$limit}))
+ {
+ save_incomplete($limit,$prompt);
+ eval {undef($dbh->{AutoCommit})};
+ if (!$@)
+ {
+ if (safe_query(\@$queries))
+ {
+ $dbh->rollback;
+ $dbh->{AutoCommit} = 1;
+ if (safe_query_result($check,"","")) {
+ add_log($limit,$safe_query_result_log);
+ save_config_data($limit,"yes",$limit);
+ }
+ safe_query($clear);
+ } else {
+ add_log($limit,$safe_query_log);
+ save_config_data($limit,"error",$limit);
+ }
+ $dbh->{AutoCommit} = 1;
+ }
+ else
+ {
+ add_log($limit,"Couldnt undef autocommit ?? ");
+ save_config_data($limit,"no",$limit);
+ }
+ safe_query($clear);
+ }
+ return $limits{$limit} ne "yes";
+}
+
+sub report_rollback
+{
+ my ($limit,$queries,$check,$clear)=@_;
+ if (!defined($limits{$limit}))
+ {
+ save_incomplete($limit,$prompt);
+ eval {undef($dbh->{AutoCommit})};
+ if (!$@)
+ {
+ if (safe_query(\@$queries))
+ {
+ add_log($limit,$safe_query_log);
+
+ $dbh->rollback;
+ $dbh->{AutoCommit} = 1;
+ if (safe_query($check)) {
+ add_log($limit,$safe_query_log);
+ save_config_data($limit,"no",$limit);
+ } else {
+ add_log($limit,$safe_query_log);
+ save_config_data($limit,"yes",$limit);
+ };
+ safe_query($clear);
+ } else {
+ add_log($limit,$safe_query_log);
+ save_config_data($limit,"error",$limit);
+ }
+ }
+ else
+ {
+ add_log($limit,'Couldnt undef Autocommit??');
+ save_config_data($limit,"error",$limit);
+ }
+ safe_query($clear);
+ }
+ $dbh->{AutoCommit} = 1;
+ return $limits{$limit} ne "yes";
+}
+
+
+sub check_and_report
+{
+ my ($prompt,$limit,$pre,$query,$post,$answer,$string_type,$skip_prompt,
+ $function)=@_;
+ my ($tmp);
+ $function=0 if (!defined($function));
+
+ print "$prompt: " if (!defined($skip_prompt));
+ if (!defined($limits{$limit}))
+ {
+ save_incomplete($limit,$prompt);
+ $tmp=1-safe_query(\@$pre);
+ add_log($limit,$safe_query_log);
+ if (!$tmp)
+ {
+ $tmp=safe_query_result($query,$answer,$string_type) ;
+ add_log($limit,$safe_query_result_log);
+ };
+ safe_query(\@$post);
+ add_log($limit,$safe_query_log);
+ delete $limits{$limit};
+ if ($function == 3) # Report error as 'no'.
+ {
+ $function=0;
+ $tmp= -$tmp;
+ }
+ if ($function == 0 ||
+ $tmp != 0 && $function == 1 ||
+ $tmp == 0 && $function== 2)
+ {
+ save_config_data($limit, $tmp == 0 ? "yes" : $tmp == 1 ? "no" : "error",
+ $prompt);
+ print "$limits{$limit}\n";
+ return $function == 0 ? $limits{$limit} eq "yes" : 0;
+ }
+ return 1; # more things to check
+ }
+ print "$limits{$limit}\n";
+ return 0 if ($function);
+ return $limits{$limit} eq "yes";
+}
+
+
+sub try_and_report
+{
+ my ($prompt,$limit,@tests)=@_;
+ my ($tmp,$test,$type);
+
+ print "$prompt: ";
+
+ if (!defined($limits{$limit}))
+ {
+ save_incomplete($limit,$prompt);
+ $type="no"; # Not supported
+ foreach $test (@tests)
+ {
+ my $tmp_type= shift(@$test);
+ if (safe_query_l($limit,\@$test))
+ {
+ $type=$tmp_type;
+ goto outer;
+ }
+ }
+ outer:
+ save_config_data($limit, $type, $prompt);
+ }
+ print "$limits{$limit}\n";
+ return $limits{$limit} ne "no";
+}
+
+#
+# Just execute the query and check values; Returns 1 if ok
+#
+
+sub execute_and_check
+{
+ my ($key,$pre,$query,$post,$answer,$string_type)=@_;
+ my ($tmp);
+
+ $tmp=safe_query_l($key,\@$pre);
+
+ $tmp=safe_query_result_l($key,$query,$answer,$string_type) == 0 if ($tmp);
+ safe_query_l($key,\@$post);
+ return $tmp;
+}
+
+
+# returns 0 if ok, 1 if error, -1 if wrong answer
+# Sets $last_result to value of query
+sub safe_query_result_l{
+ my ($key,$query,$answer,$result_type)=@_;
+ my $r = safe_query_result($query,$answer,$result_type);
+ add_log($key,$safe_query_result_log);
+ return $r;
+}
+
+sub safe_query_result
+{
+# result type can be
+# 8 (must be empty), 2 (Any value), 0 (number)
+# 1 (char, endspaces can differ), 3 (exact char), 4 (NULL)
+# 5 (char with prefix), 6 (exact, errors are ignored)
+# 7 (array of numbers)
+ my ($query,$answer,$result_type)=@_;
+ my ($sth,$row,$result,$retry);
+ undef($last_result);
+ $safe_query_result_log="";
+
+ printf "\nquery3: %-80.80s\n",$query if ($opt_log_all_queries);
+ print LOG "$query;\n" if ($opt_log);
+ $safe_query_result_log="<".$query."\n";
+
+ for ($retry=0; $retry < $retry_limit ; $retry++)
+ {
+ if (!($sth=$dbh->prepare($query)))
+ {
+ print_query($query);
+ $safe_query_result_log .= "> prepare failed:".$dbh->errstr."\n";
+
+ if ($server->abort_if_fatal_error())
+ {
+ check_connect(); # Check that server is still up
+ next; # Retry again
+ }
+ check_connect(); # Check that server is still up
+ return 1;
+ }
+ if (!$sth->execute)
+ {
+ print_query($query);
+ $safe_query_result_log .= "> execute failed:".$dbh->errstr."\n";
+ if ($server->abort_if_fatal_error())
+ {
+ check_connect(); # Check that server is still up
+ next; # Retry again
+ }
+ check_connect(); # Check that server is still up
+ return 1;
+ }
+ else
+ {
+ last;
+ }
+ }
+ if (!($row=$sth->fetchrow_arrayref))
+ {
+ print "\nquery: $query didn't return any result\n" if ($opt_debug);
+ $safe_query_result_log .= "> didn't return any result:".$dbh->errstr."\n";
+ $sth->finish;
+ return ($result_type == 8) ? 0 : 1;
+ }
+ if ($result_type == 8)
+ {
+ $sth->finish;
+ return 1;
+ }
+ $result=0; # Ok
+ $last_result= $row->[0]; # Save for report_result;
+ $safe_query_result_log .= ">".$last_result."\n";
+ # Note:
+ # if ($result_type == 2) We accept any return value as answer
+
+ if ($result_type == 0) # Compare numbers
+ {
+ $row->[0] =~ s/,/./; # Fix if ',' is used instead of '.'
+ if ($row->[0] != $answer && (abs($row->[0]- $answer)/
+ (abs($row->[0]) + abs($answer))) > 0.01)
+ {
+ $result=-1;
+ $safe_query_result_log .=
+ "We expected '$answer' but got '$last_result' \n";
+ }
+ }
+ elsif ($result_type == 1) # Compare where end space may differ
+ {
+ $row->[0] =~ s/\s+$//;
+ if ($row->[0] ne $answer)
+ {
+ $result=-1;
+ $safe_query_result_log .=
+ "We expected '$answer' but got '$last_result' \n";
+ } ;
+ }
+ elsif ($result_type == 3) # This should be a exact match
+ {
+ if ($row->[0] ne $answer)
+ {
+ $result= -1;
+ $safe_query_result_log .=
+ "We expected '$answer' but got '$last_result' \n";
+ };
+ }
+ elsif ($result_type == 4) # If results should be NULL
+ {
+ if (defined($row->[0]))
+ {
+ $result= -1;
+ $safe_query_result_log .=
+ "We expected NULL but got '$last_result' \n";
+ };
+ }
+ elsif ($result_type == 5) # Result should have given prefix
+ {
+ if (length($row->[0]) < length($answer) &&
+ substr($row->[0],1,length($answer)) ne $answer)
+ {
+ $result= -1 ;
+ $safe_query_result_log .=
+ "Result must have prefix '$answer', but '$last_result' \n";
+ };
+ }
+ elsif ($result_type == 6) # Exact match but ignore errors
+ {
+ if ($row->[0] ne $answer)
+ { $result= 1;
+ $safe_query_result_log .=
+ "We expected '$answer' but got '$last_result' \n";
+ } ;
+ }
+ elsif ($result_type == 7) # Compare against array of numbers
+ {
+ if ($row->[0] != $answer->[0])
+ {
+ $safe_query_result_log .= "must be '$answer->[0]' \n";
+ $result= -1;
+ }
+ else
+ {
+ my ($value);
+ shift @$answer;
+ while (($row=$sth->fetchrow_arrayref))
+ {
+ $safe_query_result_log .= ">$row\n";
+
+ $value=shift(@$answer);
+ if (!defined($value))
+ {
+ print "\nquery: $query returned to many results\n"
+ if ($opt_debug);
+ $safe_query_result_log .= "It returned to many results \n";
+ $result= 1;
+ last;
+ }
+ if ($row->[0] != $value)
+ {
+ $safe_query_result_log .= "Must return $value here \n";
+ $result= -1;
+ last;
+ }
+ }
+ if ($#$answer != -1)
+ {
+ print "\nquery: $query returned too few results\n"
+ if ($opt_debug);
+ $safe_query_result_log .= "It returned too few results \n";
+ $result= 1;
+ }
+ }
+ }
+ $sth->finish;
+ print "\nquery: '$query' returned '$row->[0]' instead of '$answer'\n"
+ if ($opt_debug && $result && $result_type != 7);
+ return $result;
+}
+
+#
+# Find limit using binary search. This is a weighed binary search that
+# will prefere lower limits to get the server to crash as
+# few times as possible
+
+
+sub find_limit()
+{
+ my ($prompt,$limit,$query)=@_;
+ my ($first,$end,$i,$tmp,@tmp_array, $queries);
+ print "$prompt: ";
+ if (defined($end=$limits{$limit}))
+ {
+ print "$end (cache)\n";
+ return $end;
+ }
+ save_incomplete($limit,$prompt);
+ add_log($limit,"We are trying (example with N=5):");
+ $queries = $query->query(5);
+ if (ref($queries) ne "ARRAY")
+ {
+ push(@tmp_array,$queries);
+ $queries= \@tmp_array;
+ }
+ foreach $tmp (@$queries)
+ { add_log($limit,repr_query($tmp)); }
+
+ if (defined($queries = $query->check_query()))
+ {
+ if (ref($queries) ne "ARRAY")
+ {
+ @tmp_array=();
+ push(@tmp_array,$queries);
+ $queries= \@tmp_array;
+ }
+ foreach $tmp (@$queries)
+ { add_log($limit,repr_query($tmp)); }
+ }
+ if (defined($query->{'init'}) && !defined($end=$limits{'restart'}{'tohigh'}))
+ {
+ if (!safe_query_l($limit,$query->{'init'}))
+ {
+ $query->cleanup();
+ return "error";
+ }
+ }
+
+ if (!limit_query($query,1)) # This must work
+ {
+ print "\nMaybe fatal error: Can't check '$prompt' for limit=1\n".
+ "error: $last_error\n";
+ return "error";
+ }
+
+ $first=0;
+ $first=$limits{'restart'}{'low'} if ($limits{'restart'}{'low'});
+
+ if (defined($end=$limits{'restart'}{'tohigh'}))
+ {
+ $end--;
+ print "\nRestarting this with low limit: $first and high limit: $end\n";
+ delete $limits{'restart'};
+ $i=$first+int(($end-$first+4)/5); # Prefere lower on errors
+ }
+ else
+ {
+ $end= $query->max_limit();
+ $i=int(($end+$first)/2);
+ }
+ my $log_str = "";
+ unless(limit_query($query,0+$end)) {
+ while ($first < $end)
+ {
+ print "." if ($opt_debug);
+ save_config_data("restart",$i,"") if ($opt_restart);
+ if (limit_query($query,$i))
+ {
+ $first=$i;
+ $log_str .= " $i:OK";
+ $i=$first+int(($end-$first+1)/2); # to be a bit faster to go up
+ }
+ else
+ {
+ $end=$i-1;
+ $log_str .= " $i:FAIL";
+ $i=$first+int(($end-$first+4)/5); # Prefere lower on errors
+ }
+ }
+ }
+ $end+=$query->{'offset'} if ($end && defined($query->{'offset'}));
+ if ($end >= $query->{'max_limit'} &&
+ substr($query->{'max_limit'},0,1) eq '+')
+ {
+ $end= $query->{'max_limit'};
+ }
+ print "$end\n";
+ add_log($limit,$log_str);
+ save_config_data($limit,$end,$prompt);
+ delete $limits{'restart'};
+ return $end;
+}
+
+#
+# Check that the query works!
+#
+
+sub assert
+{
+ my($query)=@_;
+
+ if (!safe_query($query))
+ {
+ $query=join("; ",@$query) if (ref($query) eq "ARRAY");
+ print "\nFatal error:\nquery: '$query'\nerror: $DBI::errstr\n";
+ exit 1;
+ }
+}
+
+
+sub read_config_data
+{
+ my ($key,$limit,$prompt);
+ if (-e $opt_config_file)
+ {
+ open(CONFIG_FILE,"+<$opt_config_file") ||
+ die "Can't open configure file $opt_config_file\n";
+ print "Reading old values from cache: $opt_config_file\n";
+ }
+ else
+ {
+ open(CONFIG_FILE,"+>>$opt_config_file") ||
+ die "Can't create configure file $opt_config_file: $!\n";
+ }
+ select CONFIG_FILE;
+ $|=1;
+ select STDOUT;
+ while (<CONFIG_FILE>)
+ {
+ chomp;
+ if (/^(\S+)=([^\#]*[^\#\s])\s*(\# .*)*$/)
+ {
+ $key=$1; $limit=$2 ; $prompt=$3;
+ if (!$opt_quick || $limit =~ /\d/ || $key =~ /crash_me/)
+ {
+ if ($key !~ /restart/i)
+ {
+ $limits{$key}=$limit eq "null"? undef : $limit;
+ $prompts{$key}=length($prompt) ? substr($prompt,2) : "";
+ $last_read=$key;
+ delete $limits{'restart'};
+ }
+ else
+ {
+ $limit_changed=1;
+ if ($limit > $limits{'restart'}{'tohigh'})
+ {
+ $limits{'restart'}{'low'} = $limits{'restart'}{'tohigh'};
+ }
+ $limits{'restart'}{'tohigh'} = $limit;
+ }
+ }
+ }
+ elsif (/\s*###(.*)$/) # log line
+ {
+ # add log line for previously read key
+ $log{$last_read} .= "$1\n";
+ }
+ elsif (!/^\s*$/ && !/^\#/)
+ {
+ die "Wrong config row: $_\n";
+ }
+ }
+}
+
+
+sub save_config_data
+{
+ my ($key,$limit,$prompt)=@_;
+ $prompts{$key}=$prompt;
+ return if (defined($limits{$key}) && $limits{$key} eq $limit);
+ if (!defined($limit) || $limit eq "")
+ {
+# die "Undefined limit for $key\n";
+ $limit = 'null';
+ }
+ print CONFIG_FILE "$key=$limit\t# $prompt\n";
+ $limits{$key}=$limit;
+ $limit_changed=1;
+# now write log lines (immediatelly after limits)
+ my $line;
+ my $last_line_was_empty=0;
+ foreach $line (split /\n/, $log{$key})
+ {
+ print CONFIG_FILE "$log_prefix$line\n"
+ unless ( ($last_line_was_empty eq 1)
+ && ($line =~ /^\s+$/) );
+ $last_line_was_empty= ($line =~ /^\s+$/)?1:0;
+ };
+
+ if (($opt_restart && $limits{'operating_system'} =~ /windows/i) ||
+ ($limits{'operating_system'} =~ /NT/))
+ {
+ # If perl crashes in windows, everything is lost (Wonder why? :)
+ close CONFIG_FILE;
+ open(CONFIG_FILE,"+>>$opt_config_file") ||
+ die "Can't reopen configure file $opt_config_file: $!\n";
+ }
+}
+
+sub add_log
+{
+ my $key = shift;
+ my $line = shift;
+ $log{$key} .= $line . "\n" if ($opt_verbose);
+}
+
+sub save_all_config_data
+{
+ my ($key,$tmp);
+ close CONFIG_FILE;
+ return if (!$limit_changed);
+ open(CONFIG_FILE,">$opt_config_file") ||
+ die "Can't create configure file $opt_config_file: $!\n";
+ select CONFIG_FILE;
+ $|=1;
+ select STDOUT;
+ delete $limits{'restart'};
+
+ print CONFIG_FILE
+ "#This file is automaticly generated by crash-me $version\n\n";
+ foreach $key (sort keys %limits)
+ {
+ $tmp="$key=$limits{$key}";
+ print CONFIG_FILE $tmp . ("\t" x (int((32-min(length($tmp),32)+7)/8)+1)) .
+ "# $prompts{$key}\n";
+ if ($opt_verbose)
+ {
+ my $line;
+ my $last_line_was_empty=0;
+ foreach $line (split /\n/, $log{$key})
+ {
+ print CONFIG_FILE "$log_prefix$line\n" unless
+ ( ($last_line_was_empty eq 1) && ($line =~ /^\s*$/));
+ $last_line_was_empty= ($line =~ /^\s*$/)?1:0;
+ }
+ }
+ }
+ close CONFIG_FILE;
+}
+
+#
+# Save 'incomplete' in the limits file to be able to continue if
+# crash-me dies because of a bug in perl/DBI
+
+sub save_incomplete
+{
+ my ($limit,$prompt)= @_;
+ save_config_data($limit,"incompleted",$prompt) if ($opt_restart);
+}
+
+
+sub check_repeat
+{
+ my ($sth,$limit)=@_;
+ my ($row);
+
+ return 0 if (!($row=$sth->fetchrow_arrayref));
+ return (defined($row->[0]) && ('a' x $limit) eq $row->[0]) ? 1 : 0;
+}
+
+
+sub min
+{
+ my($min)=$_[0];
+ my($i);
+ for ($i=1 ; $i <= $#_; $i++)
+ {
+ $min=$_[$i] if ($min > $_[$i]);
+ }
+ return $min;
+}
+
+sub sql_concat
+{
+ my ($a,$b)= @_;
+ return "$a || $b" if ($limits{'func_sql_concat_as_||'} eq 'yes');
+ return "concat($a,$b)" if ($limits{'func_odbc_concat'} eq 'yes');
+ return "$a + $b" if ($limits{'func_extra_concat_as_+'} eq 'yes');
+ return undef;
+}
+
+#
+# Returns a list of statements to create a table in a portable manner
+# but still utilizing features in the databases.
+#
+
+sub create_table
+{
+ my($table_name,$fields,$index,$extra) = @_;
+ my($query,$nr,$parts,@queries,@index);
+
+ $extra="" if (!defined($extra));
+
+ $query="create table $table_name (";
+ $nr=0;
+ foreach $field (@$fields)
+ {
+ $query.= $field . ',';
+ }
+ foreach $index (@$index)
+ {
+ $index =~ /\(([^\(]*)\)$/i;
+ $parts=$1;
+ if ($index =~ /^primary key/)
+ {
+ if ($limits{'primary_key_in_create'} eq 'yes')
+ {
+ $query.= $index . ',';
+ }
+ else
+ {
+ push(@queries,
+ "create unique index ${table_name}_prim on $table_name ($parts)");
+ }
+ }
+ elsif ($index =~ /^unique/)
+ {
+ if ($limits{'unique_in_create'} eq 'yes')
+ {
+ $query.= "unique ($parts),";
+ }
+ else
+ {
+ $nr++;
+ push(@queries,
+ "create unique index ${table_name}_$nr on $table_name ($parts)");
+
+ }
+ }
+ else
+ {
+ if ($limits{'index_in_create'} eq 'yes')
+ {
+ $query.= "index ($parts),";
+ }
+ else
+ {
+ $nr++;
+ push(@queries,
+ "create index ${table_name}_$nr on $table_name ($1)");
+ }
+ }
+ }
+ chop($query);
+ $query.= ") $extra";
+ unshift(@queries,$query);
+ return @queries;
+}
+
+
+#
+# This is used by some query packages to change:
+# %d -> limit
+# %s -> 'a' x limit
+# %v -> "1,1,1,1,1" where there are 'limit' number of ones
+# %f -> q1,q2,q3....
+# %F -> q1 integer,q2 integer,q3 integer....
+
+sub fix_query
+{
+ my ($query,$limit)=@_;
+ my ($repeat,$i);
+
+ return $query if !(defined($query));
+ $query =~ s/%d/$limit/g;
+ if ($query =~ /%s/)
+ {
+ $repeat= 'a' x $limit;
+ $query =~ s/%s/$repeat/g;
+ }
+ if ($query =~ /%v/)
+ {
+ $repeat= '1,' x $limit;
+ chop($repeat);
+ $query =~ s/%v/$repeat/g;
+ }
+ if ($query =~ /%f/)
+ {
+ $repeat="";
+ for ($i=1 ; $i <= $limit ; $i++)
+ {
+ $repeat.="q$i,";
+ }
+ chop($repeat);
+ $query =~ s/%f/$repeat/g;
+ }
+ if ($query =~ /%F/)
+ {
+ $repeat="";
+ for ($i=1 ; $i <= $limit ; $i++)
+ {
+ $repeat.="q$i integer,";
+ }
+ chop($repeat);
+ $query =~ s/%F/$repeat/g;
+ }
+ return $query;
+}
+
+
+#
+# Different query packages
+#
+
+package query_repeat;
+
+sub new
+{
+ my ($type,$init,$query,$add1,$add_mid,$add,$add_end,$end_query,$cleanup,
+ $max_limit, $check, $offset)=@_;
+ my $self={};
+ if (defined($init) && $#$init != -1)
+ {
+ $self->{'init'}=$init;
+ }
+ $self->{'query'}=$query;
+ $self->{'add1'}=$add1;
+ $self->{'add_mid'}=$add_mid;
+ $self->{'add'}=$add;
+ $self->{'add_end'}=$add_end;
+ $self->{'end_query'}=$end_query;
+ $self->{'cleanup'}=$cleanup;
+ $self->{'max_limit'}=(defined($max_limit) ? $max_limit : $main::query_size);
+ $self->{'check'}=$check;
+ $self->{'offset'}=$offset;
+ $self->{'printf'}= ($add =~ /%d/);
+ bless $self;
+}
+
+sub query
+{
+ my ($self,$limit)=@_;
+ if (!$self->{'printf'})
+ {
+ return $self->{'query'} . ($self->{'add'} x $limit) .
+ ($self->{'add_end'} x $limit) . $self->{'end_query'};
+ }
+ my ($tmp,$tmp2,$tmp3,$i);
+ $tmp=$self->{'query'};
+ if ($self->{'add1'})
+ {
+ for ($i=0; $i < $limit ; $i++)
+ {
+ $tmp3 = $self->{'add1'};
+ $tmp3 =~ s/%d/$i/g;
+ $tmp .= $tmp3;
+ }
+ }
+ $tmp .= " ".$self->{'add_mid'};
+ if ($self->{'add'})
+ {
+ for ($i=0; $i < $limit ; $i++)
+ {
+ $tmp2 = $self->{'add'};
+ $tmp2 =~ s/%d/$i/g;
+ $tmp .= $tmp2;
+ }
+ }
+ return ($tmp .
+ ($self->{'add_end'} x $limit) . $self->{'end_query'});
+}
+
+sub max_limit
+{
+ my ($self)=@_;
+ my $tmp;
+ $tmp=int(($main::limits{"query_size"}-length($self->{'query'})
+ -length($self->{'add_mid'})-length($self->{'end_query'}))/
+ (length($self->{'add1'})+
+ length($self->{'add'})+length($self->{'add_end'})));
+ return main::min($self->{'max_limit'},$tmp);
+}
+
+
+sub cleanup
+{
+ my ($self)=@_;
+ my($tmp,$statement);
+ $tmp=$self->{'cleanup'};
+ foreach $statement (@$tmp)
+ {
+ main::safe_query($statement) if (defined($statement) && length($statement));
+ }
+}
+
+sub check
+{
+ my ($self,$sth)=@_;
+ my $check=$self->{'check'};
+ return &$check($sth,$self->{'limit'}) if (defined($check));
+ return 1;
+}
+
+sub check_query
+{
+ return undef;
+}
+
+
+package query_num;
+
+sub new
+{
+ my ($type,$query,$end_query,$cleanup,$max_limit,$check)=@_;
+ my $self={};
+ $self->{'query'}=$query;
+ $self->{'end_query'}=$end_query;
+ $self->{'cleanup'}=$cleanup;
+ $self->{'max_limit'}=$max_limit;
+ $self->{'check'}=$check;
+ bless $self;
+}
+
+sub query
+{
+ my ($self,$i)=@_;
+ $self->{'limit'}=$i;
+ return "$self->{'query'}$i$self->{'end_query'}";
+}
+
+sub max_limit
+{
+ my ($self)=@_;
+ return $self->{'max_limit'};
+}
+
+sub cleanup
+{
+ my ($self)=@_;
+ my($statement);
+ foreach $statement ($self->{'$cleanup'})
+ {
+ main::safe_query($statement) if (defined($statement) && length($statement));
+ }
+}
+
+
+sub check
+{
+ my ($self,$sth)=@_;
+ my $check=$self->{'check'};
+ return &$check($sth,$self->{'limit'}) if (defined($check));
+ return 1;
+}
+
+sub check_query
+{
+ return undef;
+}
+
+#
+# This package is used when testing CREATE TABLE!
+#
+
+package query_table;
+
+sub new
+{
+ my ($type,$query, $add, $end_query, $extra_init, $safe_query, $check,
+ $cleanup, $max_limit, $offset)=@_;
+ my $self={};
+ $self->{'query'}=$query;
+ $self->{'add'}=$add;
+ $self->{'end_query'}=$end_query;
+ $self->{'extra_init'}=$extra_init;
+ $self->{'safe_query'}=$safe_query;
+ $self->{'check'}=$check;
+ $self->{'cleanup'}=$cleanup;
+ $self->{'max_limit'}=$max_limit;
+ $self->{'offset'}=$offset;
+ bless $self;
+}
+
+
+sub query
+{
+ my ($self,$limit)=@_;
+ $self->{'limit'}=$limit;
+ $self->cleanup(); # Drop table before create
+
+ my ($tmp,$tmp2,$i,$query,@res);
+ $tmp =$self->{'query'};
+ $tmp =~ s/%d/$limit/g;
+ for ($i=1; $i <= $limit ; $i++)
+ {
+ $tmp2 = $self->{'add'};
+ $tmp2 =~ s/%d/$i/g;
+ $tmp .= $tmp2;
+ }
+ push(@res,$tmp . $self->{'end_query'});
+ $tmp=$self->{'extra_init'};
+ foreach $query (@$tmp)
+ {
+ push(@res,main::fix_query($query,$limit));
+ }
+ return \@res;
+}
+
+
+sub max_limit
+{
+ my ($self)=@_;
+ return $self->{'max_limit'};
+}
+
+
+sub check_query
+{
+ my ($self)=@_;
+ return main::fix_query($self->{'safe_query'},$self->{'limit'});
+}
+
+sub check
+{
+ my ($self,$sth)=@_;
+ my $check=$self->{'check'};
+ return 0 if (!($row=$sth->fetchrow_arrayref));
+ if (defined($check))
+ {
+ return (defined($row->[0]) &&
+ $row->[0] eq main::fix_query($check,$self->{'limit'})) ? 1 : 0;
+ }
+ return 1;
+}
+
+
+# Remove table before and after create table query
+
+sub cleanup()
+{
+ my ($self)=@_;
+ main::safe_query(main::fix_query($self->{'cleanup'},$self->{'limit'}));
+}
+
+#
+# Package to do many queries with %d, and %s substitution
+#
+
+package query_many;
+
+sub new
+{
+ my ($type,$query,$safe_query,$check_result,$cleanup,$max_limit,$offset,
+ $safe_cleanup)=@_;
+ my $self={};
+ $self->{'query'}=$query;
+ $self->{'safe_query'}=$safe_query;
+ $self->{'check'}=$check_result;
+ $self->{'cleanup'}=$cleanup;
+ $self->{'max_limit'}=$max_limit;
+ $self->{'offset'}=$offset;
+ $self->{'safe_cleanup'}=$safe_cleanup;
+ bless $self;
+}
+
+
+sub query
+{
+ my ($self,$limit)=@_;
+ my ($queries,$query,@res);
+ $self->{'limit'}=$limit;
+ $self->cleanup() if (defined($self->{'safe_cleanup'}));
+ $queries=$self->{'query'};
+ foreach $query (@$queries)
+ {
+ push(@res,main::fix_query($query,$limit));
+ }
+ return \@res;
+}
+
+sub check_query
+{
+ my ($self)=@_;
+ return main::fix_query($self->{'safe_query'},$self->{'limit'});
+}
+
+sub cleanup
+{
+ my ($self)=@_;
+ my($tmp,$statement);
+ return if (!defined($self->{'cleanup'}));
+ $tmp=$self->{'cleanup'};
+ foreach $statement (@$tmp)
+ {
+ if (defined($statement) && length($statement))
+ {
+ main::safe_query(main::fix_query($statement,$self->{'limit'}));
+ }
+ }
+}
+
+
+sub check
+{
+ my ($self,$sth)=@_;
+ my ($check,$row);
+ return 0 if (!($row=$sth->fetchrow_arrayref));
+ $check=$self->{'check'};
+ if (defined($check))
+ {
+ return (defined($row->[0]) &&
+ $row->[0] eq main::fix_query($check,$self->{'limit'})) ? 1 : 0;
+ }
+ return 1;
+}
+
+sub max_limit
+{
+ my ($self)=@_;
+ return $self->{'max_limit'};
+}
+
+#
+# Used to find max supported row length
+#
+
+package query_row_length;
+
+sub new
+{
+ my ($type,$create,$null,$drop,$max_limit)=@_;
+ my $self={};
+ $self->{'table_name'}=$create;
+ $self->{'null'}=$null;
+ $self->{'cleanup'}=$drop;
+ $self->{'max_limit'}=$max_limit;
+ bless $self;
+}
+
+
+sub query
+{
+ my ($self,$limit)=@_;
+ my ($res,$values,$size,$length,$i);
+ $self->{'limit'}=$limit;
+
+ $res="";
+ $size=main::min($main::limits{'max_char_size'},255);
+ $size = 255 if (!$size); # Safety
+ for ($length=$i=0; $length + $size <= $limit ; $length+=$size, $i++)
+ {
+ $res.= "q$i char($size) $self->{'null'},";
+ $values.="'" . ('a' x $size) . "',";
+ }
+ if ($length < $limit)
+ {
+ $size=$limit-$length;
+ $res.= "q$i char($size) $self->{'null'},";
+ $values.="'" . ('a' x $size) . "',";
+ }
+ chop($res);
+ chop($values);
+ return ["create table " . $self->{'table_name'} . " ($res)",
+ "insert into " . $self->{'table_name'} . " values ($values)"];
+}
+
+sub max_limit
+{
+ my ($self)=@_;
+ return $self->{'max_limit'};
+}
+
+sub cleanup
+{
+ my ($self)=@_;
+ main::safe_query($self->{'cleanup'});
+}
+
+
+sub check
+{
+ return 1;
+}
+
+sub check_query
+{
+ return undef;
+}
+
+#
+# Used to find max supported index length
+#
+
+package query_index_length;
+
+sub new
+{
+ my ($type,$create,$drop,$max_limit)=@_;
+ my $self={};
+ $self->{'create'}=$create;
+ $self->{'cleanup'}=$drop;
+ $self->{'max_limit'}=$max_limit;
+ bless $self;
+}
+
+
+sub query
+{
+ my ($self,$limit)=@_;
+ my ($res,$size,$length,$i,$parts,$values);
+ $self->{'limit'}=$limit;
+
+ $res=$parts=$values="";
+ $size=main::min($main::limits{'max_index_part_length'},
+ $main::limits{'max_char_size'});
+ $size=1 if ($size == 0); # Avoid infinite loop errors
+ for ($length=$i=0; $length + $size <= $limit ; $length+=$size, $i++)
+ {
+ $res.= "q$i char($size) not null,";
+ $parts.= "q$i,";
+ $values.= "'" . ('a' x $size) . "',";
+ }
+ if ($length < $limit)
+ {
+ $size=$limit-$length;
+ $res.= "q$i char($size) not null,";
+ $parts.="q$i,";
+ $values.= "'" . ('a' x $size) . "',";
+ }
+ chop($parts);
+ chop($res);
+ chop($values);
+ if ($main::limits{'unique_in_create'} eq 'yes')
+ {
+ return [$self->{'create'} . "($res,unique ($parts))",
+ "insert into crash_q values($values)"];
+ }
+ return [$self->{'create'} . "($res)",
+ "create index crash_q_index on crash_q ($parts)",
+ "insert into crash_q values($values)"];
+}
+
+sub max_limit
+{
+ my ($self)=@_;
+ return $self->{'max_limit'};
+}
+
+sub cleanup
+{
+ my ($self)=@_;
+ main::safe_query($self->{'cleanup'});
+}
+
+
+sub check
+{
+ return 1;
+}
+
+sub check_query
+{
+ return undef;
+}
+
+
+
+### TODO:
+# OID test instead of / in addition to _rowid