File Coverage

blib/lib/DBD/cubrid.pm

Criterion	Covered	Total	%
statement	68	242	28.1
branch	13	142	9.1
condition	1	75	1.3
subroutine	11	20	55.0
pod	0	1	0.0
total	93	480	19.3

# cubrid.pm
#
# Copyright (C) 2008 Search Solution Corporation. All rights reserved by Search Solution.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# - Redistributions of source code must retain the above copyright notice,
#   this list of conditions and the following disclaimer.
#
# - Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
#
# - Neither the name of the  nor the names of its contributors
#   may be used to endorse or promote products derived from this software without
#   specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
# OF SUCH DAMAGE.
#

use 5.008;
use warnings;
use strict;

{   package DBD::cubrid;

    use DBI ();
    use DynaLoader ();
    use vars qw(@ISA $VERSION $err $errstr $sqlstate $drh $dbh);
    @ISA = qw(DynaLoader);

    require_version DBI 1.61;

    $VERSION = '9.3.0.0001';

    bootstrap DBD::cubrid $VERSION;

    $drh = undef;   # holds driver handle once initialized
    $err = 0;       # holds error code for DBI::err
    $errstr = '';   # holds error string for DBI::errstr
    $sqlstate = ''; # holds five character SQLSTATE code

    sub driver {
        return $drh if $drh;

        my($class, $attr) = @_;

        $class .= "::dr";

        $drh = DBI::_new_drh ($class, {
                'Name' => 'cubrid',
                'Version' => $VERSION,
                'Err'    => \$DBD::cubrid::err,
                'Errstr' => \$DBD::cubrid::errstr,
                'Attribution' => 'DBD::cubrid by Zhang Hui'
            });

        DBD::cubrid::st->install_method ('cubrid_lob_get');
        DBD::cubrid::st->install_method ('cubrid_lob_export');
        DBD::cubrid::st->install_method ('cubrid_lob_import');
        DBD::cubrid::st->install_method ('cubrid_lob_close');

        $drh
    }
}

{   package DBD::cubrid::dr; # ====== DRIVER ======
    use strict;

    sub connect {

        my ($drh, $dsn, $user, $passwd, $attrhash) = @_;
        my %connect_attr;

        if ($dsn =~ /=/) {
            my ($n,$v);
            $dsn =~ s/^\s+//;
            $dsn =~ s/\s+$//;
            $dsn =~ s/^DBI:cubrid://;
            $dsn =~ s/^dbi:cubrid://;
            my @dsn = map {
                ($n,$v) = split /\s*=\s*/, $_, -1;
                Carp::carp("DSN component '$_' is not in 'name=value' format")
                    unless defined $v && defined $n;
                (uc($n), $v)
            } split /\s*;\s*/, $dsn;
            my %dsn = @dsn;
            foreach (%dsn) {
                $connect_attr{$_} = $dsn{$_};
            }
        }
        else {
            Carp::carp("DSN $dsn is not in 'name=value' format");
        }

        $user = 'public' if not defined $user;

        my ($host, $port, $dbname);

        if ($connect_attr{HOST}) {
            $host = $connect_attr{HOST};
        } else {
            $host = 'localhost';
        }

        if ($connect_attr{PORT}) {
            $port = $connect_attr{PORT};
        } else {
            $port = 33000;
        }

        if ($connect_attr{DATABASE}) {
            $dbname = $connect_attr{DATABASE};
        } else {
            $dbname = '';
        }

        my $connect_dsn = "cci:cubrid:$host:$port:$dbname" . ':::';
        my $is_connect_attr = 0;

        if ($connect_attr{ALTHOSTS}) {
            $connect_dsn .= "?alhosts=$connect_attr{ALTHOSTS}";
            $is_connect_attr = 1;
        }

        if ($connect_attr{RCTIME}) {
            if ($is_connect_attr) {
                $connect_dsn .= "&rctime=$connect_attr{RCTIME}";
            } else {
                $connect_dsn .= "?rctime=$connect_attr{RCTIME}";
                $is_connect_attr = 1;
            }
        }

        if ($connect_attr{LOGIN_TIMEOUT}) {
            if ($is_connect_attr) {
                $connect_dsn .= "&login_timeout=$connect_attr{LOGIN_TIMEOUT}";
            } else {
                $connect_dsn .= "?login_timeout=$connect_attr{LOGIN_TIMEOUT}";
                $is_connect_attr = 1;
            }
        }

        if ($connect_attr{QUERY_TIMEOUT}) {
            if ($is_connect_attr) {
                $connect_dsn .= "&query_timeout=$connect_attr{QUERY_TIMEOUT}";
            } else {
                $connect_dsn .= "?query_timeout=$connect_attr{QUERY_TIMEOUT}";
                $is_connect_attr = 1;
            }
        }

        if ($connect_attr{DISCONNECT_ON_QUERY_TIMEOUT}) {
            if ($is_connect_attr) {
                $connect_dsn .= "&disconnect_on_query_timeout=$connect_attr{DISCONNECT_ON_QUERY_TIMEOUT}";
            } else {
                $connect_dsn .= "?disconnect_on_query_timeout=$connect_attr{DISCONNECT_ON_QUERY_TIMEOUT}";
                $is_connect_attr = 1;
            }
        }

        my ($dbh) = DBI::_new_dbh ($drh, {
                'Name' => $dbname,
                'User' => $user,
            });

        DBD::cubrid::db::_login($dbh, $connect_dsn, $user, $passwd, $attrhash) or return undef;

        $dbh
    }

} # end the package of DBD::cubrid::dr


