mirror of
https://github.com/MariaDB/server.git
synced 2025-01-16 12:02:42 +01:00
5036 lines
156 KiB
Bash
5036 lines
156 KiB
Bash
#!/usr/bin/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
|