server-cfg
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:103k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. #!/usr/bin/perl
  2. # -*- perl -*-
  3. # Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  4. #
  5. # This library is free software; you can redistribute it and/or
  6. # modify it under the terms of the GNU Library General Public
  7. # License as published by the Free Software Foundation; either
  8. # version 2 of the License, or (at your option) any later version.
  9. #
  10. # This library is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13. # Library General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU Library General Public
  16. # License along with this library; if not, write to the Free
  17. # Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18. # MA 02111-1307, USA
  19. #
  20. # The configuration file for the DBI/DBD tests on different databases ....
  21. # You will need the DBD module for the database you are running.
  22. # Monty made this bench script and I (Luuk de Boer) rewrote it to DBI/DBD.
  23. # Monty rewrote this again to use packages.
  24. #
  25. # Each database has a different package that has 3 functions:
  26. # new Creates a object with some standard slot
  27. # version Version number of the server
  28. # create Generates commands to create a table
  29. #
  30. #
  31. # First some global functions that help use the packages:
  32. #
  33. sub get_server
  34. {
  35.   my ($name,$host,$database,$odbc,$machine,$socket,$connect_options)=@_;
  36.   my ($server);
  37.   if ($name =~ /mysql/i)
  38.   { $server=new db_MySQL($host, $database, $machine, $socket,$connect_options); }
  39.   elsif ($name =~ /pg/i)
  40.   { $server= new db_Pg($host,$database); }
  41.   elsif ($name =~ /msql/i)
  42.   { $server= new db_mSQL($host,$database); }
  43.   elsif ($name =~ /solid/i)
  44.   { $server= new db_Solid($host,$database); }
  45.   elsif ($name =~ /Empress/i)
  46.   { $server= new db_Empress($host,$database); }
  47.   elsif ($name =~ /FrontBase/i)
  48.   { $server= new db_FrontBase($host,$database); }
  49.   elsif ($name =~ /Oracle/i)
  50.   { $server= new db_Oracle($host,$database); }
  51.   elsif ($name =~ /Access/i)
  52.   { $server= new db_access($host,$database); }
  53.   elsif ($name =~ /Informix/i)
  54.   { $server= new db_Informix($host,$database); }
  55.   elsif ($name =~ /ms-sql/i)
  56.   { $server= new db_ms_sql($host,$database); }
  57.   elsif ($name =~ /sybase/i)
  58.   { $server= new db_sybase($host,$database); }
  59.   elsif ($name =~ /Adabas/i) # Adabas has two drivers
  60.   {
  61.     $server= new db_Adabas($host,$database);
  62.     if ($name =~ /AdabasD/i)
  63.     {
  64.       $server->{'data_source'} =~ s/:Adabas:/:AdabasD:/;
  65.     }
  66.   }
  67.   elsif ($name =~ /DB2/i)
  68.   { $server= new db_db2($host,$database); }
  69.   elsif ($name =~ /Mimer/i)
  70.   { $server= new db_Mimer($host,$database); }
  71.   elsif ($name =~ /Sapdb/i)
  72.   { $server= new db_sapdb($host,$database); }
  73.   elsif ($name =~ /interBase/i)
  74.   { $server= new db_interbase($host,$database); }
  75.   else
  76.   {
  77.       die "Unknown sql server name used: $namenUse one of: Access, Adabas, AdabasD, Empress, FrontBase, Oracle, Informix, InterBase, DB2, mSQL, Mimer, MS-SQL, MySQL, Pg, Solid, SAPDB or Sybase.nIf the connection is done trough ODBC the name must end with _ODBCn";
  78.   }
  79.   if ($name =~ /_ODBC$/i || defined($odbc) && $odbc)
  80.   {
  81.     if (! ($server->{'data_source'} =~ /^([^:]*):([^:]+):([^:]*)/ ))
  82.     {
  83.       die "Can't find databasename in data_source: '" .
  84.   $server->{'data_source'}. "'n";
  85.     }
  86.     if ($3) {
  87.       $server->{'data_source'} = "$1:ODBC:$3";
  88.     } else {
  89.       $server->{'data_source'} = "$1:ODBC:$database";
  90.     }
  91.   }
  92.   return $server;
  93. }
  94. sub all_servers
  95. {
  96.   return ["Access", "Adabas", "DB2", "Empress", "FrontBase", "Oracle",
  97.   "Informix", "InterBase", "Mimer", "mSQL", "MS-SQL", "MySQL", "Pg","SAPDB",
  98.   "Solid", "Sybase"];
  99. }
  100. #############################################################################
  101. #      First the configuration for MySQL off course :-)
  102. #############################################################################
  103. package db_MySQL;
  104. sub new
  105. {
  106.   my ($type,$host,$database,$machine,$socket,$connect_options)= @_;
  107.   my $self= {};
  108.   my %limits;
  109.   bless $self;
  110.   $self->{'cmp_name'} = "mysql";
  111.   $self->{'data_source'} = "DBI:mysql:database=$database;host=$host";
  112.   $self->{'data_source'} .= ";mysql_socket=$socket" if($socket);
  113.   $self->{'data_source'} .= ";$connect_options" if($connect_options);
  114.   $self->{'limits'} = %limits;
  115.   $self->{'blob'} = "blob";
  116.   $self->{'text'} = "text";
  117.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  118.   $self->{'vacuum'} = 1; # When using with --fast
  119.   $self->{'drop_attr'} = "";
  120.   $self->{'transactions'} = 0; # Transactions disabled by default
  121.   $limits{'NEG'} = 1; # Supports -id
  122.   $limits{'alter_add_multi_col'}= 1; #Have ALTER TABLE t add a int,add b int;
  123.   $limits{'alter_table'} = 1; # Have ALTER TABLE
  124.   $limits{'alter_table_dropcol'}= 1; # Have ALTER TABLE DROP column
  125.   $limits{'column_alias'} = 1; # Alias for fields in select statement.
  126.   $limits{'func_extra_%'} = 1; # Has % as alias for mod()
  127.   $limits{'func_extra_if'} = 1; # Have function if.
  128.   $limits{'func_extra_in_num'} = 1; # Has function in
  129.   $limits{'func_odbc_floor'} = 1; # Has func_odbc_floor function
  130.   $limits{'func_odbc_mod'} = 1; # Have function mod.
  131.   $limits{'functions'} = 1; # Has simple functions (+/-)
  132.   $limits{'group_by_position'}  = 1; # Can use 'GROUP BY 1'
  133.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  134.   $limits{'group_func_extra_std'} = 1; # Have group function std().
  135.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings
  136.   $limits{'group_functions'} = 1; # Have group functions
  137.   $limits{'having_with_alias'}  = 1; # Can use aliases in HAVING
  138.   $limits{'having_with_group'} = 1; # Can use group functions in HAVING
  139.   $limits{'insert_multi_value'} = 1; # Have INSERT ... values (1,2),(3,4)
  140.   $limits{'insert_select'} = 1;
  141.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables
  142.   $limits{'left_outer_join'} = 1; # Supports left outer joins
  143.   $limits{'like_with_column'} = 1; # Can use column1 LIKE column2
  144.   $limits{'limit'} = 1; # supports the limit attribute
  145.   $limits{'truncate_table'} = 1;
  146.   $limits{'load_data_infile'} = 1; # Has load data infile
  147.   $limits{'lock_tables'} = 1; # Has lock tables
  148.   $limits{'max_column_name'} = 64; # max table and column name
  149.   $limits{'max_columns'} = 2000; # Max number of columns in table
  150.   $limits{'max_conditions'} = 9999; # (Actually not a limit)
  151.   $limits{'max_index'} = 16; # Max number of keys
  152.   $limits{'max_index_parts'} = 16; # Max segments/key
  153.   $limits{'max_tables'} = (($machine || '') =~ "^win") ? 5000 : 65000;
  154.   $limits{'max_text_size'} = 1000000; # Good enough for tests
  155.   $limits{'multi_drop'} = 1; # Drop table can take many tables
  156.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1'
  157.   $limits{'order_by_unused'} = 1;
  158.   $limits{'query_size'} = 1000000; # Max size with default buffers.
  159.   $limits{'select_without_from'}= 1; # Can do 'select 1';
  160.   $limits{'subqueries'} = 0; # Doesn't support sub-queries.
  161.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  162.   $limits{'unique_index'} = 1; # Unique index works or not
  163.   $limits{'working_all_fields'} = 1;
  164.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  165.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  166.   # Some fixes that depends on the environment
  167.   if (defined($main::opt_create_options) &&
  168.       $main::opt_create_options =~ /type=heap/i)
  169.   {
  170.     $limits{'working_blobs'} = 0; # HEAP tables can't handle BLOB's
  171.   }
  172.   if (defined($main::opt_create_options) &&
  173.       $main::opt_create_options =~ /type=innodb/i)
  174.   {
  175.     $self->{'transactions'} = 1; # Transactions enabled
  176.   }
  177.   if (defined($main::opt_create_options) &&
  178.       $main::opt_create_options =~ /type=ndb/i)
  179.   {
  180.     $self->{'transactions'} = 1; # Transactions enabled
  181.     $limits{'max_columns'} = 90; # Max number of columns in table
  182.     $limits{'max_tables'} = 32;   # No comments
  183.   }
  184.   if (defined($main::opt_create_options) &&
  185.       $main::opt_create_options =~ /type=bdb/i)
  186.   {
  187.     $self->{'transactions'} = 1; # Transactions enabled
  188.   }
  189.   if (defined($main::opt_create_options) &&
  190.       $main::opt_create_options =~ /type=gemini/i)
  191.   {
  192.     $limits{'working_blobs'} = 0; # Blobs not implemented yet
  193.     $limits{'max_tables'} = 500;
  194.     $self->{'transactions'} = 1; # Transactions enabled
  195.   }
  196.   return $self;
  197. }
  198. #
  199. # Get the version number of the database
  200. #
  201. sub version
  202. {
  203.   my ($self)=@_;
  204.   my ($dbh,$sth,$version,@row);
  205.   $dbh=$self->connect();
  206.   $sth = $dbh->prepare("select VERSION()") or die $DBI::errstr;
  207.   $version="MySQL 3.20.?";
  208.   if ($sth->execute && (@row = $sth->fetchrow_array))
  209.   {
  210.     $row[0] =~ s/-/ /g; # To get better tables with long names
  211.     $version="MySQL $row[0]";
  212.   }
  213.   $sth->finish;
  214.   $sth = $dbh->prepare("show status like 'ssl_version'") or die $DBI::errstr;
  215.   if ($sth->execute && (@row = $sth->fetchrow_array))
  216.   {
  217.     $version .= "/$row[1]";
  218.   }
  219.   $sth->finish;
  220.   $dbh->disconnect;
  221.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  222.   return $version;
  223. }
  224. #
  225. # Connection with optional disabling of logging
  226. #
  227. sub connect
  228. {
  229.   my ($self)=@_;
  230.   my ($dbh);
  231.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  232.     $main::opt_password,{ PrintError => 0}) ||
  233.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  234.   $dbh->do("SET OPTION LOG_OFF=1,UPDATE_LOG=0");
  235.   return $dbh;
  236. }
  237. #
  238. # Returns a list of statements to create a table
  239. # The field types are in ANSI SQL format.
  240. #
  241. # If one uses $main::opt_fast then one is allowed to use
  242. # non standard types to get better speed.
  243. #
  244. sub create
  245. {
  246.   my($self,$table_name,$fields,$index,$options) = @_;
  247.   my($query,@queries);
  248.   $query="create table $table_name (";
  249.   foreach $field (@$fields)
  250.   {
  251. #    $field =~ s/ decimal/ double(10,2)/i;
  252.     $field =~ s/ big_decimal/ double(10,2)/i;
  253.     $query.= $field . ',';
  254.   }
  255.   foreach $index (@$index)
  256.   {
  257.     $query.= $index . ',';
  258.   }
  259.   substr($query,-1)=")"; # Remove last ',';
  260.   $query.=" $options" if (defined($options));
  261.   $query.=" $main::opt_create_options" if (defined($main::opt_create_options));
  262.   push(@queries,$query);
  263.   return @queries;
  264. }
  265. sub insert_file {
  266.   my ($self,$dbname, $file, $dbh) = @_;
  267.   my ($command, $sth);
  268.   $file =~ s|\|/|g; # Change Win32 names to Unix syntax
  269.   $command = "load data infile '$file' into table $dbname columns optionally enclosed by '\'' terminated by ','";
  270. #  print "$commandn";
  271.   $sth = $dbh->do($command) or die $DBI::errstr;
  272.   return $sth; # Contains number of rows
  273. }
  274. #
  275. # Do any conversions to the ANSI SQL query so that the database can handle it
  276. #
  277. sub query {
  278.   my($self,$sql) = @_;
  279.   return $sql;
  280. }
  281. sub drop_index {
  282.   my ($self,$table,$index) = @_;
  283.   return "DROP INDEX $index ON $table";
  284. }
  285. #
  286. # Abort if the server has crashed
  287. # return: 0 if ok
  288. #   1 question should be retried
  289. #
  290. sub abort_if_fatal_error
  291. {
  292.   return 0;
  293. }
  294. #
  295. # This should return 1 if we to do disconnect / connect when doing
  296. # big batches
  297. #
  298. sub small_rollback_segment
  299. {
  300.   return 0;
  301. }
  302. #
  303. # reconnect on errors (needed mainly be crash-me)
  304. #
  305. sub reconnect_on_errors
  306. {
  307.   return 0;
  308. }
  309. sub fix_for_insert
  310. {
  311.   my ($self,$cmd) = @_;
  312.   return $cmd;
  313. }
  314. #
  315. # Optimize tables for better performance
  316. #
  317. sub vacuum
  318. {
  319.   my ($self,$full_vacuum,$dbh_ref,@tables)=@_;
  320.   my ($loop_time,$end_time,$dbh);
  321.   if ($#tables >= 0)
  322.   {
  323.     $dbh=$$dbh_ref;
  324.     $loop_time=new Benchmark;
  325.     $dbh->do("OPTIMIZE TABLE " . join(',',@tables)) || die "Got error: $DBI::errstr when executing 'OPTIMIZE TABLE'n";
  326.     $end_time=new Benchmark;
  327.     print "Time for book-keeping (1): " .
  328.       Benchmark::timestr(Benchmark::timediff($end_time, $loop_time),"all") . "nn";
  329.   }
  330. }
  331. #############################################################################
  332. #      Definitions for mSQL
  333. #############################################################################
  334. package db_mSQL;
  335. sub new
  336. {
  337.   my ($type,$host,$database)= @_;
  338.   my $self= {};
  339.   my %limits;
  340.   bless $self;
  341.   $self->{'cmp_name'} = "msql";
  342.   $self->{'data_source'} = "DBI:mSQL:$database:$host";
  343.   $self->{'limits'} = %limits;
  344.   $self->{'double_quotes'} = 0;
  345.   $self->{'drop_attr'} = "";
  346.   $self->{'transactions'} = 0;  # No transactions
  347.   $self->{'blob'} = "text(" . $limits{'max_text_size'} .")";
  348.   $self->{'text'} = "text(" . $limits{'max_text_size'} .")";
  349.   $limits{'max_conditions'} = 74;
  350.   $limits{'max_columns'} = 75;
  351.   $limits{'max_tables'} = 65000; # Should be big enough
  352.   $limits{'max_text_size'} = 32000;
  353.   $limits{'query_size'} = 65535;
  354.   $limits{'max_index'} = 5;
  355.   $limits{'max_index_parts'} = 10;
  356.   $limits{'max_column_name'} = 35;
  357.   $limits{'join_optimizer'} = 0; # Can't optimize FROM tables
  358.   $limits{'load_data_infile'} = 0;
  359.   $limits{'lock_tables'} = 0;
  360.   $limits{'functions'} = 0;
  361.   $limits{'group_functions'} = 0;
  362.   $limits{'group_distinct_functions'}= 0;  # Have count(distinct)
  363.   $limits{'multi_drop'} = 0;
  364.   $limits{'select_without_from'}= 0;
  365.   $limits{'subqueries'} = 0;
  366.   $limits{'left_outer_join'} = 0;
  367.   $limits{'table_wildcard'} = 0;
  368.   $limits{'having_with_alias'}  = 0;
  369.   $limits{'having_with_group'} = 0;
  370.   $limits{'like_with_column'} = 1;
  371.   $limits{'order_by_position'}  = 1;
  372.   $limits{'group_by_position'}  = 1;
  373.   $limits{'alter_table'} = 0;
  374.   $limits{'alter_add_multi_col'}= 0;
  375.   $limits{'alter_table_dropcol'}= 0;
  376.   $limits{'group_func_extra_std'} = 0;
  377.   $limits{'limit'} = 1; # supports the limit attribute
  378.   $limits{'unique_index'} = 1; # Unique index works or not
  379.   $limits{'insert_select'} = 0;
  380.   $limits{'func_odbc_mod'} = 0;
  381.   $limits{'func_extra_%'} = 0;
  382.   $limits{'func_odbc_floor'} = 0;
  383.   $limits{'func_extra_if'} = 0;
  384.   $limits{'column_alias'} = 0;
  385.   $limits{'NEG'} = 0;
  386.   $limits{'func_extra_in_num'} = 0;
  387.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  388.   $limits{'order_by_unused'} = 1;
  389.   $limits{'working_all_fields'} = 1;
  390.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  391.   return $self;
  392. }
  393. #
  394. # Get the version number of the database
  395. #
  396. sub version
  397. {
  398.   my ($tmp,$dir);
  399.   foreach $dir ("/usr/local/Hughes", "/usr/local/mSQL","/my/local/mSQL",
  400. "/usr/local")
  401.   {
  402.     if (-x "$dir/bin/msqladmin")
  403.     {
  404.       $tmp=`$dir/bin/msqladmin version | grep server`;
  405.       if ($tmp =~ /^s*(.*w)s*$/)
  406.       { # Strip pre- and endspace
  407. $tmp=$1;
  408. $tmp =~ s/s+/ /g; # Remove unnecessary spaces
  409. $tmp .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  410. return $tmp;
  411.       }
  412.     }
  413.   }
  414.   return "mSQL version ???";
  415. }
  416. sub connect
  417. {
  418.   my ($self)=@_;
  419.   my ($dbh);
  420.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  421.     $main::opt_password,{ PrintError => 0}) ||
  422.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  423.   return $dbh;
  424. }
  425. #
  426. # Can't handle many field types, so we map everything to int and real.
  427. #
  428. sub create
  429. {
  430.   my($self,$table_name,$fields,$index) = @_;
  431.   my($query,@queries,$name,$nr);
  432.   $query="create table $table_name (";
  433.   foreach $field (@$fields)
  434.   {
  435.     $field =~ s/varchar/char/i; # mSQL doesn't have VARCHAR()
  436.     # mSQL can't handle more than the real basic int types
  437.     $field =~ s/tinyint|smallint|mediumint|integer/int/i;
  438.     # mSQL can't handle different visual lengths
  439.     $field =~ s/int(d*)/int/i;
  440.     # mSQL doesn't have float, change it to real
  441.     $field =~ s/float((d*,d*)){0,1}/real/i;
  442.     $field =~ s/double((d*,d*)){0,1}/real/i;
  443.     # mSQL doesn't have blob, it has text instead
  444.     if ($field =~ / blob/i)
  445.     {
  446.       $name=$self->{'blob'};
  447.       $field =~ s/ blob/ $name/;
  448.     }
  449.     $query.= $field . ',';
  450.   }
  451.   substr($query,-1)=")"; # Remove last ',';
  452.   push(@queries,$query);
  453.   $nr=0;
  454.   # Prepend table_name to index name because the the name may clash with
  455.   # a field name. (Should be diffent name space, but this is mSQL...)
  456.   foreach $index (@$index)
  457.   {
  458.     # Primary key is unique index in mSQL
  459.     $index =~ s/primary key/unique index primary/i;
  460.     if ($index =~ /^uniques*(([^(]*))$/i)
  461.     {
  462.       $nr++;
  463.       push(@queries,"create unique index ${table_name}_$nr on $table_name ($1)");
  464.     }
  465.     else
  466.     {
  467.       if (!($index =~ /^(.*index)s+(w*)s+((.*))$/i))
  468.       {
  469. die "Can't parse index information in '$index'n";
  470.       }
  471.       push(@queries,"create $1 ${table_name}_$2 on $table_name $3");
  472.     }
  473.   }
  474.   return @queries;
  475. }
  476. sub insert_file {
  477.   my($self,$dbname, $file) = @_;
  478.   print "insert an ascii file isn't supported by mSQLn";
  479.   return 0;
  480. }
  481. sub query {
  482.   my($self,$sql) = @_;
  483.   return $sql;
  484. }
  485. sub drop_index
  486. {
  487.   my ($self,$table,$index) = @_;
  488.   return "DROP INDEX $index FROM $table";
  489. }
  490. sub abort_if_fatal_error
  491. {
  492.   return 0;
  493. }
  494. sub small_rollback_segment
  495. {
  496.   return 0;
  497. }
  498. sub reconnect_on_errors
  499. {
  500.   return 0;
  501. }
  502. sub fix_for_insert
  503. {
  504.   my ($self,$cmd) = @_;
  505.   return $cmd;
  506. }
  507. #############################################################################
  508. #      Definitions for PostgreSQL     #
  509. #############################################################################
  510. package db_Pg;
  511. sub new
  512. {
  513.   my ($type,$host,$database)= @_;
  514.   my $self= {};
  515.   my %limits;
  516.   bless $self;
  517.   $self->{'cmp_name'} = "pg";
  518.   $self->{'data_source'} = "DBI:Pg:dbname=$database";
  519.   $self->{'limits'} = %limits;
  520.   $self->{'blob'} = "text";
  521.   $self->{'text'} = "text";
  522.   $self->{'double_quotes'} = 1;
  523.   $self->{'drop_attr'} = "";
  524.   $self->{'transactions'} = 1; # Transactions enabled
  525.   $self->{"vacuum"} = 1;
  526.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables
  527.   $limits{'load_data_infile'} = 0;
  528.   $limits{'NEG'} = 1;
  529.   $limits{'alter_add_multi_col'}= 0; # alter_add_multi_col ?
  530.   $limits{'alter_table'} = 1;
  531.   $limits{'alter_table_dropcol'}= 0;
  532.   $limits{'column_alias'} = 1;
  533.   $limits{'func_extra_%'} = 1;
  534.   $limits{'func_extra_if'} = 0;
  535.   $limits{'func_extra_in_num'} = 1;
  536.   $limits{'func_odbc_floor'} = 1;
  537.   $limits{'func_odbc_mod'} = 1; # Has %
  538.   $limits{'functions'} = 1;
  539.   $limits{'group_by_position'}  = 1;
  540.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  541.   $limits{'group_func_extra_std'} = 0;
  542.   $limits{'group_func_sql_min_str'}= 1; # Can execute MIN() and MAX() on strings
  543.   $limits{'group_functions'} = 1;
  544.   $limits{'having_with_alias'}  = 0;
  545.   $limits{'having_with_group'} = 1;
  546.   $limits{'insert_select'} = 1;
  547.   $limits{'left_outer_join'} = 1;
  548.   $limits{'like_with_column'} = 1;
  549.   $limits{'lock_tables'} = 0; # in ATIS gives this a problem
  550.   $limits{'max_column_name'}  = 128;
  551.   $limits{'max_columns'} = 1000; # 500 crashes pg 6.3
  552.   $limits{'max_conditions'} = 9999; # This makes Pg real slow
  553.   $limits{'max_index'} = 64; # Big enough
  554.   $limits{'max_index_parts'} = 16;
  555.   $limits{'max_tables'} = 5000; # 10000 crashes pg 7.0.2
  556.   $limits{'max_text_size'} = 65000; # Good enough for test
  557.   $limits{'multi_drop'} = 1;
  558.   $limits{'order_by_position'}  = 1;
  559.   $limits{'order_by_unused'} = 1;
  560.   $limits{'query_size'} = 16777216;
  561.   $limits{'select_without_from'}= 1;
  562.   $limits{'subqueries'} = 1;
  563.   $limits{'table_wildcard'} = 1;
  564.   $limits{'truncate_table'} = 1;
  565.   $limits{'unique_index'} = 1; # Unique index works or not
  566.   $limits{'working_all_fields'} = 1;
  567.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  568.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  569.   return $self;
  570. }
  571. # couldn't find the option to get the version number
  572. sub version
  573. {
  574.   my ($version,$dir);
  575.   $version = "PostgreSQL version ???";
  576.   foreach $dir ($ENV{'PGDATA'},"/usr/local/pgsql/data", "/usr/local/pg/data")
  577.   {
  578.     if ($dir && -e "$dir/PG_VERSION")
  579.     {
  580.       $version= `cat $dir/PG_VERSION`;
  581.       if ($? == 0)
  582.       {
  583. chomp($version);
  584. $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  585. return "PostgreSQL $version";
  586.       }
  587.     }
  588.   }
  589.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  590.   return $version;
  591. }
  592. sub connect
  593. {
  594.   my ($self)=@_;
  595.   my ($dbh);
  596.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  597.     $main::opt_password,{ PrintError => 0}) ||
  598.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  599.   return $dbh;
  600. }
  601. sub create
  602. {
  603.   my($self,$table_name,$fields,$index) = @_;
  604.   my($query,@queries,$name,$in,$indfield,$table,$nr);
  605.   $query="create table $table_name (";
  606.   foreach $field (@$fields)
  607.   {
  608.     if ($main::opt_fast)
  609.     {
  610.       # Allow use of char2, char4, char8 or char16
  611.       $field =~ s/char(2|4|8|16)/char$1/;
  612.     }
  613.     # Pg can't handle more than the real basic int types
  614.     $field =~ s/tinyint|smallint|mediumint|integer/int/;
  615.     # Pg can't handle different visual lengths
  616.     $field =~ s/int(d*)/int/;
  617.     $field =~ s/float(d*,d*)/float/;
  618.     $field =~ s/ double/ float/;
  619. #    $field =~ s/ decimal/ float/i;
  620. #    $field =~ s/ big_decimal/ float/i;
  621. #    $field =~ s/ date/ int/i;
  622.     # Pg doesn't have blob, it has text instead
  623.     $field =~ s/ blob/ text/;
  624.     $query.= $field . ',';
  625.   }
  626.   substr($query,-1)=")"; # Remove last ',';
  627.   push(@queries,$query);
  628.   foreach $index (@$index)
  629.   {
  630.     $index =~ s/primary key/unique index primary_key/i;
  631.     if ($index =~ /^unique.*(([^(]*))$/i)
  632.     {
  633.       # original: $indfield="using btree (" .$1.")";
  634.       # using btree doesn磘 seem to work with Postgres anymore; it creates
  635.       # the table and adds the index, but it isn磘 unique
  636.       $indfield=" (" .$1.")";
  637.       $in="unique index";
  638.       $table="index_$nr"; $nr++;
  639.     }
  640.     elsif ($index =~ /^(.*index)s+(w*)s+((.*))$/i)
  641.     {
  642.       # original: $indfield="using btree (" .$1.")";
  643.       $indfield=" " .$3;
  644.       $in="index";
  645.       $table="index_$nr"; $nr++;
  646.     }
  647.     else
  648.     {
  649.       die "Can't parse index information in '$index'n";
  650.     }
  651.     push(@queries,"create $in ${table_name}_$table on $table_name $indfield");
  652.   }
  653.   $queries[0]=$query;
  654.   return @queries;
  655. }
  656. sub insert_file {
  657.   my ($self,$dbname, $file, $dbh) = @_;
  658.   my ($command, $sth);
  659. # Syntax:
  660. # copy [binary] <class_name> [with oids]
  661. #      {to|from} {<filename>|stdin|stdout} [using delimiters <delim>]
  662.   print "The ascii files aren't correct for postgres ....!!!n";
  663.   $command = "copy $dbname from '$file' using delimiters ','";
  664.   print "$commandn";
  665.   $sth = $dbh->do($command) or die $DBI::errstr;
  666.   return $sth;
  667. }
  668. #
  669. # As postgreSQL wants A % B instead of standard mod(A,B) we have to map
  670. # This will not handle all cases, but as the benchmarks doesn't use functions
  671. # inside MOD() the following should work
  672. #
  673. # PostgreSQL cant handle count(*) or even count(1), but it can handle
  674. # count(1+1) sometimes. ==> this is solved in PostgreSQL 6.3
  675. #
  676. # PostgreSQL 6.5 is supporting MOD.
  677. sub query {
  678.   my($self,$sql) = @_;
  679.   my(@select,$change);
  680. # if you use PostgreSQL 6.x and x is lower as 5 then uncomment the line below.
  681. #  $sql =~ s/mod(([^,]*),([^)]*))/($1 % $2)/gi;
  682. #
  683. # if you use PostgreSQL 6.1.x uncomment the lines below
  684. #  if ($sql =~ /selects+count(*)s+from/i) {
  685. #  }
  686. #  elsif ($sql =~ /count(*)/i)
  687. #  {
  688. #    if ($sql =~ /selects+(.*)s+from/i)
  689. #    {
  690. #      @select = split(/,/,$1);
  691. #      if ($select[0] =~ /(.*)s+ass+w+$/i)
  692. #      {
  693. #  $change = $1;
  694. #      }
  695. #      else
  696. #      {
  697. # $change = $select[0];
  698. #      }
  699. #    }
  700. #    if (($change =~ /count/i) || ($change eq "")) {
  701. #      $change = "1+1";
  702. #    }
  703. #    $sql =~ s/count(*)/count($change)/gi;
  704. #  }
  705. # till here.
  706.   return $sql;
  707. }
  708. sub drop_index
  709. {
  710.   my ($self,$table,$index) = @_;
  711.   return "DROP INDEX $index";
  712. }
  713. sub abort_if_fatal_error
  714. {
  715.   return 1 if ($DBI::errstr =~ /sent to backend, but backend closed/i);
  716.   return 0;
  717. }
  718. sub small_rollback_segment
  719. {
  720.   return 0;
  721. }
  722. sub reconnect_on_errors
  723. {
  724.   return 0;
  725. }
  726. sub fix_for_insert
  727. {
  728.   my ($self,$cmd) = @_;
  729.   return $cmd;
  730. }
  731. sub vacuum
  732. {
  733.   my ($self,$full_vacuum,$dbh_ref,@tables)=@_;
  734.   my ($loop_time,$end_time,$dbh,$table);
  735.   if (defined($full_vacuum))
  736.   {
  737.     $$dbh_ref->disconnect;  $$dbh_ref= $self->connect();
  738.   }
  739.   $dbh=$$dbh_ref;
  740.   $loop_time=new Benchmark;
  741.   if ($#tables >= 0)
  742.   {
  743.     foreach $table (@tables)
  744.     {
  745.       $dbh->do("vacuum analyze $table") || die "Got error: $DBI::errstr when executing 'vacuum analyze $table'n";
  746.       $dbh->do("vacuum $table") || die "Got error: $DBI::errstr when executing 'vacuum'n";
  747.     }
  748.   }
  749.   else
  750.   {
  751. #    $dbh->do("vacuum pg_attributes") || die "Got error: $DBI::errstr when executing 'vacuum'n";
  752. #    $dbh->do("vacuum pg_index") || die "Got error: $DBI::errstr when executing 'vacuum'n";
  753.     $dbh->do("vacuum analyze") || die "Got error: $DBI::errstr when executing 'vacuum analyze'n";
  754.     $dbh->do("vacuum") || die "Got error: $DBI::errstr when executing 'vacuum'n";
  755.   }
  756.   $end_time=new Benchmark;
  757.   print "Time for book-keeping (1): " .
  758.   Benchmark::timestr(Benchmark::timediff($end_time, $loop_time),"all") . "nn";
  759.   $dbh->disconnect;  $$dbh_ref= $self->connect();
  760. }
  761. #############################################################################
  762. #      Definitions for Solid
  763. #############################################################################
  764. package db_Solid;
  765. sub new
  766. {
  767.   my ($type,$host,$database)= @_;
  768.   my $self= {};
  769.   my %limits;
  770.   bless $self;
  771.   $self->{'cmp_name'} = "solid";
  772.   $self->{'data_source'} = "DBI:Solid:";
  773.   $self->{'limits'} = %limits;
  774.   $self->{'blob'} = "long varchar";
  775.   $self->{'text'} = "long varchar";
  776.   $self->{'double_quotes'} = 1;
  777.   $self->{'drop_attr'} = "";
  778.   $self->{'transactions'} = 1; # Transactions enabled
  779.   $limits{'max_conditions'} = 9999; # Probably big enough
  780.   $limits{'max_columns'} = 2000; # From crash-me
  781.   $limits{'max_tables'} = 65000; # Should be big enough
  782.   $limits{'max_text_size'} = 65492; # According to tests
  783.   $limits{'query_size'} = 65535; # Probably a limit
  784.   $limits{'max_index'} = 64; # Probably big enough
  785.   $limits{'max_index_parts'} = 64;
  786.   $limits{'max_column_name'} = 80;
  787.   $limits{'join_optimizer'} = 1;
  788.   $limits{'load_data_infile'} = 0;
  789.   $limits{'lock_tables'} = 0;
  790.   $limits{'functions'} = 1;
  791.   $limits{'group_functions'} = 1;
  792.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings
  793.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  794.   $limits{'select_without_from'}= 0; # Can do 'select 1' ?;
  795.   $limits{'multi_drop'} = 0;
  796.   $limits{'subqueries'} = 1;
  797.   $limits{'left_outer_join'} = 1;
  798.   $limits{'table_wildcard'} = 1;
  799.   $limits{'having_with_alias'}  = 0;
  800.   $limits{'having_with_group'} = 1;
  801.   $limits{'like_with_column'} = 1;
  802.   $limits{'order_by_position'}  = 0; # 2.30.0018 can this
  803.   $limits{'group_by_position'}  = 0;
  804.   $limits{'alter_table'} = 1;
  805.   $limits{'alter_add_multi_col'}= 0;
  806.   $limits{'alter_table_dropcol'}= 0;
  807.   $limits{'group_func_extra_std'} = 0; # Have group function std().
  808.   $limits{'func_odbc_mod'} = 1;
  809.   $limits{'func_extra_%'} = 0;
  810.   $limits{'func_odbc_floor'} = 1;
  811.   $limits{'column_alias'} = 1;
  812.   $limits{'NEG'} = 1;
  813.   $limits{'func_extra_in_num'} = 1;
  814.   $limits{'unique_index'} = 1; # Unique index works or not
  815.   $limits{'insert_select'} = 1;
  816.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  817.   $limits{'order_by_unused'} = 1;
  818.   $limits{'working_all_fields'} = 1;
  819.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  820.   return $self;
  821. }
  822. #
  823. # Get the version number of the database
  824. #
  825. sub version
  826. {
  827.   my ($version,$dir);
  828.   $version="Solid version ??";
  829.   foreach $dir ($ENV{'SOLIDDIR'},"/usr/local/solid", "/my/local/solid")
  830.   {
  831.     if ($dir && -e "$dir/bin/solcon")
  832.     {
  833.       $version=`$dir/bin/solcon -e"ver" $main::opt_user $main::opt_password | grep Server | sed q`;
  834.       if ($? == 0)
  835.       {
  836. chomp($version);
  837. $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  838. return $version;
  839.       }
  840.     }
  841.   }
  842.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  843.   return $version;
  844. }
  845. sub connect
  846. {
  847.   my ($self)=@_;
  848.   my ($dbh);
  849.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  850.     $main::opt_password,{ PrintError => 0}) ||
  851.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  852.   return $dbh;
  853. }
  854. #
  855. # Returns a list of statements to create a table
  856. # The field types are in ANSI SQL format.
  857. #
  858. sub create
  859. {
  860.   my($self,$table_name,$fields,$index) = @_;
  861.   my($query,@queries,$nr);
  862.   $query="create table $table_name (";
  863.   foreach $field (@$fields)
  864.   {
  865.     $field =~ s/mediumint/integer/i;
  866.     $field =~ s/ double/ float/i;
  867.     # Solid doesn't have blob, it has long varchar
  868.     $field =~ s/ blob/ long varchar/;
  869. #    $field =~ s/ decimal/ float/i;
  870. #    $field =~ s/ big_decimal/ float/i;
  871. #    $field =~ s/ date/ int/i;
  872.     $query.= $field . ',';
  873.   }
  874.   substr($query,-1)=")"; # Remove last ',';
  875.   push(@queries,$query);
  876.   $nr=0;
  877.   foreach $index (@$index)
  878.   {
  879.     if ($index =~ /^primary key/i || $index =~ /^unique/i)
  880.     { # Add to create statement
  881.       substr($queries[0],-1,0)="," . $index;
  882.     }
  883.     else
  884.     {
  885.       $index =~ /^(.*)s+((.*))$/;
  886.       push(@queries,"create ${1}$nr on $table_name $2");
  887.       $nr++;
  888.     }
  889.   }
  890.   return @queries;
  891. }
  892. # there is no sql statement in solid which can do the load from
  893. # an ascii file in the db ... but there is the speedloader program
  894. # an external program which can load the ascii file in the db ...
  895. # the server must be down before using speedloader !!!!
  896. # (in the standalone version)
  897. # it works also with a control file ... that one must be made ....
  898. sub insert_file {
  899.   my ($self, $dbname, $file) = @_;
  900.   my ($speedcmd);
  901.   $speedcmd = '/usr/local/solid/bin/solload';
  902.   print "At this moment not supported - solid server must go down n";
  903.   return 0;
  904. }
  905. # solid can't handle an alias in a having statement so
  906. # select test as foo from tmp group by foo having foor > 2
  907. # becomes
  908. # select test as foo from tmp group by foo having test > 2
  909. #
  910. sub query {
  911.   my($self,$sql) = @_;
  912.   my(@select,$tmp,$newhaving,$key,%change);
  913.   if ($sql =~ /havings+/i)
  914.   {
  915.     if ($sql =~ /select (.*) from/i)
  916.     {
  917.       (@select) = split(/,s*/, $1);
  918.       foreach $tmp (@select)
  919.       {
  920. if ($tmp =~ /(.*)s+ass+(w+)/)
  921. {
  922.   $change{$2} = $1;
  923. }
  924.       }
  925.     }
  926.     if ($sql =~ /havings+(w+)/i)
  927.     {
  928.       $newhaving = $1;
  929.       foreach $key (sort {$a cmp $b} keys %change)
  930.       {
  931. if ($newhaving eq $key)
  932. {
  933.   $newhaving =~ s/$key/$change{$key}/g;
  934. }
  935.       }
  936.     }
  937.     $sql =~ s/(having)s+(w+)/$1 $newhaving/i;
  938.   }
  939.   return $sql;
  940. }
  941. sub drop_index
  942. {
  943.   my ($self,$table,$index) = @_;
  944.   return "DROP INDEX $index";
  945. }
  946. sub abort_if_fatal_error
  947. {
  948.   return 0;
  949. }
  950. sub small_rollback_segment
  951. {
  952.   return 0;
  953. }
  954. sub fix_for_insert
  955. {
  956.   my ($self,$cmd) = @_;
  957.   return $cmd;
  958. }
  959. sub reconnect_on_errors
  960. {
  961.   return 0;
  962. }
  963. #############################################################################
  964. #      Definitions for Empress
  965. #
  966. # at this moment DBI:Empress can only handle 200 prepare statements ...
  967. # so Empress can't be tested with the benchmark test :(
  968. #############################################################################
  969. package db_Empress;
  970. sub new
  971. {
  972.   my ($type,$host,$database)= @_;
  973.   my $self= {};
  974.   my %limits;
  975.   bless $self;
  976.   $self->{'cmp_name'} = "empress";
  977.   $self->{'data_source'}        = "DBI:EmpressNet:SERVER=$host;Database=/usr/local/empress/rdbms/bin/$database";
  978.   $self->{'limits'} = %limits;
  979.   $self->{'blob'} = "text";
  980.   $self->{'text'} = "text";
  981.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  982.   $self->{'drop_attr'} = "";
  983.   $self->{'transactions'} = 1; # Transactions enabled
  984.   $limits{'max_conditions'} = 1258;
  985.   $limits{'max_columns'} = 226; # server is disconnecting????
  986. # above this value .... but can handle 2419 columns
  987. # maybe something for crash-me ... but how to check ???
  988.   $limits{'max_tables'} = 65000; # Should be big enough
  989.   $limits{'max_text_size'} = 4095; # max returned ....
  990.   $limits{'query_size'} = 65535; # Not a limit, big enough
  991.   $limits{'max_index'} = 64; # Big enough
  992.   $limits{'max_index_parts'} = 64; # Big enough
  993.   $limits{'max_column_name'}  = 31;
  994.   $limits{'join_optimizer'} = 1;
  995.   $limits{'load_data_infile'} = 0;
  996.   $limits{'lock_tables'} = 1;
  997.   $limits{'functions'} = 1;
  998.   $limits{'group_functions'} = 1;
  999.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings
  1000.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  1001.   $limits{'select_without_from'}= 0;
  1002.   $limits{'multi_drop'} = 0;
  1003.   $limits{'subqueries'} = 1;
  1004.   $limits{'table_wildcard'} = 0;
  1005.   $limits{'having_with_alias'}  = 0;  # AS isn't supported in a select
  1006.   $limits{'having_with_group'} = 1;
  1007.   $limits{'like_with_column'} = 1;
  1008.   $limits{'order_by_position'}  = 1;
  1009.   $limits{'group_by_position'}  = 0;
  1010.   $limits{'alter_table'} = 1;
  1011.   $limits{'alter_add_multi_col'}= 0;
  1012.   $limits{'alter_table_dropcol'}= 0;
  1013.   $limits{'group_func_extra_std'}= 0; # Have group function std().
  1014.   $limits{'func_odbc_mod'} = 0;
  1015.   $limits{'func_extra_%'} = 1;
  1016.   $limits{'func_odbc_floor'} = 1;
  1017.   $limits{'func_extra_if'} = 0;
  1018.   $limits{'column_alias'} = 0;
  1019.   $limits{'NEG'} = 1;
  1020.   $limits{'func_extra_in_num'} = 0;
  1021.   $limits{'unique_index'} = 1; # Unique index works or not
  1022.   $limits{'insert_select'} = 1;
  1023.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  1024.   $limits{'order_by_unused'} = 1;
  1025.   $limits{'working_all_fields'} = 1;
  1026.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  1027.   return $self;
  1028. }
  1029. #
  1030. # Get the version number of the database
  1031. #
  1032. sub version
  1033. {
  1034.   my ($self,$dbh)=@_;
  1035.   my ($version);
  1036.   $version="";
  1037.   if (-x "/usr/local/empress/rdbms/bin/empvers")
  1038.   {
  1039.     $version=`/usr/local/empress/rdbms/bin/empvers | grep Version`;
  1040.   }
  1041.   if ($version)
  1042.   {
  1043.     chomp($version);
  1044.   }
  1045.   else
  1046.   {
  1047.     $version="Empress version ???";
  1048.   }
  1049.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  1050.   return $version;
  1051. }
  1052. sub connect
  1053. {
  1054.   my ($self)=@_;
  1055.   my ($dbh);
  1056.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  1057.     $main::opt_password,{ PrintError => 0}) ||
  1058.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  1059.   return $dbh;
  1060. }
  1061. sub insert_file {
  1062.   my($self,$dbname, $file) = @_;
  1063.   my($command,$sth);
  1064.   $command = "insert into $dbname from '$file'";
  1065.   print "$commandn" if ($opt_debug);
  1066.   $sth = $dbh->do($command) or die $DBI::errstr;
  1067.   return $sth;
  1068. }
  1069. #
  1070. # Returns a list of statements to create a table
  1071. # The field types are in ANSI SQL format.
  1072. #
  1073. sub create
  1074. {
  1075.   my($self,$table_name,$fields,$index) = @_;
  1076.   my($query,@queries,$nr);
  1077.   $query="create table $table_name (";
  1078.   foreach $field (@$fields)
  1079.   {
  1080.     $field =~ s/mediumint/int/i;
  1081.     $field =~ s/tinyint/int/i;
  1082.     $field =~ s/smallint/int/i;
  1083.     $field =~ s/longint/int/i;
  1084.     $field =~ s/integer/int/i;
  1085.     $field =~ s/ double/ longfloat/i;
  1086.     # Solid doesn't have blob, it has long varchar
  1087. #    $field =~ s/ blob/ text(65535,65535,65535,65535)/;
  1088.     $field =~ s/ blob/ text/;
  1089.     $field =~ s/ varchar((d+))/ char($1,3)/;
  1090.     $field =~ s/ char((d+))/ char($1,3)/;
  1091. #    $field =~ s/ decimal/ float/i;
  1092. #    $field =~ s/ big_decimal/ longfloat/i;
  1093. #    $field =~ s/ date/ int/i;
  1094.     $field =~ s/ float(.*)/ float/i;
  1095.     if ($field =~ / int((d+))/) {
  1096.       if ($1 > 4) {
  1097.         $field =~ s/ int(d+)/ longinteger/i;
  1098.       } else {
  1099.         $field =~ s/ int(d+)/ longinteger/i;
  1100.       }
  1101.     } else {
  1102.       $field =~ s/ int/ longinteger/i;
  1103.     }
  1104.     $query.= $field . ',';
  1105.   }
  1106.   substr($query,-1)=")"; # Remove last ',';
  1107.   push(@queries,$query);
  1108.   $nr=1;
  1109.   foreach $index (@$index)
  1110.   {
  1111.     # Primary key is unique index in Empress
  1112.     $index =~ s/primary key/unique index/i;
  1113.     if ($index =~ /^unique.*(([^(]*))$/i)
  1114.     {
  1115.       $nr++;
  1116.       push(@queries,"create unique index ${table_name}_$nr on $table_name ($1)");
  1117.     }
  1118.     else
  1119.     {
  1120.       if (!($index =~ /^(.*index)s+(w*)s+((.*))$/i))
  1121.       {
  1122. die "Can't parse index information in '$index'n";
  1123.       }
  1124.       push(@queries,"create $1 ${table_name}_$2 on $table_name $3");
  1125.     }
  1126.   }
  1127.   return @queries;
  1128. }
  1129. # empress can't handle an alias and but can handle the number of the
  1130. # columname - so
  1131. # select test as foo from tmp order by foo
  1132. # becomes
  1133. # select test from tmp order by 1
  1134. #
  1135. sub query {
  1136.   my($self,$sql) = @_;
  1137.   my(@select,$i,$tmp,$newselect,$neworder,@order,$key,%change);
  1138.   my($tmp1,$otmp,$tmp2);
  1139.   if ($sql =~ /s+ass+/i)
  1140.   {
  1141.     if ($sql =~ /selects+(.*)s+from/i) {
  1142.       $newselect = $1;
  1143.       (@select) = split(/,s*/, $1);
  1144.       $i = 1;
  1145.       foreach $tmp (@select) {
  1146. if ($tmp =~ /s+ass+(w+)/) {
  1147.   $change{$1} = $i;
  1148. }
  1149. $i++;
  1150.       }
  1151.     }
  1152.     $newselect =~ s/s+ass+(w+)//gi;
  1153.     $tmp2 = 0;
  1154.     if ($sql =~ /orders+bys+(.*)$/i) {
  1155.       (@order) = split(/,s*/, $1);
  1156.       foreach $otmp (@order) {
  1157. foreach $key (sort {$a cmp $b} keys %change) {
  1158.   if ($otmp eq $key) {
  1159.     $neworder .= "$tmp1"."$change{$key}";
  1160.     $tmp1 = ", ";
  1161.     $tmp2 = 1;
  1162.   } elsif ($otmp =~ /(w+)s+(.+)$/) {
  1163.     if ($key eq $1) {
  1164.       $neworder .= "$tmp1"."$change{$key} $2";
  1165.       $tmp2 = 1;
  1166.     }
  1167.   }
  1168. }
  1169. if ($tmp2 == 0) {
  1170.   $neworder .= "$tmp1"."$otmp";
  1171. }
  1172. $tmp2 = 0;
  1173. $tmp1 = ", ";
  1174.       }
  1175.     }
  1176.     $sql =~ s/(select)s+(.*)s+(from)/$1 $newselect $3/i;
  1177.     $sql =~ s/(orders+by)s+(.*)$/$1 $neworder/i;
  1178.   }
  1179.   return $sql;
  1180. }
  1181. sub fix_for_insert
  1182. {
  1183.   my ($self,$cmd) = @_;
  1184.   $cmd =~ s/''/' '/g;
  1185.   return $cmd;
  1186. }
  1187. sub drop_index
  1188. {
  1189.   my ($self,$table,$index) = @_;
  1190.   return "DROP INDEX $index";
  1191. }
  1192. # This is a because of the 200 statement problem with DBI-Empress
  1193. sub abort_if_fatal_error
  1194. {
  1195.   if ($DBI::errstr =~ /Overflow of table of prepared statements/i)
  1196.   {
  1197.     print "Overflow of prepared statements ... killing the processn";
  1198.     exit 1;
  1199.   }
  1200.   return 0;
  1201. }
  1202. sub small_rollback_segment
  1203. {
  1204.   return 0;
  1205. }
  1206. sub reconnect_on_errors
  1207. {
  1208.   return 0;
  1209. }
  1210. #############################################################################
  1211. #                  Definitions for Oracle
  1212. #############################################################################
  1213. package db_Oracle;
  1214. sub new
  1215. {
  1216.   my ($type,$host,$database)= @_;
  1217.   my $self= {};
  1218.   my %limits;
  1219.   bless $self;
  1220.   $self->{'cmp_name'} = "Oracle";
  1221.   $self->{'data_source'} = "DBI:Oracle:$database";
  1222.   $self->{'limits'} = %limits;
  1223.   $self->{'blob'} = "long";
  1224.   $self->{'text'} = "long";
  1225.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  1226.   $self->{'drop_attr'} = "";
  1227.   $self->{'transactions'} = 1; # Transactions enabled
  1228.   $self->{"vacuum"} = 1;
  1229.   $limits{'max_conditions'} = 9999; # (Actually not a limit)
  1230.   $limits{'max_columns'} = 254; # Max number of columns in table
  1231.   $limits{'max_tables'} = 65000; # Should be big enough
  1232.   $limits{'max_text_size'} = 2000; # Limit for blob test-connect
  1233.   $limits{'query_size'} = 65525; # Max size with default buffers.
  1234.   $limits{'max_index'} = 16; # Max number of keys
  1235.   $limits{'max_index_parts'} = 16; # Max segments/key
  1236.   $limits{'max_column_name'} = 32; # max table and column name
  1237.   $limits{'truncate_table'} = 1;
  1238.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables
  1239.   $limits{'load_data_infile'} = 0; # Has load data infile
  1240.   $limits{'lock_tables'} = 0; # Has lock tables
  1241.   $limits{'functions'} = 1; # Has simple functions (+/-)
  1242.   $limits{'group_functions'} = 1; # Have group functions
  1243.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings
  1244.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  1245.   $limits{'select_without_from'}= 0;
  1246.   $limits{'multi_drop'} = 0;
  1247.   $limits{'subqueries'} = 1;
  1248.   $limits{'left_outer_join'} = 0; # This may be fixed in the query module
  1249.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  1250.   $limits{'having_with_alias'}  = 0; # Can use aliases in HAVING
  1251.   $limits{'having_with_group'} = 1; # Can't use group functions in HAVING
  1252.   $limits{'like_with_column'} = 1; # Can use column1 LIKE column2
  1253.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1'
  1254.   $limits{'group_by_position'}  = 0;
  1255.   $limits{'alter_table'} = 1;
  1256.   $limits{'alter_add_multi_col'}= 0;
  1257.   $limits{'alter_table_dropcol'}= 0;
  1258.   $limits{'group_func_extra_std'} = 0; # Have group function std().
  1259.   $limits{'func_odbc_mod'} = 0; # Oracle has problem with mod()
  1260.   $limits{'func_extra_%'} = 0; # Has % as alias for mod()
  1261.   $limits{'func_odbc_floor'} = 1; # Has func_odbc_floor function
  1262.   $limits{'func_extra_if'} = 0; # Have function if.
  1263.   $limits{'column_alias'} = 1; # Alias for fields in select statement.
  1264.   $limits{'NEG'} = 1; # Supports -id
  1265.   $limits{'func_extra_in_num'} = 1; # Has function in
  1266.   $limits{'unique_index'} = 1; # Unique index works or not
  1267.   $limits{'insert_select'} = 1;
  1268.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  1269.   $limits{'order_by_unused'} = 1;
  1270.   $limits{'working_all_fields'} = 1;
  1271.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  1272.   return $self;
  1273. }
  1274. #
  1275. # Get the version number of the database
  1276. #
  1277. sub version
  1278. {
  1279.   my ($self)=@_;
  1280.   my ($dbh,$sth,$version,@row);
  1281.   $dbh=$self->connect();
  1282.   $sth = $dbh->prepare("select VERSION from product_component_version WHERE PRODUCT like 'Oracle%'") or die $DBI::errstr;
  1283.   $version="Oracle 7.x";
  1284.   if ($sth->execute && (@row = $sth->fetchrow_array))
  1285.   {
  1286.     $version="Oracle $row[0]";
  1287.   }
  1288.   $sth->finish;
  1289.   $dbh->disconnect;
  1290.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  1291.   return $version;
  1292. }
  1293. sub connect
  1294. {
  1295.   my ($self)=@_;
  1296.   my ($dbh);
  1297.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  1298.     $main::opt_password,{ PrintError => 0}) ||
  1299.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  1300.   return $dbh;
  1301. }
  1302. #
  1303. # Returns a list of statements to create a table
  1304. # The field types are in ANSI SQL format.
  1305. #
  1306. # If one uses $main::opt_fast then one is allowed to use
  1307. # non standard types to get better speed.
  1308. #
  1309. sub create
  1310. {
  1311.   my($self,$table_name,$fields,$index) = @_;
  1312.   my($query,@queries,$ind,@keys);
  1313.   $query="create table $table_name (";
  1314.   foreach $field (@$fields)
  1315.   {
  1316.     $field =~ s/ character((d+))/ char($1)/i;
  1317.     $field =~ s/ character varying((d+))/ varchar($1)/i;
  1318.     $field =~ s/ char varying((d+))/ varchar($1)/i;
  1319.     $field =~ s/ integer/ number(38)/i;
  1320.     $field =~ s/ int/ number(38)/i;
  1321.     $field =~ s/ tinyint/ number(38)/i;
  1322.     $field =~ s/ smallint/ number(38)/i;
  1323.     $field =~ s/ mediumint/ number(38)/i;
  1324.     $field =~ s/ tinynumber((d+))((d+))/ number($1,$2)/i;
  1325.     $field =~ s/ smallnumber((d+))((d+))/ number($1,$2)/i;
  1326.     $field =~ s/ mediumnumber((d+))((d+))/ number($1,$2)/i;
  1327.     $field =~ s/ number((d+))((d+))/ number($1,$2)/i;
  1328.     $field =~ s/ numeric((d+))((d+))/ number($1,$2)/i;
  1329.     $field =~ s/ decimal((d+))((d+))/ number($1,$2)/i;
  1330.     $field =~ s/ dec((d+))((d+))/ number($1,$2)/i;
  1331.     $field =~ s/ float/ number/;
  1332.     $field =~ s/ real/ number/;
  1333.     $field =~ s/ double precision/ number/;
  1334.     $field =~ s/ double/ number/;
  1335.     $field =~ s/ blob/ long/;
  1336.     $query.= $field . ',';
  1337.   }
  1338.   foreach $ind (@$index)
  1339.   {
  1340.     my @index;
  1341.     if ( $ind =~ /bKEYb/i ){
  1342.       push(@keys,"ALTER TABLE $table_name ADD $ind");
  1343.     }else{
  1344.       my @fields = split(' ',$index);
  1345.       my $query="CREATE INDEX $fields[1] ON $table_name $fields[2]";
  1346.       push(@index,$query);
  1347.     }
  1348.   }
  1349.   substr($query,-1)=")"; # Remove last ',';
  1350.   push(@queries,$query,@keys,@index);
  1351. #print "query:$queryn";
  1352.   return @queries;
  1353. }
  1354. sub insert_file {
  1355.   my($self,$dbname, $file) = @_;
  1356.   print "insert an ascii file isn't supported by Oracle (?)n";
  1357.   return 0;
  1358. }
  1359. #
  1360. # Do any conversions to the ANSI SQL query so that the database can handle it
  1361. #
  1362. sub query {
  1363.   my($self,$sql) = @_;
  1364.   return $sql;
  1365. }
  1366. sub fix_for_insert
  1367. {
  1368.   my ($self,$cmd) = @_;
  1369.   $cmd =~ s/''/' '/g;
  1370.   return $cmd;
  1371. }
  1372. sub drop_index
  1373. {
  1374.   my ($self,$table,$index) = @_;
  1375.   return "DROP INDEX $index";
  1376. }
  1377. #
  1378. # Abort if the server has crashed
  1379. # return: 0 if ok
  1380. #   1 question should be retried
  1381. #
  1382. sub abort_if_fatal_error
  1383. {
  1384.   return 0;
  1385. }
  1386. sub small_rollback_segment
  1387. {
  1388.   return 1;
  1389. }
  1390. sub reconnect_on_errors
  1391. {
  1392.   return 0;
  1393. }
  1394. #
  1395. # optimize the tables ....
  1396. #
  1397. sub vacuum
  1398. {
  1399.   my ($self,$full_vacuum,$dbh_ref)=@_;
  1400.   my ($loop_time,$end_time,$sth,$dbh);
  1401.   if (defined($full_vacuum))
  1402.   {
  1403.     $$dbh_ref->disconnect;  $$dbh_ref= $self->connect();
  1404.   }
  1405.   $dbh=$$dbh_ref;
  1406.   $loop_time=new Benchmark;
  1407.   # first analyze all tables
  1408.   $sth = $dbh->prepare("select table_name from user_tables") || die "Got error: $DBI::errstr";
  1409.   $sth->execute || die "Got error: $DBI::errstr when select user_tables";
  1410.   while (my @r = $sth->fetchrow_array)
  1411.   {
  1412.     $dbh->do("analyze table $r[0] compute statistics") || die "Got error: $DBI::errstr when executing 'analyze table'n";
  1413.   }
  1414.   # now analyze all indexes ...
  1415.   $sth = $dbh->prepare("select index_name from user_indexes") || die "Got error: $DBI::errstr";
  1416.   $sth->execute || die "Got error: $DBI::errstr when select user_indexes";
  1417.   while (my @r1 = $sth->fetchrow_array)
  1418.   {
  1419.     $dbh->do("analyze index $r1[0] compute statistics") || die "Got error: $DBI::errstr when executing 'analyze index $r1[0]'n";
  1420.   }
  1421.   $end_time=new Benchmark;
  1422.   print "Time for book-keeping (1): " .
  1423.   Benchmark::timestr(Benchmark::timediff($end_time, $loop_time),"all") . "nn";
  1424.   $dbh->disconnect;  $$dbh_ref= $self->connect();
  1425. }
  1426. #############################################################################
  1427. #                  Definitions for Informix
  1428. #############################################################################
  1429. package db_Informix;
  1430. sub new
  1431. {
  1432.   my ($type,$host,$database)= @_;
  1433.   my $self= {};
  1434.   my %limits;
  1435.   bless $self;
  1436.   $self->{'cmp_name'} = "Informix";
  1437.   $self->{'data_source'} = "DBI:Informix:$database";
  1438.   $self->{'limits'} = %limits;
  1439.   $self->{'blob'} = "byte in table";
  1440.   $self->{'text'} = "byte in table";
  1441.   $self->{'double_quotes'} = 0; # Can handle:  'Walker''s'
  1442.   $self->{'drop_attr'} = "";
  1443.   $self->{'transactions'} = 1; # Transactions enabled
  1444.   $self->{'host'} = $host;
  1445.   $limits{'NEG'} = 1; # Supports -id
  1446.   $limits{'alter_table'} = 1;
  1447.   $limits{'alter_add_multi_col'}= 0;
  1448.   $limits{'alter_table_dropcol'}= 1;
  1449.   $limits{'column_alias'} = 1; # Alias for fields in select statement.
  1450.   $limits{'func_extra_%'} = 0; # Has % as alias for mod()
  1451.   $limits{'func_extra_if'} = 0; # Have function if.
  1452.   $limits{'func_extra_in_num'}= 0; # Has function in
  1453.   $limits{'func_odbc_floor'} = 0; # Has func_odbc_floor function
  1454.   $limits{'func_odbc_mod'} = 1; # Have function mod.
  1455.   $limits{'functions'} = 1; # Has simple functions (+/-)
  1456.   $limits{'group_by_position'}  = 1; # Can use 'GROUP BY 1'
  1457.   $limits{'group_by_alias'}  = 0; # Can use 'select a as ab from x GROUP BY ab'
  1458.   $limits{'group_func_extra_std'} = 0; # Have group function std().
  1459.   $limits{'group_functions'} = 1; # Have group functions
  1460.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings
  1461.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  1462.   $limits{'having_with_alias'}  = 0; # Can use aliases in HAVING
  1463.   $limits{'having_with_group'}= 1; # Can't use group functions in HAVING
  1464.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables (always 1 only for msql)
  1465.   $limits{'left_outer_join'} = 0; # Supports left outer joins (ANSI)
  1466.   $limits{'like_with_column'} = 1; # Can use column1 LIKE column2
  1467.   $limits{'load_data_infile'} = 0; # Has load data infile
  1468.   $limits{'lock_tables'} = 1; # Has lock tables
  1469.   $limits{'max_conditions'} = 1214; # (Actually not a limit)
  1470.   $limits{'max_column_name'} = 18; # max table and column name
  1471.   $limits{'max_columns'} = 994; # Max number of columns in table
  1472.   $limits{'max_tables'} = 65000; # Should be big enough
  1473.   $limits{'max_index'} = 64; # Max number of keys
  1474.   $limits{'max_index_parts'} = 15; # Max segments/key
  1475.   $limits{'max_text_size'} = 65535;  # Max size with default buffers. ??
  1476.   $limits{'multi_drop'} = 0; # Drop table can take many tables
  1477.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1'
  1478.   $limits{'query_size'} = 32766; # Max size with default buffers.
  1479.   $limits{'select_without_from'}= 0; # Can do 'select 1';
  1480.   $limits{'subqueries'} = 1; # Doesn't support sub-queries.
  1481.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  1482.   $limits{'unique_index'} = 1; # Unique index works or not
  1483.   $limits{'insert_select'} = 1;
  1484.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  1485.   $limits{'order_by_unused'} = 1;
  1486.   $limits{'working_all_fields'} = 1;
  1487.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  1488.   return $self;
  1489. }
  1490. #
  1491. # Get the version number of the database
  1492. #
  1493. sub version
  1494. {
  1495.   my ($self)=@_;
  1496.   my ($dbh,$sth,$version,@row);
  1497.   $ENV{'INFORMIXSERVER'} = $self->{'host'};
  1498.   $dbh=$self->connect();
  1499.   $sth = $dbh->prepare("SELECT owner FROM systables WHERE tabname = ' VERSION'")
  1500.       or die $DBI::errstr;
  1501.   $version='Informix unknown';
  1502.   if ($sth->execute && (@row = $sth->fetchrow_array))
  1503.   {
  1504.     $version="Informix $row[0]";
  1505.   }
  1506.   $sth->finish;
  1507.   $dbh->disconnect;
  1508.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  1509.   return $version;
  1510. }
  1511. sub connect
  1512. {
  1513.   my ($self)=@_;
  1514.   my ($dbh);
  1515.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  1516.     $main::opt_password,{ PrintError => 0}) ||
  1517.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  1518.   return $dbh;
  1519. }
  1520. #
  1521. # Create table
  1522. #
  1523. sub create
  1524. {
  1525.   my($self,$table_name,$fields,$index) = @_;
  1526.   my($query,@queries,$name,$nr);
  1527.   $query="create table $table_name (";
  1528.   foreach $field (@$fields)
  1529.   {
  1530. #    $field =~ s/btransport_descriptionb/transport_desc/;
  1531. # to overcome limit 18 chars
  1532.     $field =~ s/tinyint/smallint/i;
  1533.     $field =~ s/tinyint(d+)/smallint/i;
  1534.     $field =~ s/mediumint/integer/i;
  1535.     $field =~ s/mediumint(d+)/integer/i;
  1536.     $field =~ s/smallint(d+)/smallint/i;
  1537.     $field =~ s/integer(d+)/integer/i;
  1538.     $field =~ s/int(d+)/integer/i;
  1539. #    $field =~ s/b(?:small)?int(?:eger)?((d+))/decimal($1)/i;
  1540. #    $field =~ s/float((d*,d*)){0,1}/real/i;
  1541.     $field =~ s/(float|double)((.*?))?/float/i;
  1542.     if ($field =~ / blob/i)
  1543.     {
  1544.       $name=$self->{'blob'};
  1545.       $field =~ s/ blob/ $name/;
  1546.     }
  1547.     $query.= $field . ',';
  1548.   }
  1549.   substr($query,-1)=")"; # Remove last ',';
  1550.   push(@queries,$query);
  1551.   $nr=0;
  1552.   foreach $index (@$index)
  1553.   {
  1554.     # Primary key is unique index in Informix
  1555.     $index =~ s/primary key/unique index primary/i;
  1556.     if ($index =~ /^uniques*(([^(]*))$/i)
  1557.     {
  1558.       $nr++;
  1559.       push(@queries,"create unique index ${table_name}_$nr on $table_name ($1)");
  1560.     }
  1561.     else
  1562.     {
  1563.       if (!($index =~ /^(.*index)s+(w*)s+((.*))$/i))
  1564.       {
  1565. die "Can't parse index information in '$index'n";
  1566.       }
  1567.       ### push(@queries,"create $1 ${table_name}_$2 on $table_name $3");
  1568.       $nr++;
  1569.       push(@queries,"create $1 ${table_name}_$nr on $table_name $3");
  1570.     }
  1571.   }
  1572.   return @queries;
  1573. }
  1574. #
  1575. # Some test needed this
  1576. #
  1577. sub query {
  1578.   my($self,$sql) = @_;
  1579.   return $sql;
  1580. }
  1581. sub fix_for_insert
  1582. {
  1583.   my ($self,$cmd) = @_;
  1584.   $cmd =~ s/\'//g;
  1585.   return $cmd;
  1586. }
  1587. sub drop_index
  1588. {
  1589.   my ($self,$table,$index) = @_;
  1590.   return "DROP INDEX $index";
  1591. }
  1592. #
  1593. # Abort if the server has crashed
  1594. # return: 0 if ok
  1595. #   1 question should be retried
  1596. #
  1597. sub abort_if_fatal_error
  1598. {
  1599.   return 0;
  1600. }
  1601. sub small_rollback_segment
  1602. {
  1603.   return 0;
  1604. }
  1605. sub reconnect_on_errors
  1606. {
  1607.   return 0;
  1608. }
  1609. #############################################################################
  1610. #      Configuration for Access
  1611. #############################################################################
  1612. package db_access;
  1613. sub new
  1614. {
  1615.   my ($type,$host,$database)= @_;
  1616.   my $self= {};
  1617.   my %limits;
  1618.   bless $self;
  1619.   $self->{'cmp_name'} = "access";
  1620.   $self->{'data_source'} = "DBI:ODBC:$database";
  1621.   if (defined($host) && $host ne "")
  1622.   {
  1623.     $self->{'data_source'} .= ":$host";
  1624.   }
  1625.   $self->{'limits'} = %limits;
  1626.   $self->{'blob'} = "blob";
  1627.   $self->{'text'} = "blob"; # text ? 
  1628.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  1629.   $self->{'drop_attr'} = "";
  1630.   $self->{'transactions'} = 1; # Transactions enabled
  1631.   $limits{'max_conditions'} = 97; # We get 'Query is too complex'
  1632.   $limits{'max_columns'} = 255; # Max number of columns in table
  1633.   $limits{'max_tables'} = 65000; # Should be big enough
  1634.   $limits{'max_text_size'} = 255;  # Max size with default buffers.
  1635.   $limits{'query_size'} = 65535; # Not a limit, big enough
  1636.   $limits{'max_index'} = 32; # Max number of keys
  1637.   $limits{'max_index_parts'} = 10; # Max segments/key
  1638.   $limits{'max_column_name'} = 64; # max table and column name
  1639.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables
  1640.   $limits{'load_data_infile'} = 0; # Has load data infile
  1641.   $limits{'lock_tables'} = 0; # Has lock tables
  1642.   $limits{'functions'} = 1; # Has simple functions (+/-)
  1643.   $limits{'group_functions'} = 1; # Have group functions
  1644.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings
  1645.   $limits{'group_distinct_functions'}= 0; # Have count(distinct)
  1646.   $limits{'select_without_from'}= 1; # Can do 'select 1';
  1647.   $limits{'multi_drop'} = 0; # Drop table can take many tables
  1648.   $limits{'subqueries'} = 1; # Supports sub-queries.
  1649.   $limits{'left_outer_join'} = 1; # Supports left outer joins
  1650.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  1651.   $limits{'having_with_alias'}  = 0; # Can use aliases in HAVING
  1652.   $limits{'having_with_group'} = 1; # Can use group functions in HAVING
  1653.   $limits{'like_with_column'} = 1; # Can use column1 LIKE column2
  1654.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1'
  1655.   $limits{'group_by_position'}  = 0; # Can use 'GROUP BY 1'
  1656.   $limits{'alter_table'} = 1;
  1657.   $limits{'alter_add_multi_col'}= 2; #Have ALTER TABLE t add a int, b int;
  1658.   $limits{'alter_table_dropcol'}= 1;
  1659.   $limits{'group_func_extra_std'} = 0; # Have group function std().
  1660.   $limits{'func_odbc_mod'} = 0; # Have function mod.
  1661.   $limits{'func_extra_%'} = 0; # Has % as alias for mod()
  1662.   $limits{'func_odbc_floor'} = 0; # Has func_odbc_floor function
  1663.   $limits{'func_extra_if'} = 0; # Have function if.
  1664.   $limits{'column_alias'} = 1; # Alias for fields in select statement.
  1665.   $limits{'NEG'} = 1; # Supports -id
  1666.   $limits{'func_extra_in_num'} = 1; # Has function in
  1667.   $limits{'unique_index'} = 1; # Unique index works or not
  1668.   $limits{'insert_select'} = 1;
  1669.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  1670.   $limits{'order_by_unused'} = 1;
  1671.   $limits{'working_all_fields'} = 1;
  1672.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  1673.   return $self;
  1674. }
  1675. #
  1676. # Get the version number of the database
  1677. #
  1678. sub version
  1679. {
  1680.   my ($self)=@_;
  1681.   my $version="Access 2000";
  1682.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  1683.   return $version; #DBI/ODBC can't return the server version
  1684. }
  1685. sub connect
  1686. {
  1687.   my ($self)=@_;
  1688.   my ($dbh);
  1689.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  1690.     $main::opt_password,{ PrintError => 0}) ||
  1691.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  1692.   return $dbh;
  1693. }
  1694. #
  1695. # Returns a list of statements to create a table
  1696. # The field types are in ANSI SQL format.
  1697. #
  1698. sub create
  1699. {
  1700.   my($self,$table_name,$fields,$index) = @_;
  1701.   my($query,@queries,$nr);
  1702.   $query="create table $table_name (";
  1703.   foreach $field (@$fields)
  1704.   {
  1705.     $field =~ s/mediumint/integer/i;
  1706.     $field =~ s/tinyint/smallint/i;
  1707.     $field =~ s/float(d+,d+)/float/i;
  1708.     $field =~ s/integer(d+)/integer/i;
  1709.     $field =~ s/smallint(d+)/smallint/i;
  1710.     $field =~ s/int(d+)/integer/i;
  1711.     $field =~ s/blob/text/i;
  1712.     $query.= $field . ',';
  1713.   }
  1714.   substr($query,-1)=")"; # Remove last ',';
  1715.   push(@queries,$query);
  1716.   $nr=0;
  1717.   foreach $index (@$index)
  1718.   {
  1719.     $ext="WITH DISALLOW NULL";
  1720.     if (($index =~ s/primary key/unique index primary_key/i))
  1721.     {
  1722.       $ext="WITH PRIMARY;"
  1723.     }
  1724.     if ($index =~ /^unique.*(([^(]*))$/i)
  1725.     {
  1726.       $nr++;
  1727.       $index="unique index ${table_name}_$nr ($1)";
  1728.     }
  1729.     $index =~ /^(.*)s+((.*))$/;
  1730.     push(@queries,"create ${1} on $table_name $2");
  1731.   }
  1732.   return @queries;
  1733. }
  1734. #
  1735. # Do any conversions to the ANSI SQL query so that the database can handle it
  1736. #
  1737. sub query {
  1738.   my($self,$sql) = @_;
  1739.   return $sql;
  1740. }
  1741. sub drop_index
  1742. {
  1743.   my ($self,$table,$index) = @_;
  1744.   return "DROP INDEX $index ON $table";
  1745. }
  1746. #
  1747. # Abort if the server has crashed
  1748. # return: 0 if ok
  1749. #   1 question should be retried
  1750. #
  1751. sub abort_if_fatal_error
  1752. {
  1753.   return 1 if (($DBI::errstr =~ /The database engine couldn't lock table/i) ||
  1754.                ($DBI::errstr =~ /niet vergrendelen. De tabel is momenteel in gebruik /i) ||
  1755.        ($DBI::errstr =~ /Den anv.* redan av en annan/i) ||
  1756.        ($DBI::errstr =~ /non-exclusive access/));
  1757.   return 0;
  1758. }
  1759. sub small_rollback_segment
  1760. {
  1761.   return 0;
  1762. }
  1763. sub reconnect_on_errors
  1764. {
  1765.   return 1;
  1766. }
  1767. sub fix_for_insert
  1768. {
  1769.   my ($self,$cmd) = @_;
  1770.   return $cmd;
  1771. }
  1772. #############################################################################
  1773. #      Configuration for Microsoft SQL server
  1774. #############################################################################
  1775. package db_ms_sql;
  1776. sub new
  1777. {
  1778.   my ($type,$host,$database)= @_;
  1779.   my $self= {};
  1780.   my %limits;
  1781.   bless $self;
  1782.   $self->{'cmp_name'} = "ms-sql";
  1783.   $self->{'data_source'} = "DBI:ODBC:$database";
  1784.   if (defined($host) && $host ne "")
  1785.   {
  1786.     $self->{'data_source'} .= ":$host";
  1787.   }
  1788.   $self->{'limits'} = %limits;
  1789.   $self->{'blob'} = "text";
  1790.   $self->{'text'} = "text";
  1791.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  1792.   $self->{'drop_attr'} = "";
  1793.   $self->{'transactions'} = 1; # Transactions enabled
  1794.   $limits{'max_conditions'} = 1030; # We get 'Query is too complex'
  1795.   $limits{'max_columns'} = 250; # Max number of columns in table
  1796.   $limits{'max_tables'} = 65000; # Should be big enough
  1797.   $limits{'max_text_size'} = 9830;  # Max size with default buffers.
  1798.   $limits{'query_size'} = 9830; # Max size with default buffers.
  1799.   $limits{'max_index'} = 64; # Max number of keys
  1800.   $limits{'max_index_parts'} = 15; # Max segments/key
  1801.   $limits{'max_column_name'} = 30; # max table and column name
  1802.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables
  1803.   $limits{'load_data_infile'} = 0; # Has load data infile
  1804.   $limits{'lock_tables'} = 0; # Has lock tables
  1805.   $limits{'functions'} = 1; # Has simple functions (+/-)
  1806.   $limits{'group_functions'} = 1; # Have group functions
  1807.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings
  1808.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  1809.   $limits{'select_without_from'}= 1; # Can do 'select 1';
  1810.   $limits{'multi_drop'} = 1; # Drop table can take many tables
  1811.   $limits{'subqueries'} = 1; # Supports sub-queries.
  1812.   $limits{'left_outer_join'} = 1; # Supports left outer joins
  1813.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  1814.   $limits{'having_with_alias'}  = 0; # Can use aliases in HAVING
  1815.   $limits{'having_with_group'} = 1; # Can't use group functions in HAVING
  1816.   $limits{'like_with_column'} = 1; # Can use column1 LIKE column2
  1817.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1'
  1818.   $limits{'group_by_position'}  = 0; # Can use 'GROUP BY 1'
  1819.   $limits{'alter_table'} = 1;
  1820.   $limits{'alter_add_multi_col'}= 0;
  1821.   $limits{'alter_table_dropcol'}= 0;
  1822.   $limits{'group_func_extra_std'} = 0; # Have group function std().
  1823.   $limits{'func_odbc_mod'} = 0; # Have function mod.
  1824.   $limits{'func_extra_%'} = 1; # Has % as alias for mod()
  1825.   $limits{'func_odbc_floor'} = 1; # Has func_odbc_floor function
  1826.   $limits{'func_extra_if'} = 0; # Have function if.
  1827.   $limits{'column_alias'} = 1; # Alias for fields in select statement.
  1828.   $limits{'NEG'} = 1; # Supports -id
  1829.   $limits{'func_extra_in_num'} = 0; # Has function in
  1830.   $limits{'unique_index'} = 1; # Unique index works or not
  1831.   $limits{'insert_select'} = 1;
  1832.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  1833.   $limits{'order_by_unused'} = 1;
  1834.   $limits{'working_all_fields'} = 1;
  1835.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  1836.   return $self;
  1837. }
  1838. #
  1839. # Get the version number of the database
  1840. #
  1841. sub version
  1842. {
  1843.   my ($self)=@_;
  1844.   my($sth,@row, $version);
  1845.   $version='MS SQL server ?';
  1846.   $dbh=$self->connect();
  1847.   $sth = $dbh->prepare("SELECT @@VERSION") or die $DBI::errstr;
  1848.   $sth->execute or die $DBI::errstr;
  1849.   @row = $sth->fetchrow_array;
  1850.   if ($row[0]) {
  1851.      @server = split(/n/,$row[0]);
  1852.      chomp(@server);
  1853.      $version= "$server[0]";
  1854.   } 
  1855.   $sth->finish;
  1856.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  1857.   return $version;
  1858. }
  1859. sub connect
  1860. {
  1861.   my ($self)=@_;
  1862.   my ($dbh);
  1863.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  1864.     $main::opt_password,{ PrintError => 0}) ||
  1865.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  1866.   return $dbh;
  1867. }
  1868. #
  1869. # Returns a list of statements to create a table
  1870. # The field types are in ANSI SQL format.
  1871. #
  1872. sub create
  1873. {
  1874.   my($self,$table_name,$fields,$index) = @_;
  1875.   my($query,@queries,$nr);
  1876.   $query="create table $table_name (";
  1877.   foreach $field (@$fields)
  1878.   {
  1879.     $field =~ s/mediumint/integer/i;
  1880.     $field =~ s/float(d+,d+)/float/i;
  1881.     $field =~ s/double(d+,d+)/float/i;
  1882.     $field =~ s/double/float/i;
  1883.     $field =~ s/integer(d+)/integer/i;
  1884.     $field =~ s/int(d+)/integer/i;
  1885.     $field =~ s/smallint(d+)/smallint/i;
  1886.     $field =~ s/smallinteger/smallint/i;
  1887.     $field =~ s/tinyint(d+)/tinyint/i;
  1888.     $field =~ s/tinyinteger/tinyint/i;
  1889.     $field =~ s/blob/text/i;
  1890.     $query.= $field . ',';
  1891.   }
  1892.   substr($query,-1)=")"; # Remove last ',';
  1893.   push(@queries,$query);
  1894.   $nr=0;
  1895.   foreach $index (@$index)
  1896.   {
  1897.     $ext="WITH DISALLOW NULL";
  1898.     if (($index =~ s/primary key/unique index primary_key/i))
  1899.     {
  1900.       $ext="WITH PRIMARY;"
  1901.     }
  1902.     if ($index =~ /^unique.*(([^(]*))$/i)
  1903.     {
  1904.       $nr++;
  1905.       $index="unique index ${table_name}_$nr ($1)";
  1906.     }
  1907.     $index =~ /^(.*)s+((.*))$/;
  1908.     push(@queries,"create ${1} on $table_name $2");
  1909.   }
  1910.   return @queries;
  1911. }
  1912. #
  1913. # Do any conversions to the ANSI SQL query so that the database can handle it
  1914. #
  1915. sub query {
  1916.   my($self,$sql) = @_;
  1917.   return $sql;
  1918. }
  1919. sub drop_index
  1920. {
  1921.   my ($self,$table,$index) = @_;
  1922.   return "DROP INDEX $table.$index";
  1923. }
  1924. #
  1925. # Abort if the server has crashed
  1926. # return: 0 if ok
  1927. #   1 question should be retried
  1928. #
  1929. sub abort_if_fatal_error
  1930. {
  1931.   return 0;
  1932. }
  1933. sub small_rollback_segment
  1934. {
  1935.   return 0;
  1936. }
  1937. sub reconnect_on_errors
  1938. {
  1939.   return 0;
  1940. }
  1941. sub fix_for_insert
  1942. {
  1943.   my ($self,$cmd) = @_;
  1944.   return $cmd;
  1945. }
  1946. #############################################################################
  1947. #      Configuration for Sybase
  1948. #############################################################################
  1949. package db_sybase;
  1950. sub new
  1951. {
  1952.   my ($type,$host,$database)= @_;
  1953.   my $self= {};
  1954.   my %limits;
  1955.   bless $self;
  1956.   $self->{'cmp_name'} = "sybase";
  1957.   $self->{'data_source'} = "DBI:Sybase:database=$database";
  1958.   if (defined($host) && $host ne "")
  1959.   {
  1960.     $self->{'data_source'} .= ";hostname=$host";
  1961.   }
  1962.   $self->{'limits'} = %limits;
  1963.   $self->{'blob'} = "text";
  1964.   $self->{'text'} = "text";
  1965.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  1966.   $self->{'drop_attr'} = "";
  1967.   $self->{'transactions'} = 1; # Transactions enabled
  1968.   $self->{"vacuum"} = 1;
  1969.   $limits{'max_conditions'} = 1030; # We get 'Query is too complex'
  1970.   $limits{'max_columns'} = 250; # Max number of columns in table
  1971.   $limits{'max_tables'} = 65000; # Should be big enough
  1972.   $limits{'max_text_size'} = 9830;  # Max size with default buffers.
  1973.   $limits{'query_size'} = 9830; # Max size with default buffers.
  1974.   $limits{'max_index'} = 64; # Max number of keys
  1975.   $limits{'max_index_parts'} = 15; # Max segments/key
  1976.   $limits{'max_column_name'} = 30; # max table and column name
  1977.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables
  1978.   $limits{'load_data_infile'} = 0; # Has load data infile
  1979.   $limits{'lock_tables'} = 0; # Has lock tables
  1980.   $limits{'functions'} = 1; # Has simple functions (+/-)
  1981.   $limits{'group_functions'} = 1; # Have group functions
  1982.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings
  1983.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  1984.   $limits{'select_without_from'}= 1; # Can do 'select 1';
  1985.   $limits{'multi_drop'} = 1; # Drop table can take many tables
  1986.   $limits{'subqueries'} = 1; # Supports sub-queries.
  1987.   $limits{'left_outer_join'} = 1; # Supports left outer joins
  1988.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  1989.   $limits{'having_with_alias'}  = 0; # Can use aliases in HAVING
  1990.   $limits{'having_with_group'} = 1; # Can't use group functions in HAVING
  1991.   $limits{'like_with_column'} = 1; # Can use column1 LIKE column2
  1992.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1'
  1993.   $limits{'group_by_position'}  = 0; # Can use 'GROUP BY 1'
  1994.   $limits{'alter_table'} = 1;
  1995.   $limits{'alter_add_multi_col'}= 0;
  1996.   $limits{'alter_table_dropcol'}= 0;
  1997.   $limits{'group_func_extra_std'} = 0; # Have group function std().
  1998.   $limits{'func_odbc_mod'} = 0; # Have function mod.
  1999.   $limits{'func_extra_%'} = 1; # Has % as alias for mod()
  2000.   $limits{'func_odbc_floor'} = 1; # Has func_odbc_floor function
  2001.   $limits{'func_extra_if'} = 0; # Have function if.
  2002.   $limits{'column_alias'} = 1; # Alias for fields in select statement.
  2003.   $limits{'NEG'} = 1; # Supports -id
  2004.   $limits{'func_extra_in_num'} = 0; # Has function in
  2005.   $limits{'unique_index'} = 1; # Unique index works or not
  2006.   $limits{'insert_select'} = 1;
  2007.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  2008.   $limits{'order_by_unused'} = 1;
  2009.   $limits{'working_all_fields'} = 1;
  2010.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  2011.   return $self;
  2012. }
  2013. #
  2014. # Get the version number of the database
  2015. #
  2016. sub version
  2017. {
  2018.   my ($self)=@_;
  2019.   my ($dbh,$sth,$version,@row);
  2020.   $dbh=$self->connect();
  2021.   $sth = $dbh->prepare('SELECT @@version') or die $DBI::errstr;
  2022.   $version="Sybase (unknown)";
  2023.   if ($sth->execute && (@row = $sth->fetchrow_array))
  2024.   {
  2025.     $version=$row[0];
  2026.   }
  2027.   $sth->finish;
  2028.   $dbh->disconnect;
  2029.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  2030.   return $version;
  2031. }
  2032. sub connect
  2033. {
  2034.   my ($self)=@_;
  2035.   my ($dbh);
  2036.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  2037.     $main::opt_password,{ PrintError => 0 , AutoCommit => 1}) ||
  2038.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  2039.   return $dbh;
  2040. }
  2041. #
  2042. # Returns a list of statements to create a table
  2043. # The field types are in ANSI SQL format.
  2044. #
  2045. sub create
  2046. {
  2047.   my($self,$table_name,$fields,$index) = @_;
  2048.   my($query,@queries,$nr);
  2049.   $query="create table $table_name (";
  2050.   foreach $field (@$fields)
  2051.   {
  2052.     $field =~ s/mediumint/integer/i;
  2053.     $field =~ s/float(d+,d+)/float/i;
  2054.     $field =~ s/int(d+)/int/i;
  2055.     $field =~ s/double/float/i;
  2056.     $field =~ s/integer(d+)/integer/i;
  2057.     $field =~ s/smallint(d+)/smallint/i;
  2058.     $field =~ s/tinyint(d+)/tinyint/i;
  2059.     $field =~ s/blob/text/i;
  2060.     $query.= $field . ',';
  2061.   }
  2062.   substr($query,-1)=")"; # Remove last ',';
  2063.   push(@queries,$query);
  2064.   $nr=0;
  2065.   foreach $index (@$index)
  2066.   {
  2067. #    $ext="WITH DISALLOW NULL";
  2068.     if (($index =~ s/primary key/unique index primary_key/i))
  2069.     {
  2070. #      $ext="WITH PRIMARY;"
  2071.     }
  2072.     if ($index =~ /^unique.*(([^(]*))$/i)
  2073.     {
  2074.       $nr++;
  2075.       $index="unique index ${table_name}_$nr ($1)";
  2076.     }
  2077.     $index =~ /^(.*)s+((.*))$/;
  2078.     push(@queries,"create ${1} on $table_name $2");
  2079.   }
  2080.   return @queries;
  2081. }
  2082. #
  2083. # Do any conversions to the ANSI SQL query so that the database can handle it
  2084. #
  2085. sub query {
  2086.   my($self,$sql) = @_;
  2087.   return $sql;
  2088. }
  2089. sub drop_index
  2090. {
  2091.   my ($self,$table,$index) = @_;
  2092.   return "DROP INDEX $table.$index";
  2093. }
  2094. #
  2095. # Abort if the server has crashed
  2096. # return: 0 if ok
  2097. #   1 question should be retried
  2098. #
  2099. sub abort_if_fatal_error
  2100. {
  2101.   return 0;
  2102. }
  2103. sub small_rollback_segment
  2104. {
  2105.   return 0;
  2106. }
  2107. sub reconnect_on_errors
  2108. {
  2109.   return 0;
  2110. }
  2111. sub fix_for_insert
  2112. {
  2113.   my ($self,$cmd) = @_;
  2114.   return $cmd;
  2115. }
  2116. #
  2117. # optimize the tables ....
  2118. #  WARNING (from walrus)! This sub will work only from DBD:sybase
  2119. # driver. Because if we use ODBC we don't know actual database name
  2120. # (but DSN name only)
  2121. sub vacuum
  2122. {
  2123.   my ($self,$full_vacuum,$dbh_ref)=@_;
  2124.   my ($loop_time,$end_time,$dbh);
  2125.   if (defined($full_vacuum))
  2126.   {
  2127.     $$dbh_ref->disconnect;  $$dbh_ref= $self->connect();
  2128.   }
  2129.   $dbh=$$dbh_ref;
  2130.   $loop_time=new Benchmark;
  2131.   my (@tables,$sth,$current_table,$current_base);
  2132.   $dbh->do("dump tran $database with truncate_only");
  2133.   $sth=$dbh->prepare("sp_tables" ) or die "prepere";
  2134.   $sth->execute() or die "execute";
  2135.   while (@row = $sth->fetchrow_array()) {
  2136.     $current_table = $row[2];
  2137.     $current_base = $row[0];
  2138.     next if ($current_table =~ /^sys/); 
  2139.     push(@tables,$current_table) if ($database == $current_base);    
  2140.    }
  2141.   $sth->finish();
  2142.   foreach $table (@tables) {
  2143. #    print "$table: n";
  2144.     $dbh->do("update statistics $table") or print "Oops!"; 
  2145.   }
  2146.  
  2147. #  $dbh->do("analyze table ?? compute statistics") || die "Got error: $DBI::errstr when executing 'vacuum'n";
  2148.   $end_time=new Benchmark;
  2149.   print "Time for book-keeping (1): " .
  2150.   Benchmark::timestr(Benchmark::timediff($end_time, $loop_time),"all") . "nn";
  2151.   $dbh->disconnect;  $$dbh_ref= $self->connect();
  2152. }
  2153. #############################################################################
  2154. #                  Definitions for Adabas
  2155. #############################################################################
  2156. package db_Adabas;
  2157. sub new
  2158. {
  2159.   my ($type,$host,$database)= @_;
  2160.   my $self= {};
  2161.   my %limits;
  2162.   bless $self;
  2163.   $self->{'cmp_name'} = "Adabas";
  2164.   $self->{'data_source'} = "DBI:Adabas:$database";
  2165.   $self->{'limits'} = %limits;
  2166.   $self->{'blob'} = "long";
  2167.   $self->{'text'} = "long";
  2168.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  2169.   $self->{'drop_attr'} = "";
  2170.   $self->{'transactions'} = 1; # Transactions enabled
  2171.   $limits{'max_conditions'} = 50; # (Actually not a limit)
  2172.   $limits{'max_columns'} = 254; # Max number of columns in table
  2173.   $limits{'max_tables'} = 65000; # Should be big enough
  2174.   $limits{'max_text_size'} = 2000; # Limit for blob test-connect
  2175.   $limits{'query_size'} = 65525; # Max size with default buffers.
  2176.   $limits{'max_index'} = 16; # Max number of keys
  2177.   $limits{'max_index_parts'} = 16; # Max segments/key
  2178.   $limits{'max_column_name'} = 32; # max table and column name
  2179.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables
  2180.   $limits{'load_data_infile'} = 0; # Has load data infile
  2181.   $limits{'lock_tables'} = 0; # Has lock tables
  2182.   $limits{'functions'} = 1; # Has simple functions (+/-)
  2183.   $limits{'group_functions'} = 1; # Have group functions
  2184.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings
  2185.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  2186.   $limits{'select_without_from'}= 0;
  2187.   $limits{'multi_drop'} = 0;
  2188.   $limits{'subqueries'} = 1;
  2189.   $limits{'left_outer_join'} = 0; # This may be fixed in the query module
  2190.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  2191.   $limits{'having_with_alias'}  = 0; # Can use aliases in HAVING
  2192.   $limits{'having_with_group'} = 1; # Can't use group functions in HAVING
  2193.   $limits{'like_with_column'} = 1; # Can use column1 LIKE column2
  2194.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1'
  2195.   $limits{'group_by_position'}  = 1;
  2196.   $limits{'alter_table'} = 1;
  2197.   $limits{'alter_add_multi_col'}= 2; #Have ALTER TABLE t add a int, b int;
  2198.   $limits{'alter_table_dropcol'}= 1;
  2199.   $limits{'group_func_extra_std'} = 0; # Have group function std().
  2200.   $limits{'func_odbc_mod'} = 0; # Oracle has problem with mod()
  2201.   $limits{'func_extra_%'} = 0; # Has % as alias for mod()
  2202.   $limits{'func_odbc_floor'} = 1; # Has func_odbc_floor function
  2203.   $limits{'func_extra_if'} = 0; # Have function if.
  2204.   $limits{'column_alias'} = 1; # Alias for fields in select statement.
  2205.   $limits{'NEG'} = 1; # Supports -id
  2206.   $limits{'func_extra_in_num'} = 1; # Has function in
  2207.   $limits{'unique_index'} = 1; # Unique index works or not
  2208.   $limits{'insert_select'} = 1;
  2209.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  2210.   $limits{'order_by_unused'} = 1;
  2211.   $limits{'working_all_fields'} = 1;
  2212.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  2213.   return $self;
  2214. }
  2215. #
  2216. # Get the version number of the database
  2217. #
  2218. sub version
  2219. {
  2220.   my ($self)=@_;
  2221.   my ($dbh,$sth,$version,@row);
  2222.   $dbh=$self->connect();
  2223.   $sth = $dbh->prepare("SELECT KERNEL FROM VERSIONS") or die $DBI::errstr;
  2224.   $version="Adabas (unknown)";
  2225.   if ($sth->execute && (@row = $sth->fetchrow_array)
  2226.       && $row[0] =~ /([d.]+)/)
  2227.   {
  2228.     $version="Adabas $1";
  2229.   }
  2230.   $sth->finish;
  2231.   $dbh->disconnect;
  2232.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  2233.   return $version;
  2234. }
  2235. sub connect
  2236. {
  2237.   my ($self)=@_;
  2238.   my ($dbh);
  2239.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  2240.     $main::opt_password,{ PrintError => 0}) ||
  2241.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  2242.   return $dbh;
  2243. }
  2244. #
  2245. # Returns a list of statements to create a table
  2246. # The field types are in ANSI SQL format.
  2247. #
  2248. # If one uses $main::opt_fast then one is allowed to use
  2249. # non standard types to get better speed.
  2250. #
  2251. sub create
  2252. {
  2253.   my($self,$table_name,$fields,$index) = @_;
  2254.   my($query,@queries,$ind,@keys);
  2255.   $query="create table $table_name (";
  2256.   foreach $field (@$fields)
  2257.   {
  2258.     $field =~ s/CHARACTERs+VARYING/VARCHAR/i;
  2259.     $field =~ s/TINYINT/SMALLINT/i;
  2260.     $field =~ s/MEDIUMINT/INT/i;
  2261.     $field =~ s/SMALLINTs*(d+)/SMALLINT/i;
  2262.     $field =~ s/INTs*(d+)/INT/i;
  2263.     $field =~ s/BLOB/LONG/i;
  2264.     $field =~ s/INTEGERs*(d+)/INTEGER/i;
  2265.     $field =~ s/FLOATs*((d+),d+)/FLOAT($1)/i;
  2266.     $field =~ s/DOUBLE/FLOAT(38)/i;
  2267.     $field =~ s/DOUBLEs+PRECISION/FLOAT(38)/i;
  2268.     $query.= $field . ',';
  2269.   }
  2270.   foreach $ind (@$index)
  2271.   {
  2272.     my @index;
  2273.     if ( $ind =~ /bKEYb/i ){
  2274.       push(@keys,"ALTER TABLE $table_name ADD $ind");
  2275.     }else{
  2276.       my @fields = split(' ',$index);
  2277.       my $query="CREATE INDEX $fields[1] ON $table_name $fields[2]";
  2278.       push(@index,$query);
  2279.     }
  2280.   }
  2281.   substr($query,-1)=")"; # Remove last ',';
  2282.   push(@queries,$query,@keys,@index);
  2283. #print "query:$queryn";
  2284.   return @queries;
  2285. }
  2286. sub insert_file {
  2287.   my($self,$dbname, $file) = @_;
  2288.   print "insert an ascii file isn't supported by Oracle (?)n";
  2289.   return 0;
  2290. }
  2291. #
  2292. # Do any conversions to the ANSI SQL query so that the database can handle it
  2293. #
  2294. sub query {
  2295.   my($self,$sql) = @_;
  2296.   return $sql;
  2297. }
  2298. sub drop_index
  2299. {
  2300.   my ($self,$table,$index) = @_;
  2301.   return "DROP INDEX $index";
  2302. }
  2303. #
  2304. # Abort if the server has crashed
  2305. # return: 0 if ok
  2306. #   1 question should be retried
  2307. #
  2308. sub abort_if_fatal_error
  2309. {
  2310.   return 0;
  2311. }
  2312. sub small_rollback_segment
  2313. {
  2314.   return 0;
  2315. }
  2316. sub reconnect_on_errors
  2317. {
  2318.   return 0;
  2319. }
  2320. sub fix_for_insert
  2321. {
  2322.   my ($self,$cmd) = @_;
  2323.   return $cmd;
  2324. }
  2325. #############################################################################
  2326. #      Configuration for IBM DB2
  2327. #############################################################################
  2328. package db_db2;
  2329. sub new
  2330. {
  2331.   my ($type,$host,$database)= @_;
  2332.   my $self= {};
  2333.   my %limits;
  2334.   bless $self;
  2335.   $self->{'cmp_name'} = "DB2";
  2336.   $self->{'data_source'} = "DBI:ODBC:$database";
  2337.   if (defined($host) && $host ne "")
  2338.   {
  2339.     $self->{'data_source'} .= ":$host";
  2340.   }
  2341.   $self->{'limits'} = %limits;
  2342.   $self->{'blob'} = "varchar(255)";
  2343.   $self->{'text'} = "varchar(255)";
  2344.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  2345.   $self->{'drop_attr'} = "";
  2346.   $self->{'transactions'} = 1; # Transactions enabled
  2347.   $limits{'max_conditions'} = 418; # We get 'Query is too complex'
  2348.   $limits{'max_columns'} = 500; # Max number of columns in table
  2349.   $limits{'max_tables'} = 65000; # Should be big enough
  2350.   $limits{'max_text_size'} = 254;  # Max size with default buffers.
  2351.   $limits{'query_size'} = 254; # Max size with default buffers.
  2352.   $limits{'max_index'} = 48; # Max number of keys
  2353.   $limits{'max_index_parts'} = 15; # Max segments/key
  2354.   $limits{'max_column_name'} = 18; # max table and column name
  2355.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables
  2356.   $limits{'load_data_infile'} = 0; # Has load data infile
  2357.   $limits{'lock_tables'} = 0; # Has lock tables
  2358.   $limits{'functions'} = 1; # Has simple functions (+/-)
  2359.   $limits{'group_functions'} = 1; # Have group functions
  2360.   $limits{'group_func_sql_min_str'}= 1;
  2361.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  2362.   $limits{'select_without_from'}= 0; # Can do 'select 1';
  2363.   $limits{'multi_drop'} = 0; # Drop table can take many tables
  2364.   $limits{'subqueries'} = 1; # Supports sub-queries.
  2365.   $limits{'left_outer_join'} = 1; # Supports left outer joins
  2366.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  2367.   $limits{'having_with_alias'}  = 0; # Can use aliases in HAVING
  2368.   $limits{'having_with_group'} = 1; # Can't use group functions in HAVING
  2369.   $limits{'like_with_column'} = 0; # Can use column1 LIKE column2
  2370.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1'
  2371.   $limits{'group_by_position'}  = 0; # Can use 'GROUP BY 1'
  2372.   $limits{'alter_table'} = 1;
  2373.   $limits{'alter_add_multi_col'}= 0;
  2374.   $limits{'alter_table_dropcol'}= 0;
  2375.   $limits{'group_func_extra_std'} = 0; # Have group function std().
  2376.   $limits{'func_odbc_mod'} = 1; # Have function mod.
  2377.   $limits{'func_extra_%'} = 0; # Has % as alias for mod()
  2378.   $limits{'func_odbc_floor'} = 1; # Has func_odbc_floor function
  2379.   $limits{'func_extra_if'} = 0; # Have function if.
  2380.   $limits{'column_alias'} = 1; # Alias for fields in select statement.
  2381.   $limits{'NEG'} = 1; # Supports -id
  2382.   $limits{'func_extra_in_num'} = 0; # Has function in
  2383.   $limits{'unique_index'} = 1; # Unique index works or not
  2384.   $limits{'insert_select'} = 1;
  2385.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  2386.   $limits{'order_by_unused'} = 1;
  2387.   $limits{'working_all_fields'} = 1;
  2388.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  2389.   return $self;
  2390. }
  2391. #
  2392. # Get the version number of the database
  2393. #
  2394. sub version
  2395. {
  2396.   my ($self)=@_;
  2397.   return "IBM DB2 5"; #DBI/ODBC can't return the server version
  2398. }
  2399. sub connect
  2400. {
  2401.   my ($self)=@_;
  2402.   my ($dbh);
  2403.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user, $main::opt_password) ||
  2404.     die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  2405.   return $dbh;
  2406. }
  2407. #
  2408. # Returns a list of statements to create a table
  2409. # The field types are in ANSI SQL format.
  2410. #
  2411. sub create
  2412. {
  2413.   my($self,$table_name,$fields,$index) = @_;
  2414.   my($query,@queries,$nr);
  2415.   $query="create table $table_name (";
  2416.   foreach $field (@$fields)
  2417.   {
  2418.     $field =~ s/mediumint/integer/i;
  2419.     $field =~ s/float(d+,d+)/float/i;
  2420.     $field =~ s/integer(d+)/integer/i;
  2421.     $field =~ s/int(d+)/integer/i;
  2422.     $field =~ s/tinyint(d+)/smallint/i;
  2423.     $field =~ s/tinyint/smallint/i;
  2424.     $field =~ s/smallint(d+)/smallint/i;
  2425.     $field =~ s/smallinteger/smallint/i;
  2426.     $field =~ s/blob/varchar(256)/i;
  2427.     $query.= $field . ',';
  2428.   }
  2429.   substr($query,-1)=")"; # Remove last ',';
  2430.   push(@queries,$query);
  2431.   $nr=0;
  2432.   foreach $index (@$index)
  2433.   {
  2434.     $ext="WITH DISALLOW NULL";
  2435.     if (($index =~ s/primary key/unique index primary_key/i))
  2436.     {
  2437.       $ext="WITH PRIMARY;"
  2438.     }
  2439.     if ($index =~ /^unique.*(([^(]*))$/i)
  2440.     {
  2441.       $nr++;
  2442.       $index="unique index ${table_name}_$nr ($1)";
  2443.     }
  2444.     $index =~ /^(.*)s+((.*))$/;
  2445.     push(@queries,"create ${1} on $table_name $2");
  2446.   }
  2447.   return @queries;
  2448. }
  2449. #
  2450. # Do any conversions to the ANSI SQL query so that the database can handle it
  2451. #
  2452. sub query {
  2453.   my($self,$sql) = @_;
  2454.   return $sql;
  2455. }
  2456. sub drop_index
  2457. {
  2458.   my ($self,$table,$index) = @_;
  2459.   return "DROP INDEX $table.$index";
  2460. }
  2461. #
  2462. # Abort if the server has crashed
  2463. # return: 0 if ok
  2464. #   1 question should be retried
  2465. #
  2466. sub abort_if_fatal_error
  2467. {
  2468.   return 0;
  2469. }
  2470. sub small_rollback_segment
  2471. {
  2472.   return 1;
  2473. }
  2474. sub reconnect_on_errors
  2475. {
  2476.   return 0;
  2477. }
  2478. sub fix_for_insert
  2479. {
  2480.   my ($self,$cmd) = @_;
  2481.   return $cmd;
  2482. }
  2483. #############################################################################
  2484. #      Configuration for MIMER 
  2485. #############################################################################
  2486. package db_Mimer;
  2487. sub new
  2488. {
  2489.   my ($type,$host,$database)= @_;
  2490.   my $self= {};
  2491.   my %limits;
  2492.   bless $self;
  2493.   $self->{'cmp_name'} = "mimer";
  2494.   $self->{'data_source'} = "DBI:mimer:$database:$host";
  2495.   $self->{'limits'} = %limits;
  2496.   $self->{'blob'} = "binary varying(15000)";
  2497.   $self->{'text'} = "character varying(15000)";
  2498.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  2499.   $self->{'drop_attr'} = "";
  2500.   $self->{'transactions'} = 1; # Transactions enabled
  2501.   $self->{'char_null'}          = "cast(NULL as char(1))";
  2502.   $self->{'numeric_null'}       = "cast(NULL as int)";
  2503.   $limits{'max_conditions'} = 9999; # (Actually not a limit)
  2504.   $limits{'max_columns'} = 252; # Max number of columns in table
  2505.   $limits{'max_tables'} = 65000; # Should be big enough
  2506.   $limits{'max_text_size'} = 15000; # Max size with default buffers.
  2507.   $limits{'query_size'} = 1000000; # Max size with default buffers.
  2508.   $limits{'max_index'} = 32; # Max number of keys
  2509.   $limits{'max_index_parts'} = 16; # Max segments/key
  2510.   $limits{'max_column_name'} = 128; # max table and column name
  2511.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables
  2512.   $limits{'load_data_infile'} = 1; # Has load data infile
  2513.   $limits{'lock_tables'} = 0; # Has lock tables
  2514.   $limits{'functions'} = 1; # Has simple functions (+/-)
  2515.   $limits{'group_functions'} = 1; # Have group functions
  2516.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings
  2517.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  2518.   $limits{'select_without_from'}= 0; # Cannot do 'select 1';
  2519.   $limits{'multi_drop'} = 0; # Drop table cannot take many tables
  2520.   $limits{'subqueries'} = 1; # Supports sub-queries.
  2521.   $limits{'left_outer_join'} = 1; # Supports left outer joins
  2522.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  2523.   $limits{'having_with_alias'}  = 0; # Can use aliases in HAVING
  2524.   $limits{'having_with_group'} = 1; # Can use group functions in HAVING
  2525.   $limits{'like_with_column'} = 1; # Can use column1 LIKE column2
  2526.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1'
  2527.   $limits{'group_by_position'}  = 0; # Cannot use 'GROUP BY 1'
  2528.   $limits{'alter_table'} = 1; # Have ALTER TABLE
  2529.   $limits{'alter_add_multi_col'}= 0; # Have ALTER TABLE t add a int,add b int;
  2530.   $limits{'alter_table_dropcol'}= 1; # Have ALTER TABLE DROP column
  2531.   $limits{'insert_multi_value'} = 0; # Does not have INSERT ... values (1,2),(3,4)
  2532.   $limits{'multi_distinct'}     = 0; # Does not allow select count(distinct a),count(distinct b).. 
  2533.   $limits{'group_func_extra_std'} = 0; # Does not have group function std().
  2534.   $limits{'func_odbc_mod'} = 1; # Have function mod.
  2535.   $limits{'func_extra_%'} = 0; # Does not have % as alias for mod()
  2536.   $limits{'func_odbc_floor'} = 1; # Has func_odbc_floor function
  2537.   $limits{'func_extra_if'} = 0; # Does not have function if.
  2538.   $limits{'column_alias'} = 1; # Alias for fields in select statement.
  2539.   $limits{'NEG'} = 1; # Supports -id
  2540.   $limits{'func_extra_in_num'} = 1; # Has function in
  2541.   $limits{'limit'} = 0; # Does not support the limit attribute
  2542.   $limits{'unique_index'} = 1; # Unique index works or not
  2543.   $limits{'insert_select'} = 1;
  2544.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  2545.   $limits{'order_by_unused'} = 0;
  2546.   $limits{'working_all_fields'} = 1;
  2547.   return $self;
  2548. }
  2549. #
  2550. # Get the version number of the database
  2551. #
  2552. sub version
  2553. {
  2554.   my ($self)=@_;
  2555.   my ($dbh,$sth,$version,@row);
  2556.   $dbh=$self->connect();
  2557. #
  2558. #  Pick up SQLGetInfo option SQL_DBMS_VER (18)
  2559. #
  2560.   $version = $dbh->func(18, GetInfo);
  2561.   $dbh->disconnect;
  2562.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);  
  2563.   return $version;
  2564. }
  2565. #
  2566. # Connection with optional disabling of logging
  2567. #
  2568. sub connect
  2569. {
  2570.   my ($self)=@_;
  2571.   my ($dbh);
  2572.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  2573.     $main::opt_password,{ PrintError => 0}) ||
  2574.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  2575.   $dbh->do("SET OPTION LOG_OFF=1,UPDATE_LOG=0");
  2576.   return $dbh;
  2577. }
  2578. #
  2579. # Returns a list of statements to create a table
  2580. # The field types are in ANSI SQL format.
  2581. #
  2582. # If one uses $main::opt_fast then one is allowed to use
  2583. # non standard types to get better speed.
  2584. #
  2585. sub create
  2586. {
  2587.   my($self,$table_name,$fields,$index,$options) = @_;
  2588.   my($query,@queries,@indexes);
  2589.   $query="create table $table_name (";
  2590.   foreach $field (@$fields)
  2591.   {
  2592. #    $field =~ s/ decimal/ double(10,2)/i;
  2593. #    $field =~ s/ big_decimal/ double(10,2)/i;
  2594.     $field =~ s/ double/ double precision/i;  
  2595.     $field =~ s/ tinyint(.*)/ smallint/i;
  2596.     $field =~ s/ smallint(.*)/ smallint/i;
  2597.     $field =~ s/ mediumint/ integer/i;
  2598.     $field =~ s/ float(.*)/ float/i;
  2599. #    $field =~ s/ date/ int/i; # Because of tcp ?
  2600.     $query.= $field . ',';
  2601.   }
  2602.   foreach $index (@$index)
  2603.   {
  2604.     if ( $index =~ /bINDEXb/i )
  2605.     {
  2606.       my @fields = split(' ',$index);
  2607.       my $query="CREATE INDEX $fields[1] ON $table_name $fields[2]";
  2608.       push(@indexes,$query);
  2609.     
  2610.     } else {
  2611.       $query.= $index . ',';
  2612.     }
  2613.   }
  2614.   substr($query,-1)=")"; # Remove last ',';
  2615.   $query.=" $options" if (defined($options));
  2616.   push(@queries,$query,@indexes);
  2617.   return @queries;
  2618. }
  2619. sub insert_file {
  2620.   my($self,$dbname, $file) = @_;
  2621.   print "insert of an ascii file isn't supported by Mimern";
  2622.   return 0;
  2623. }
  2624. #
  2625. # Do any conversions to the ANSI SQL query so that the database can handle it
  2626. #
  2627. sub query {
  2628.   my($self,$sql) = @_;
  2629.   return $sql;
  2630. }
  2631. sub drop_index {
  2632.   my ($self,$table,$index) = @_;
  2633.   return "DROP INDEX $index";
  2634. }
  2635. #
  2636. # Abort if the server has crashed
  2637. # return: 0 if ok
  2638. #   1 question should be retried
  2639. #
  2640. sub abort_if_fatal_error
  2641. {
  2642.   return 1 if ($DBI::errstr =~ /Table locked by another cursor/);
  2643.   return 0;
  2644. }
  2645. sub small_rollback_segment
  2646. {
  2647.   return 0;
  2648. }
  2649. sub reconnect_on_errors
  2650. {
  2651.   return 0;
  2652. }
  2653. sub fix_for_insert
  2654. {
  2655.   my ($self,$cmd) = @_;
  2656.   return $cmd;
  2657. }
  2658. #############################################################################
  2659. #      Configuration for InterBase
  2660. #############################################################################
  2661. package db_interbase;
  2662. sub new
  2663. {
  2664.   my ($type,$host,$database)= @_;
  2665.   my $self= {};
  2666.   my %limits;
  2667.   bless $self;
  2668.   $self->{'cmp_name'} = "interbase";
  2669.   $self->{'data_source'} = "DBI:InterBase:database=$database;ib_dialect=3";
  2670.   $self->{'limits'} = %limits;
  2671.   $self->{'blob'} = "blob";
  2672.   $self->{'text'} = "";
  2673.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  2674.   $self->{'drop_attr'} = "";
  2675.   $self->{'transactions'} = 1; # Transactions enabled
  2676.   $self->{'char_null'}          = "";
  2677.   $self->{'numeric_null'}       = "";
  2678.   $limits{'max_conditions'} = 9999; # (Actually not a limit)
  2679.   $limits{'max_columns'} = 252; # Max number of columns in table
  2680.   $limits{'max_tables'} = 65000; # Should be big enough
  2681.   $limits{'max_text_size'} = 15000; # Max size with default buffers.
  2682.   $limits{'query_size'} = 1000000; # Max size with default buffers.
  2683.   $limits{'max_index'} = 65000; # Max number of keys
  2684.   $limits{'max_index_parts'} = 8; # Max segments/key
  2685.   $limits{'max_column_name'} = 128; # max table and column name
  2686.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables
  2687.   $limits{'load_data_infile'} = 0; # Has load data infile
  2688.   $limits{'lock_tables'} = 0; # Has lock tables
  2689.   $limits{'functions'} = 1; # Has simple functions (+/-)
  2690.   $limits{'group_functions'} = 1; # Have group functions
  2691.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings
  2692.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)
  2693.   $limits{'select_without_from'}= 0; # Cannot do 'select 1';
  2694.   $limits{'multi_drop'} = 0; # Drop table cannot take many tables
  2695.   $limits{'subqueries'} = 1; # Supports sub-queries.
  2696.   $limits{'left_outer_join'} = 1; # Supports left outer joins
  2697.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  2698.   $limits{'having_with_alias'}  = 0; # Can use aliases in HAVING
  2699.   $limits{'having_with_group'} = 1; # Can use group functions in HAVING
  2700.   $limits{'like_with_column'} = 0; # Can use column1 LIKE column2
  2701.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1'
  2702.   $limits{'group_by_position'}  = 0; # Cannot use 'GROUP BY 1'
  2703.   $limits{'alter_table'} = 1; # Have ALTER TABLE
  2704.   $limits{'alter_add_multi_col'}= 1; # Have ALTER TABLE t add a int,add b int;
  2705.   $limits{'alter_table_dropcol'}= 1; # Have ALTER TABLE DROP column
  2706.   $limits{'insert_multi_value'} = 0; # Does not have INSERT ... values (1,2),(3,4)
  2707.   $limits{'group_func_extra_std'} = 0; # Does not have group function std().
  2708.   $limits{'func_odbc_mod'} = 0; # Have function mod.
  2709.   $limits{'func_extra_%'} = 0; # Does not have % as alias for mod()
  2710.   $limits{'func_odbc_floor'} = 0; # Has func_odbc_floor function
  2711.   $limits{'func_extra_if'} = 0; # Does not have function if.
  2712.   $limits{'column_alias'} = 1; # Alias for fields in select statement.
  2713.   $limits{'NEG'} = 0; # Supports -id
  2714.   $limits{'func_extra_in_num'} = 0; # Has function in
  2715.   $limits{'limit'} = 0; # Does not support the limit attribute
  2716.   $limits{'working_blobs'} = 1; # If big varchar/blobs works
  2717.   $limits{'order_by_unused'} = 1;
  2718.   $limits{'working_all_fields'} = 1;
  2719.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  2720.   return $self;
  2721. }
  2722. #
  2723. # Get the version number of the database
  2724. #
  2725. sub version
  2726. {
  2727.   my ($self)=@_;
  2728.   my ($dbh,$version);
  2729.   
  2730.   $version='Interbase ?';
  2731.   
  2732.   $dbh=$self->connect();
  2733.   eval { $version =   $dbh->func('version','ib_database_info')->{'version'}; }; 
  2734.   $dbh->disconnect;
  2735.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  2736.   return $version;
  2737. }
  2738. #
  2739. # Connection with optional disabling of logging
  2740. #
  2741. sub connect
  2742. {
  2743.   my ($self)=@_;
  2744.   my ($dbh);
  2745.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  2746.     $main::opt_password,{ PrintError => 0, AutoCommit => 1}) ||
  2747.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  2748.   return $dbh;
  2749. }
  2750. #
  2751. # Returns a list of statements to create a table
  2752. # The field types are in ANSI SQL format.
  2753. #
  2754. # If one uses $main::opt_fast then one is allowed to use
  2755. # non standard types to get better speed.
  2756. #
  2757. sub create
  2758. {
  2759.   my($self,$table_name,$fields,$index,$options) = @_;
  2760.   my($query,@queries,@keys,@indexes);
  2761.   $query="create table $table_name (";
  2762.   foreach $field (@$fields)
  2763.   {
  2764. #    $field =~ s/ big_decimal/ decimal/i;
  2765.     $field =~ s/ double/ double precision/i;
  2766.     $field =~ s/ tinyint/ smallint/i;
  2767.     $field =~ s/ mediumint/ integer/i;
  2768.     $field =~ s/bintb/integer/i;
  2769.     $field =~ s/ float(d,d)/ float/i;
  2770.     $field =~ s/ smallint(d)/ smallint/i;
  2771.     $field =~ s/ integer(d)/ integer/i;
  2772.     $query.= $field . ',';
  2773.   }
  2774.   foreach $ind (@$index)
  2775.   {
  2776.     if ( $ind =~ /(bKEYb)|(bUNIQUEb)/i ){
  2777.       push(@keys,"ALTER TABLE $table_name ADD $ind");
  2778.     }else{
  2779.       my @fields = split(' ',$ind);
  2780.       my $query="CREATE INDEX $fields[1] ON $table_name $fields[2]";
  2781.       push(@indexes,$query);
  2782.     }
  2783.   }
  2784.   substr($query,-1)=")"; # Remove last ',';
  2785.   $query.=" $options" if (defined($options));
  2786.   push(@queries,$query,@keys,@indexes);
  2787.   return @queries;
  2788. }
  2789. sub insert_file {
  2790.   my($self,$dbname, $file) = @_;
  2791.   print "insert of an ascii file isn't supported by InterBasen";
  2792.   return 0;
  2793. }
  2794. #
  2795. # Do any conversions to the ANSI SQL query so that the database can handle it
  2796. #
  2797. sub query {
  2798.   my($self,$sql) = @_;
  2799.   return $sql;
  2800. }
  2801. sub drop_index {
  2802.   my ($self,$table,$index) = @_;
  2803.   return "DROP INDEX $index";
  2804. }
  2805. #
  2806. # Abort if the server has crashed
  2807. # return: 0 if ok
  2808. #   1 question should be retried
  2809. #
  2810. sub abort_if_fatal_error
  2811. {
  2812.   return 1 if ($DBI::errstr =~ /Table locked by another cursor/);
  2813.   return 0;
  2814. }
  2815. sub small_rollback_segment
  2816. {
  2817.   return 1;
  2818. }
  2819. sub reconnect_on_errors
  2820. {
  2821.   return 1;
  2822. }
  2823. sub fix_for_insert
  2824. {
  2825.   my ($self,$cmd) = @_;
  2826.   return $cmd;
  2827. }
  2828. #############################################################################
  2829. #      Configuration for FrontBase 
  2830. #############################################################################
  2831. package db_FrontBase;
  2832. sub new
  2833. {
  2834.   my ($type,$host,$database)= @_;
  2835.   my $self= {};
  2836.   my %limits;
  2837.   bless $self;
  2838.   $self->{'cmp_name'} = "FrontBase";
  2839.   $self->{'data_source'} = "DBI:FB:dbname=$database;host=$host";
  2840.   $self->{'limits'} = %limits;
  2841.   $self->{'blob'} = "varchar(8000000)";
  2842.   $self->{'text'} = "varchar(8000000)";
  2843.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  2844.   $self->{'drop_attr'} = ' restrict';
  2845.   $self->{'transactions'} = 1; # Transactions enabled
  2846.   $self->{'error_on_execute_means_zero_rows'}=1;
  2847.   $limits{'max_conditions'} = 5427; # (Actually not a limit)
  2848.   # The following should be 8192, but is smaller because Frontbase crashes..
  2849.   $limits{'max_columns'} = 150; # Max number of columns in table
  2850.   $limits{'max_tables'} = 5000; # 10000 crashed FrontBase
  2851.   $limits{'max_text_size'} = 65000; # Max size with default buffers.
  2852.   $limits{'query_size'} = 8000000; # Max size with default buffers.
  2853.   $limits{'max_index'} = 38; # Max number of keys
  2854.   $limits{'max_index_parts'} = 20; # Max segments/key
  2855.   $limits{'max_column_name'} = 128; # max table and column name
  2856.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables
  2857.   $limits{'load_data_infile'} = 1; # Has load data infile
  2858.   $limits{'lock_tables'} = 0; # Has lock tables
  2859.   $limits{'functions'} = 1; # Has simple functions (+/-)
  2860.   $limits{'group_functions'} = 1; # Have group functions
  2861.   $limits{'group_distinct_functions'}= 0; # Have count(distinct)
  2862.   $limits{'select_without_from'}= 0;
  2863.   $limits{'multi_drop'} = 0; # Drop table cannot take many tables
  2864.   $limits{'subqueries'} = 1; # Supports sub-queries.
  2865.   $limits{'left_outer_join'} = 1; # Supports left outer joins
  2866.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  2867.   $limits{'having_with_alias'}  = 0; # Can use aliases in HAVING
  2868.   $limits{'having_with_group'} = 0; # Can use group functions in HAVING
  2869.   $limits{'like_with_column'} = 1; # Can use column1 LIKE column2
  2870.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1'
  2871.   $limits{'group_by_position'}  = 0; # Use of 'GROUP BY 1'
  2872.   $limits{'alter_table'} = 1; # Have ALTER TABLE
  2873.   $limits{'alter_add_multi_col'}= 0; # Have ALTER TABLE t add a int,add b int;
  2874.   $limits{'alter_table_dropcol'}= 0; # Have ALTER TABLE DROP column
  2875.   $limits{'insert_multi_value'} = 1;
  2876.   $limits{'group_func_extra_std'} = 0; # Does not have group function std().
  2877.   $limits{'func_odbc_mod'} = 0; # Have function mod.
  2878.   $limits{'func_extra_%'} = 0; # Does not have % as alias for mod()
  2879.   $limits{'func_odbc_floor'} = 0; # Has func_odbc_floor function
  2880.   $limits{'func_extra_if'} = 0; # Does not have function if.
  2881.   $limits{'column_alias'} = 1; # Alias for fields in select statement.
  2882.   $limits{'NEG'} = 1; # Supports -id
  2883.   $limits{'func_extra_in_num'} = 0; # Has function in
  2884.   $limits{'limit'} = 0; # Does not support the limit attribute
  2885.   $limits{'insert_select'} = 0;
  2886.   $limits{'order_by_unused'} = 0;
  2887.   # We don't get an error for duplicate row in 'test-insert'
  2888.   $limits{'unique_index'} = 0; # Unique index works or not
  2889.   # We can't use a blob as a normal string (we got a wierd error)
  2890.   $limits{'working_blobs'} = 0;
  2891.   # 'select min(region),max(region) from bench1' kills the server after a while
  2892.   $limits{'group_func_sql_min_str'} = 0;
  2893.   # If you do select f1,f2,f3...f200 from table, Frontbase dies.
  2894.   $limits{'working_all_fields'} = 0;
  2895.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  2896.   return $self;
  2897. }
  2898. #
  2899. # Get the version number of the database
  2900. #
  2901. sub version
  2902. {
  2903.   my ($self)=@_;
  2904.   my ($dbh,$sth,$version,@row);
  2905. #  $dbh=$self->connect();
  2906. #
  2907. #  Pick up SQLGetInfo option SQL_DBMS_VER (18)
  2908. #
  2909.   #$version = $dbh->func(18, GetInfo);
  2910.   $version="FrontBase 3.3";
  2911. #  $dbh->disconnect;
  2912.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  2913.   return $version;
  2914. }
  2915. #
  2916. # Connection with optional disabling of logging
  2917. #
  2918. sub connect
  2919. {
  2920.   my ($self)=@_;
  2921.   my ($dbh);
  2922.   $dbh=DBI->connect($self->{'data_source'}, 
  2923.     $main::opt_user,
  2924.     $main::opt_password,
  2925.     { PrintError => 0 , 
  2926.       'fb_host'=>$main::opt_host
  2927.     }) ||
  2928.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  2929.   $db->{AutoCommit}=1;
  2930.   # $dbh->do("SET OPTION LOG_OFF=1,UPDATE_LOG=0");
  2931.   return $dbh;
  2932. }
  2933. #
  2934. # Returns a list of statements to create a table
  2935. # The field types are in ANSI SQL format.
  2936. #
  2937. # If one uses $main::opt_fast then one is allowed to use
  2938. # non standard types to get better speed.
  2939. #
  2940. sub create
  2941. {
  2942.   my($self,$table_name,$fields,$index,$options) = @_;
  2943.   my($query,@queries,@indexes,@keys);
  2944.   $query="create table $table_name (";
  2945.   foreach $field (@$fields)
  2946.   {
  2947.     $field =~ s/ blob/ varchar(32000)/i;
  2948.     $field =~ s/ big_decimal/ float/i;
  2949.     $field =~ s/ double/ float/i;
  2950.     $field =~ s/ tinyint/ smallint/i;
  2951.     $field =~ s/ mediumint/ int/i;
  2952.     $field =~ s/ integer/ int/i;
  2953.     $field =~ s/ float(d,d)/ float/i;
  2954.     $field =~ s/ smallint(d)/ smallint/i;
  2955.     $field =~ s/ int(d)/ int/i;
  2956.     $query.= $field . ',';
  2957.   }
  2958.   foreach $ind (@$index)
  2959.   {
  2960. #    my @index;
  2961.     if ( $ind =~ /(bKEYb)|(bUNIQUEb)/i ){
  2962.       push(@keys,"ALTER TABLE $table_name ADD $ind");
  2963.     }else{
  2964.       my @fields = split(' ',$ind);
  2965.       my $query="CREATE INDEX $fields[1] ON $table_name $fields[2]";
  2966.       push(@indexes,$query);
  2967.     }
  2968.   }
  2969.   substr($query,-1)=")"; # Remove last ',';
  2970.   $query.=" $options" if (defined($options));
  2971.   push(@queries,$query,@keys,@indexes);
  2972.   return @queries;
  2973. }
  2974. sub insert_file {
  2975.   my($self,$dbname, $file) = @_;
  2976.   print "insert of an ascii file isn't supported by InterBasen";
  2977.   return 0;
  2978. }
  2979. #
  2980. # Do any conversions to the ANSI SQL query so that the database can handle it
  2981. #
  2982. sub query {
  2983.   my($self,$sql) = @_;
  2984.   return $sql;
  2985. }
  2986. sub drop_index {
  2987.   my ($self,$table,$index) = @_;
  2988.   return "DROP INDEX $index";
  2989. }
  2990. #
  2991. # Abort if the server has crashed
  2992. # return: 0 if ok
  2993. #   1 question should be retried
  2994. #
  2995. sub abort_if_fatal_error
  2996. {
  2997.   return 0 if ($DBI::errstr =~ /No raw data handle/);
  2998.   return 1;
  2999. }
  3000. sub small_rollback_segment
  3001. {
  3002.   return 0;
  3003. }
  3004. sub reconnect_on_errors
  3005. {
  3006.   return 1;
  3007. }
  3008. sub fix_for_insert
  3009. {
  3010.   my ($self,$cmd) = @_;
  3011.   return $cmd;
  3012. }
  3013. #############################################################################
  3014. #      Configuration for SAPDB 
  3015. #############################################################################
  3016. package db_sapdb;
  3017. sub new
  3018. {
  3019.   my ($type,$host,$database)= @_;
  3020.   my $self= {};
  3021.   my %limits;
  3022.   bless $self;
  3023.   $self->{'cmp_name'} = "sapdb";
  3024.   $self->{'data_source'} = "DBI:SAP_DB:$database";
  3025.   $self->{'limits'} = %limits;
  3026.   $self->{'blob'} = "LONG"; # *
  3027.   $self->{'text'} = "LONG"; # *
  3028.   $self->{'double_quotes'} = 1; # Can handle:  'Walker''s'
  3029.   $self->{'drop_attr'} = "";
  3030.   $self->{'transactions'} = 1; # Transactions enabled *
  3031.   $self->{'char_null'}          = "";
  3032.   $self->{'numeric_null'}       = "";
  3033.   $limits{'max_conditions'} = 9999; # (Actually not a limit) *
  3034.   $limits{'max_columns'} = 1023; # Max number of columns in table *
  3035.   $limits{'max_tables'} = 65000; # Should be big enough * unlimited actually
  3036.   $limits{'max_text_size'} = 15000; # Max size with default buffers. 
  3037.   $limits{'query_size'} = 64*1024; # Max size with default buffers. *64 kb by default. May be set by system variable 
  3038.   $limits{'max_index'} = 510; # Max number of keys *
  3039.   $limits{'max_index_parts'} = 16; # Max segments/key *
  3040.   $limits{'max_column_name'} = 32; # max table and column name * 
  3041.   $limits{'join_optimizer'} = 1; # Can optimize FROM tables *
  3042.   $limits{'load_data_infile'} = 0; # Has load data infile *
  3043.   $limits{'lock_tables'} = 1; # Has lock tables 
  3044.   $limits{'functions'} = 1; # Has simple functions (+/-) *
  3045.   $limits{'group_functions'} = 1; # Have group functions *
  3046.   $limits{'group_func_sql_min_str'} = 1; # Can execute MIN() and MAX() on strings *
  3047.   $limits{'group_distinct_functions'}= 1; # Have count(distinct)  *
  3048.   $limits{'select_without_from'}= 0; # Cannot do 'select 1';  *
  3049.   $limits{'multi_drop'} = 0; # Drop table cannot take many tables *
  3050.   $limits{'subqueries'} = 1; # Supports sub-queries. *
  3051.   $limits{'left_outer_join'} = 1; # Supports left outer joins *
  3052.   $limits{'table_wildcard'} = 1; # Has SELECT table_name.*
  3053.   $limits{'having_with_alias'}  = 0; # Can use aliases in HAVING *
  3054.   $limits{'having_with_group'} = 1; # Can use group functions in HAVING *
  3055.   $limits{'like_with_column'} = 1; # Can use column1 LIKE column2 *
  3056.   $limits{'order_by_position'}  = 1; # Can use 'ORDER BY 1' *
  3057.   $limits{'group_by_position'}  = 0; # Cannot use 'GROUP BY 1' *
  3058.   $limits{'alter_table'} = 1; # Have ALTER TABLE *
  3059.   $limits{'alter_add_multi_col'}= 1; # Have ALTER TABLE t add a int,add b int; *
  3060.   $limits{'alter_table_dropcol'}= 1; # Have ALTER TABLE DROP column  *
  3061.   $limits{'insert_multi_value'} = 0; # INSERT ... values (1,2),(3,4) *
  3062.   $limits{'group_func_extra_std'} = 0; # Does not have group function std().
  3063.   $limits{'func_odbc_mod'} = 0; # Have function mod. *
  3064.   $limits{'func_extra_%'} = 0; # Does not have % as alias for mod() *
  3065.   $limits{'func_odbc_floor'} = 1; # Has func_odbc_floor function *
  3066.   $limits{'func_extra_if'} = 0; # Does not have function if. *
  3067.   $limits{'column_alias'} = 1; # Alias for fields in select statement. *
  3068.   $limits{'NEG'} = 1; # Supports -id *
  3069.   $limits{'func_extra_in_num'} = 0; # Has function in *
  3070.   $limits{'limit'} = 0; # Does not support the limit attribute *
  3071.   $limits{'working_blobs'} = 1; # If big varchar/blobs works *
  3072.   $limits{'order_by_unused'} = 1; # 
  3073.   $limits{'working_all_fields'} = 1; #
  3074.   $limits{'multi_distinct'}     = 1; # allows select count(distinct a),count(distinct b).. 
  3075.   return $self;
  3076. }
  3077. #
  3078. # Get the version number of the database
  3079. #
  3080. sub version
  3081. {
  3082.   my ($self)=@_;
  3083.   my ($dbh,$sth,$version,@row);
  3084.   $dbh=$self->connect();
  3085.   $sth = $dbh->prepare("SELECT KERNEL FROM VERSIONS") or die $DBI::errstr;
  3086.   $version="SAP DB (unknown)";
  3087.   if ($sth->execute && (@row = $sth->fetchrow_array)
  3088.       && $row[0] =~ /([d.]+)/)
  3089.   {
  3090.     $version=$row[0];
  3091.     $version =~ s/KERNEL/SAP DB/i; 
  3092.   }
  3093.   $sth->finish;
  3094.   $dbh->disconnect;
  3095.   $version .= "/ODBC" if ($self->{'data_source'} =~ /:ODBC:/);
  3096.   return $version;
  3097. }
  3098. #
  3099. # Connection with optional disabling of logging
  3100. #
  3101. sub connect
  3102. {
  3103.   my ($self)=@_;
  3104.   my ($dbh);
  3105.   $dbh=DBI->connect($self->{'data_source'}, $main::opt_user,
  3106.     $main::opt_password,{ PrintError => 0, AutoCommit => 1}) ||
  3107.       die "Got error: '$DBI::errstr' when connecting to " . $self->{'data_source'} ." with user: '$main::opt_user' password: '$main::opt_password'n";
  3108.   return $dbh;
  3109. }
  3110. #
  3111. # Returns a list of statements to create a table
  3112. # The field types are in ANSI SQL format.
  3113. #
  3114. sub create
  3115. {
  3116.   my($self,$table_name,$fields,$index,$options) = @_;
  3117.   my($query,@queries,$nr);
  3118.   my @index;
  3119.   my @keys;
  3120.   $query="create table $table_name (";
  3121.   foreach $field (@$fields)
  3122.   {
  3123.     $field =~ s/bmediumintb/int/i;
  3124.     $field =~ s/btinyintb/int/i;
  3125.     $field =~ s/ int(d)/ int/i;
  3126.     $field =~ s/BLOB/LONG/i;
  3127.     $field =~ s/INTEGERs*(d+)/INTEGER/i;
  3128.     $field =~ s/SMALLINTs*(d+)/SMALLINT/i;
  3129.     $field =~ s/FLOATs*((d+),d+)/FLOAT($1)/i;
  3130.     $field =~ s/DOUBLE/FLOAT(38)/i;
  3131.     $field =~ s/DOUBLEs+PRECISION/FLOAT(38)/i;
  3132.     $query.= $field . ',';
  3133.   }
  3134.   $nr=0;
  3135.   foreach $ind (@$index)
  3136.   {
  3137.     if ( $ind =~ /bKEYb/i ){
  3138.       push(@keys,"ALTER TABLE $table_name ADD $ind");
  3139.     } elsif ($ind =~ /^unique.*(([^(]*))$/i)  {
  3140.       $nr++;
  3141.       my $query="create unique index ${table_name}_$nr on $table_name ($1)";
  3142.       push(@index,$query);
  3143.     }else{
  3144.       my @fields = split(' ',$ind);
  3145.       my $query="CREATE INDEX $fields[1] ON $table_name $fields[2]";
  3146.       push(@index,$query);
  3147.     }
  3148.   }
  3149.   substr($query,-1)=")"; # Remove last ',';
  3150.   $query.=" $options" if (defined($options));
  3151.   push(@queries,$query);
  3152.   push(@queries,@keys);
  3153.   push(@queries,@index);
  3154.   return @queries;
  3155. }
  3156. sub insert_file {
  3157.   my($self,$dbname, $file) = @_;
  3158.   print "insert of an ascii file isn't supported by SAPDBn";
  3159.   return 0;
  3160. }
  3161. #
  3162. # Do any conversions to the ANSI SQL query so that the database can handle it
  3163. #
  3164. sub query {
  3165.   my($self,$sql) = @_;
  3166.   return $sql;
  3167. }
  3168. sub drop_index {
  3169.   my ($self,$table,$index) = @_;
  3170.   return "DROP INDEX $index";
  3171. }
  3172. #
  3173. # Abort if the server has crashed
  3174. # return: 0 if ok
  3175. #   1 question should be retried
  3176. #
  3177. sub abort_if_fatal_error
  3178. {
  3179.   return 0;
  3180. }
  3181. sub small_rollback_segment
  3182. {
  3183.   return 0;
  3184. }
  3185. sub reconnect_on_errors
  3186. {
  3187.   return 0;
  3188. }
  3189. sub fix_for_insert
  3190. {
  3191.   my ($self,$cmd) = @_;
  3192.   return $cmd;
  3193. }
  3194. 1;