{   package DBD::cubrid::db; # ====== DATABASE ======
    use strict;
    use DBI qw(:sql_types);

    sub prepare {

        my ($dbh, $statement, @attribs) = @_;

        return undef if ! defined $statement;

        my $sth = DBI::_new_sth ($dbh, {
                'Statement' => $statement,
            });

        DBD::cubrid::st::_prepare($sth, $statement, @attribs) or return undef;

        $sth
    }

    sub ping {
        my $dbh = shift;
        local $SIG{__WARN__} = sub { } if $dbh->FETCH('PrintError');
        my $ret = DBD::cubrid::db::_ping($dbh);
        return $ret ? 1 : 0;
    }

    sub get_info {
        my ($dbh, $info_type) = @_;
        require DBD::cubrid::GetInfo;
        my $v = $DBD::cubrid::GetInfo::info{int($info_type)};
        $v = $v->($dbh) if ref $v eq 'CODE';
        return $v;
    }

    sub table_info {
        my ($dbh, $catalog, $schema, $table, $type, $attr) = @_;

        my @names = qw(TABLE_CAT TABLE_SCHEM TABLE_NAME TABLE_TYPE REMARKS);
        my @rows;

        my $sponge = DBI->connect("DBI:Sponge:", '','')
            or return $dbh->DBI::set_err($DBI::err, "DBI::Sponge: $DBI::errstr");

        if ((defined $catalog && $catalog eq "%") &&
             (!defined($schema) || $schema eq "") &&
             (!defined($table) || $table eq ""))
        {
            @rows = (); # Empty, because CUBRID doesn't support catalogs (yet)
        }
        elsif ((defined $schema && $schema eq "%") &&
                (!defined($catalog) || $catalog eq "") &&
                (!defined($table) || $table eq ""))
        {
            @rows = (); # Empty, because CUBRID doesn't support schemas (yet)
        }
        elsif ((defined $type && $type eq "%") &&
                (!defined($catalog) || $catalog eq "") &&
                (!defined($schema) || $schema eq "") &&
                (!defined($table) || $table eq ""))
        {
            @rows = (
                [ undef, undef, undef, "TABLE", undef ],
                [ undef, undef, undef, "VIEW",  undef ],
            );
        }
        else
        {
	    $table = '%' unless defined $table;

            my ($want_tables, $want_views);
            if (defined $type && $type ne "") {
                if (($type =~ m/^table$/i) || ($type =~ m/^view$/i) || ($type =~ /^'table','view'$/i)) {
                    $want_tables = ($type =~ m/table/i);
                    $want_views  = ($type =~ m/view/i);
                }
                else {
                    Carp::carp ("\$type must be TABLE, VIEW or 'TABELE','VIEW'");
                }
            }
            else {
                $want_tables = $want_views = 1;
            }

            my $sql = "SELECT class_name, class_type FROM db_class where class_name like " . $dbh->quote($table);
            my $sth = $dbh->prepare ($sql) or return undef;
            $sth->execute or return DBI::set_err($dbh, $sth->err(), $sth->errstr());

            while (my $ref = $sth->fetchrow_arrayref()) {
                my $type = (defined $ref->[1] &&
                    $ref->[1] =~ /VCLASS/i) ? 'VIEW' : 'TABLE';
                next if $type eq 'TABLE' && not $want_tables;
                next if $type eq 'VIEW'  && not $want_views;
                push @rows, [ undef, undef, $ref->[0], $type, undef ];
            }
        }

        my $sth = $sponge->prepare("table_info",
            {
                rows          => \@rows,
                NUM_OF_FIELDS => scalar @names,
                NAME          => \@names,
            }
        ) or return $dbh->DBI::set_err($sponge->err(), $sponge->errstr());

        return $sth;
    }

    sub column_info {
        my $dbh = shift;
        my ($catalog, $schema, $table, $column) = @_;

        # ODBC allows a NULL to mean all columns, so we'll accept undef
        $column = '%' unless defined $column;

        my $table_id = $dbh->quote_identifier($table);

        my @names = qw(
            TABLE_CAT TABLE_SCHEM TABLE_NAME COLUMN_NAME DATA_TYPE TYPE_NAME COLUMN_SIZE
            BUFFER_LENGTH DECIMAL_DIGITS NUM_PREC_RADIX NULLABLE REMARKS COLUMN_DEF
            SQL_DATA_TYPE SQL_DATETIME_SUB CHAR_OCTET_LENGTH ORDINAL_POSITION IS_NULLABLE
            CHAR_SET_CAT CHAR_SET_SCHEM CHAR_SET_NAME COLLATION_CAT COLLATION_SCHEM
            COLLATION_NAME UDT_CAT UDT_SCHEM UDT_NAME DOMAIN_CAT DOMAIN_SCHEM DOMAIN_NAME
            SCOPE_CAT SCOPE_SCHEM SCOPE_NAME MAX_CARDINALITY DTD_IDENTIFIER IS_SELF_REF
        );

        my @col_info;

        local $dbh->{FetchHashKeyName} = 'NAME_lc';
        my $desc_sth = $dbh->prepare("SHOW COLUMNS FROM $table_id LIKE " . $dbh->quote($column));
        my $desc = $dbh->selectall_arrayref($desc_sth, { Columns=>{} });

        my $ordinal_pos = 0;
        for my $row (@$desc) {

            my $type = $row->{type};
            if (!defined($type)) {
                $type = "NULL";
            }

            my $info = {
                TABLE_CAT               => $catalog,
                TABLE_SCHEM             => $schema,
                TABLE_NAME              => $table,
                COLUMN_NAME             => $row->{field},
                NULLABLE                => ($row->{null} eq 'YES') ? 1 : 0,
                IS_NULLABLE             => ($row->{null} eq 'YES') ? "YES" : "NO",
                TYPE_NAME               => uc($type),
                COLUMN_DEF              => $row->{default},
                ORDINAL_POSITION        => ++$ordinal_pos,
            };

            if ($type =~ /CHAR/) {
                $info->{DATA_TYPE} = SQL_VARCHAR;
                $info->{DATA_TYPE} = SQL_CHAR if $type =~ /^CHAR/;

                if ($type =~ /\(/) {
                    my @tmp = split /\(/, $type;
                    my @tmp1 = split /\)/, $tmp[1];
                    $info->{COLUMN_SIZE} = $tmp1[0];
                }
                else {
                    $info->{COLUMN_SIZE} = 1073741823;
                }
            }
            elsif ($type =~ /STRING/) {
                $info->{DATA_TYPE} = SQL_VARCHAR;

                if ($type =~ /\(/) {
                    my @tmp = split /\(/, $type;
                    my @tmp1 = split /\)/, $tmp[1];
                    $info->{COLUMN_SIZE} = $tmp1[0];
                }
                else {
                    $info->{COLUMN_SIZE} = 1073741823;
                }
            }
            elsif ($type =~ /INT/) {
                $info->{NUM_PREC_RADIX} = 10;
                if ($type =~ /BIGINT/) {
                    $info->{DATA_TYPE} = SQL_BIGINT;
                    $info->{COLUMN_SIZE} = 19;
                }
                elsif ($type =~ /SMALLINT/) {
                    $info->{DATA_TYPE} = SQL_SMALLINT;
                    $info->{COLUMN_SIZE} = 5;
                }
                else {
                    $info->{DATA_TYPE} = SQL_INTEGER;
                    $info->{COLUMN_SIZE} = 10;
                }
            }
            elsif ($type =~ /SHORT/) {
                $info->{DATA_TYPE} = SQL_SMALLINT;
                $info->{COLUMN_SIZE} = 5;
                $info->{NUM_PREC_RADIX} = 10;
            }
            elsif ($type =~ /NUMERIC/) {
                $info->{DATA_TYPE} = SQL_NUMERIC;
                $info->{COLUMN_SIZE} = 38;
                if ($type =~ /\(/) {
                    my @tmp = split /\(/, $type;
                    my @tmp1 = split /\)/, $tmp[1];
                    my @tmp2 = split /,/, $tmp1[0];
                    $info->{DECIMAL_DIGITS} = $tmp2[1];
                    $info->{NUM_PREC_RADIX} = $tmp2[0];
                }
                else {
                    $info->{DECIMAL_DIGITS} = 15;
                    $info->{NUM_PREC_RADIX} = 10;
                }
            }
            elsif ($type =~ /MONETARY/) {
                $info->{DATA_TYPE} = SQL_FLOAT;
                $info->{COLUMN_SIZE} = 14;
                $info->{DECIMAL_DIGITS} = 2;
            }
            elsif ($type =~ /BLOB/) {
                $info->{DATA_TYPE} = SQL_BLOB;
                $info->{COLUMN_SIZE} = 0;
            }
            elsif ($type =~ /CLOB/) {
                $info->{DATA_TYPE} = SQL_CLOB;
                $info->{COLUMN_SIZE} = 0;
            }
            elsif ($type =~ /FLOAT/) {
                $info->{DATA_TYPE} = SQL_FLOAT;
                $info->{COLUMN_SIZE} = 14;
                $info->{NUM_PREC_RADIX} = 10;
            }
            elsif ($type=~ /DOUBLE/) {
                $info->{DATA_TYPE} = SQL_DOUBLE;
                $info->{COLUMN_SIZE} = 28;
                $info->{NUM_PREC_RADIX} = 10;
            }
            elsif ($type =~ /TIME/) {
                if ($type =~ /TIMESTAMP|DATETIME/) {
                    $info->{DATA_TYPE} = SQL_TYPE_TIMESTAMP;
                    $info->{COLUMN_SIZE} = 19 if $type =~ /^TIMESTAMP/;
                    $info->{COLUMN_SIZE} = 23 if $type =~ /^DATETIME/;
                }
                else {
                    $info->{DATA_TYPE} = SQL_TYPE_TIME;
                    $info->{COLUMN_SIZE} = 8;
                }
            }
            elsif ($type =~ /DATE/) {
                if ($type =~ /DATETIME/) {
                    $info->{DATA_TYPE} = SQL_TYPE_TIMESTAMP;
                    $info->{COLUMN_SIZE} = 23;
                }
                else {
                    $info->{DATA_TYPE} = SQL_TYPE_DATE;
                    $info->{COLUMN_SIZE} = 10;
                }
            }
            elsif ($type =~ /BIT/) {
                if ($type =~ /VARYING/) {
                    $info->{DATA_TYPE} = SQL_VARBINARY;
                }
                else {
                    $info->{DATA_TYPE} = SQL_BINARY;
                }

                if ($type =~ /\(/) {
                    my @tmp = split /\(/, $type;
                    my @tmp1 = split /\)/, $tmp[1];
                    $info->{COLUMN_SIZE} = $tmp1[0];
                }
                else {
                    $info->{COLUMN_SIZE} = 1073741823;
                }
            }
            elsif ($type =~ /^NULL$/) {
                $info->{DATA_TYPE} = SQL_UNKNOWN_TYPE;
            }
            else {
                $info->{DATA_TYPE} = SQL_VARCHAR;
            }

            $info->{SQL_DATA_TYPE} ||= $info->{DATA_TYPE};

            push @col_info, [
                $info->{TABLE_CAT},
                $info->{TABLE_SCHEM},
                $info->{TABLE_NAME},
                $info->{COLUMN_NAME},
                $info->{DATA_TYPE},
                $info->{TYPE_NAME},
                $info->{COLUMN_SIZE},
                $info->{BUFFER_LENGTH},
                $info->{DECIMAL_DIGITS},
                $info->{NUM_PREC_RADIX},
                $info->{NULLABLE},
                $info->{REMARKS},
                $info->{COLUMN_DEF},
                $info->{SQL_DATA_TYPE},
                $info->{SQL_DATETIME_SUB},
                $info->{CHAR_OCTET_LENGTH},
                $info->{ORDINAL_POSITION},
                $info->{IS_NULLABLE},
                $info->{CHAR_SET_CAT},
                $info->{CHAR_SET_SCHEM},
                $info->{CHAR_SET_NAME},
                $info->{COLLATION_CAT},
                $info->{COLLATION_SCHEM},
                $info->{COLLATION_NAME},
                $info->{UDT_CAT},
                $info->{UDT_SCHEM},
                $info->{UDT_NAME},
                $info->{DOMAIN_CAT},
                $info->{DOMAIN_SCHEM},
                $info->{DOMAIN_NAME},
                $info->{SCOPE_CAT},
                $info->{SCOPE_SCHEM},
                $info->{SCOPE_NAME},
                $info->{MAX_CARDINALITY},
                $info->{DTD_IDENTIFIER},
                $info->{IS_SELF_REF}
            ];
        }

        my $sponge = DBI->connect("DBI:Sponge:", '','')
            or return $dbh->DBI::set_err($DBI::err, "DBI::Sponge: $DBI::errstr");

        my $sth = $sponge->prepare("column_info $table_id", {
                rows          => \@col_info,
                NUM_OF_FIELDS => scalar @names,
                NAME          => \@names,
            }) or return $dbh->DBI::set_err($sponge->err(), $sponge->errstr());

        return $sth;
    }

    sub primary_key_info {
        my ($dbh, $catalog, $schema, $table) = @_;

        my @names = qw(
            TABLE_CAT TABLE_SCHEM TABLE_NAME COLUMN_NAME KEY_SEQ PK_NAME
        );

        my @col_info;

        my $desc = DBD::cubrid::db::_primary_key_info ($dbh, $table);
        for my $row (@$desc) {
            push @col_info, [
                $catalog,
                $schema,
                $row->[0],
                $row->[1],
                $row->[2],
                $row->[3],
            ];
        }

        my $sponge = DBI->connect ("DBI:Sponge:", '','')
            or return $dbh->DBI::set_err ($DBI::err, "DBI::Sponge: $DBI::errstr");
        my $sth= $sponge->prepare ("primary_key_info $table", {
                rows          => \@col_info,
                NUM_OF_FIELDS => scalar @names,
                NAME          => \@names,
            }) or return $dbh->DBI::set_err($sponge->err(), $sponge->errstr());

        return $sth;
    }

    sub foreign_key_info {
        my ($dbh,
            $pk_catalog, $pk_schema, $pk_table,
            $fk_catalog, $fk_schema, $fk_table,
        ) = @_;

        my @names = qw(
            PKTABLE_CAT PKTABLE_SCHEM PKTABLE_NAME PKCOLUMN_NAME
            FKTABLE_CAT FKTABLE_SCHEM FKTABLE_NAME FKCOLUMN_NAME
            KEY_SEQ  UPDATE_RULE DELETE_RULE FK_NAME PK_NAME DEFERRABILITY
        );

        my @col_info;

        my $desc = DBD::cubrid::db::_foreign_key_info ($dbh, $pk_table, $fk_table);
        for my $row (@$desc) {
            push @col_info, [
                $pk_catalog,
                $pk_schema,
                $row->[0],
                $row->[1],
                $fk_catalog,
                $fk_schema,
                $row->[2],
                $row->[3],
                $row->[4],
                $row->[5],
                $row->[6],
                $row->[7],
                $row->[8],
                undef
            ];
        }

        my $sponge = DBI->connect ("DBI:Sponge:", '','')
            or return $dbh->DBI::set_err ($DBI::err, "DBI::Sponge: $DBI::errstr");
        my $sth= $sponge->prepare ("foreign_key_info", {
                rows          => \@col_info,
                NUM_OF_FIELDS => scalar @names,
                NAME          => \@names,
            }) or return $dbh->DBI::set_err($sponge->err(), $sponge->errstr());

        return $sth;
    }

    sub type_info_all {
        my ($dbh) = @_;

        my $type_info_all = [
            {
                TYPE_NAME           => 0,
                DATA_TYPE           => 1,
                COLUMN_SIZE         => 2,
                LITERAL_PREFIX      => 3,
                LITERAL_SUFFIX      => 4,
                CREATE_PARAMS       => 5,
                NULLABLE            => 6,
                CASE_SENSITIVE      => 7,
                SEARCHABLE          => 8,
                UNSIGNED_ATTRIBUTE  => 9,
                FIXED_PREC_SCALE    => 10,
                AUTO_UNIQUE_VALUE   => 11,
                LOCAL_TYPE_NAME     => 12,
                MINIMUM_SCALE       => 13,
                MAXIMUM_SCALE       => 14,
                SQL_DATA_TYPE       => 15,
                SQL_DATETIME_SUB    => 16,
                NUM_PREC_RADIX      => 17,
                INTERVAL_PRECISION  => 18,
            },
["CHAR", SQL_CHAR, 1073741823, q{'}, q{'}, "length",
    1, 0, 3, -1, 0, 0, "CHAR", -1, -1, SQL_CHAR, -1, -1, -1],
["VARCHAR", SQL_VARCHAR, 1073741823, q{'}, q{'}, "length",
    1, 0, 3, -1, 0, 0, "CHAR VARYING", -1, -1, SQL_VARCHAR, -1, -1, -1],
["BIT", SQL_BINARY, 1073741823 / 8, q{X'}, q{'}, "length",
    1, 0, 3, -1, 0, 0, "BIT", -1, -1, SQL_BINARY, -1, -1, -1],
["BIT VARYING", SQL_VARBINARY, 1073741823 / 8, q{X'}, q{'}, "length",
    1, 0, 3, -1, 0, 0, "BIT VARYING", -1, -1, SQL_VARBINARY, -1, -1, -1],
["NUMERIC", SQL_NUMERIC, 38, undef, undef, "precision, scale",
    1, 0, 2, 0, 0, 0, "NUMERIC", 0, 38, SQL_NUMERIC, -1, 10, -1],
["DECIMAL", SQL_DECIMAL, 38, undef, undef, "precision, scale",
    1, 0, 2, 0, 0, 0, "DECIMAL", 0, 38, SQL_DECIMAL, -1, 10, -1],
["INTEGER", SQL_INTEGER, 10, undef, undef, undef,
    1, 0, 2, 0, 0, 0, "INTEGER", -1, -1, SQL_INTEGER, -1, 10, -1],
["SMALLINT", SQL_SMALLINT, 5, undef, undef, undef,
    1, 0, 2, 0, 0, 0, "SMALLINT", -1, -1, SQL_SMALLINT, -1, 10, -1],
["REAL", SQL_REAL, 14, undef, undef, "precision",
    1, 0, 2, 0, 0, 0, "REAL", -1, -1, SQL_REAL, -1, 10, -1],
["FLOAT", SQL_FLOAT, 14, undef, undef, "precision",
    1, 0, 2, 0, 0, 0, "FLOAT", -1, -1, SQL_FLOAT, -1, 10, -1],
["DOUBLE", SQL_DOUBLE, 28, undef, undef, "precision",
    1, 0, 2, 0, 0, 0, "DOUBLE", -1, -1, SQL_DOUBLE, -1, 10, -1],
["DATE", SQL_TYPE_DATE, 10, q{DATE '}, q{'}, undef,
    1, 0, 2, 0, 0, 0, "DATE", -1, -1, SQL_DATETIME, 1, -1, -1],
["TIME", SQL_TYPE_TIME, 8, q{TIME '}, q{'}, undef,
    1, 0, 2, 0, 0, 0, "TIME", -1, -1, SQL_DATETIME, 2, -1, -1],
["TIMESTAMP", SQL_TYPE_TIMESTAMP, 19, q{TIMESTAMP '}, q{'}, undef,
    1, 0, 2, 0, 0, 0, "TIMESTAMP", -1, -1, SQL_DATETIME, 3, -1, -1],
["BIGINT", SQL_BIGINT, 19, undef, undef, undef,
    1, 0, 2, 0, 0, 0, "BIGINT", -1, -1, SQL_INTEGER, -1, 10, -1],
["DATETIME", SQL_TYPE_TIMESTAMP, 23, q{DATETIME '}, q{'}, undef,
    1, 0, 2, 0, 0, 0, "DATETIME", -1, -1, SQL_DATETIME, 3, -1, -1],
["ENUM", SQL_VARCHAR, 0, undef, undef, undef,
    1, 0, 3, 0, 0, 0, "ENUM", -1, -1, SQL_VARCHAR, -1, -1, -1],
["BLOB", SQL_BLOB, 0, undef, undef, undef,
    1, 0, 3, 0, 0, 0, "BLOB", -1, -1, SQL_BLOB, -1, -1, -1],
["CLOB", SQL_CLOB, 0, undef, undef, undef,
    1, 0, 3, 0, 0, 0, "CLOB", -1, -1, SQL_CLOB, -1, -1, -1],
        ];

        return $type_info_all;
    }

}   # end of package DBD::cubrid::db


{   package DBD::cubrid::st; # ====== STATEMENT ======


}

1;

__END__