diff options
Diffstat (limited to 'sql-bench/crash-me.sh')
| -rw-r--r-- | sql-bench/crash-me.sh | 5036 |
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 |