开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
server-cfg.sh
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：95k
源码类别：

MySQL数据库

开发平台：

Visual C++

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