Subversion Repositories DevTools

###############################################################################
# Codestriker: Copyright (c) 2001, 2002 David Sitsky.  All rights reserved.
# sits@users.sourceforge.net
#
# This program is free software; you can redistribute it and modify it under
# the terms of the GPL.

package Codestriker::DB::Database;

use strict;

use DBI;
use Codestriker;
use Codestriker::DB::Column;
use Codestriker::DB::Index;
use Codestriker::DB::PostgreSQL;
use Codestriker::DB::MySQL;
use Codestriker::DB::Oracle;
use Codestriker::DB::ODBC;
use Codestriker::DB::SQLite;

# Print out creation statements before executing them if this is true.
my $_DEBUG = 0;

# Base object for all database objects.
sub new {
    my $type = shift;
    my $self = {};
    return bless $self, $type;
}

# Factory object for retrieving a database object based on what is set
# in the configuration.
sub get_database {
    my $type = shift;

    if ($Codestriker::db =~ /^DBI:mysql/i) {
        return Codestriker::DB::MySQL->new();
    } elsif ($Codestriker::db =~ /^DBI:Pg/i) {
        return Codestriker::DB::PostgreSQL->new($Codestriker::db);
    } elsif ($Codestriker::db =~ /^DBI:Odbc/i) {
        return Codestriker::DB::ODBC->new();
    } elsif ($Codestriker::db =~ /^DBI:Oracle/i) {
        return Codestriker::DB::Oracle->new();
    } elsif ($Codestriker::db =~ /^DBI:SQLite/i) {
        return Codestriker::DB::SQLite->new();
    } else {
        die "Unsupported database type: $Codestriker::db\n";
    }
}

# Create a new database connection with the specified auto_commit and
# raise_error properties.  If an active connection is already associated
# with the database, return that.
sub _get_connection {
    my ($self, $auto_commit, $raise_error) = @_;

    # If a connection has already been created, return it.
    return $self->{dbh} if (exists $self->{dbh});

    $self->{dbh} = DBI->connect($Codestriker::db, $Codestriker::dbuser,
                                $Codestriker::dbpasswd,
                                {AutoCommit=>$auto_commit,
                                 RaiseError=>$raise_error,
                                 LongReadLen=>10240000});

    # Return the new connection.
    return $self->{dbh};
}

# Release the connection associated with the database, and either commit or
# rollback it depending on the value of $commit.
sub release_connection {
    my ($self) = @_;

    # Check there is an active connection.
    if (! defined $self->{dbh}) {
        die "Cannot release connection on database as no active connection\n";
    }

    # Disconnect the connection.
    $self->{dbh}->disconnect();
    $self->{dbh} = undef;
}

# Create the table in the database for the specified table, and with the
# provided type mappings.
sub create_table {
    my ($self, $table) = @_;

    # Create the initial table entry.
    my $stmt = "CREATE TABLE " . $table->get_name() . "(\n";
    
    # For each column, add the appropriate statement.
    my @pk = ();
    my $first_column = 1;
    foreach my $column (@{$table->get_columns()}) {
        push @pk, $column->get_name() if $column->is_primarykey();

        # Add the comma for the start of the next field if necessary.
        if ($first_column) {
            $first_column = 0;
        } else {
            $stmt .= ",\n";
        }

        # Add in the basic field definition.
        $stmt .= $column->get_name() . " " .
            $self->_map_type($column->get_type());

        # Check if the length constraint is required for a varchar expression.
        if ($column->get_type() == $Codestriker::DB::Column::TYPE->{VARCHAR}) {
            $stmt .= "(" . $column->get_length() . ")";
        }

        # Add the "NOT NULL" constraint if the column is mandatory.
        $stmt .= " NOT NULL" if $column->is_mandatory();

        # Add any autoincrement field decorations if required.
        if ($column->is_autoincrement()) {
            $stmt .= " " . $self->_get_autoincrement_type();
        }
    }

    # Now add in the primary definition if required.
    if (scalar(@pk) > 0) {
        $stmt .= ",\nPRIMARY KEY (" . (join ', ', @pk) . ")\n";
    }

    # Close off the statement.
    $stmt .= ")\n";

    print STDERR "Statement is: $stmt\n" if $_DEBUG;

    eval {
        # Now create the table.
        $self->{dbh}->do($stmt);

        # Now create the indexes for this table.
        foreach my $index (@{$table->get_indexes()}) {
            my $index_stmt = "CREATE INDEX " . $index->get_name . " ON " .
                $table->get_name() . "(";
            $index_stmt .= (join ', ', @{$index->get_column_names()}) . ")";
            
            print STDERR "Index statement is: $index_stmt\n" if $_DEBUG;
            
            # Now execute the statement to create the index.
            $self->{dbh}->do($index_stmt);
        }

        # Commit the table creation.
        $self->commit();
    };
    if ($@) {
        eval { $self->rollback() };
        die "Unable to create table/indexes.\n";
    }
}

# Method for retrieving the list of current tables attached to the database.
# For most DBI implementations, this implementation works fine.
sub get_tables() {
    my $self = shift;

    # Remove any tables that end in a period, or have backticks.  Recent
    # versions of MySQL are now using backticks around the table name.
    my @tables = $self->{dbh}->tables;
    @tables = map { $_ =~ s/.*\.//; $_ } @tables;
    @tables = map { $_ =~ s/\`//g; $_ } @tables;
    
    return @tables;
}

# Add a field to a specific table.  If the field already exists, then catch
# the error and continue silently.
sub add_field {
    my ($self, $table, $field, $definition) = @_;

    my $dbh = $self->{dbh};
    my $rc = 0;

    eval {
        $dbh->{PrintError} = 0;
        my $field_type = $self->_map_type($definition);

        $dbh->do("ALTER TABLE $table ADD COLUMN $field $field_type");
        print "Added new field $field to table $table.\n";
        $rc = 1;
        $self->commit();
    };
    if ($@) {
        eval { $self->rollback() };
    }
    
    $dbh->{PrintError} = 1;

    return $rc;
}

# Check if the specified column exists in the specified table.
sub column_exists {
    my ($self, $tablename, $columnname) = @_;

    my $dbh = $self->{dbh};
    my $rc = 0;

    eval {
        $dbh->{PrintError} = 0;

        my $stmt = $dbh->prepare_cached("SELECT COUNT($columnname) " .
                                        "FROM $tablename");
        $rc = defined $stmt && $stmt->execute() ? 1 : 0;
        $stmt->finish();
        $self->commit();
    };
    if ($@) {
        eval { $self->rollback() };
    }

    $dbh->{PrintError} = 1;

    return $rc;
}

# Method for moving a database table to another name in a safe manner.
sub move_table {
    my ($self, $old_tablename, $new_tablename) = @_;

    my $dbh = $self->{dbh};
    my $rc = 0;

    eval {
        $dbh->{PrintError} = 0;

        my $stmt =
            $dbh->prepare_cached("ALTER TABLE $old_tablename RENAME TO " .
                                 "$new_tablename");
        my $rc = defined $stmt && $stmt->execute() ? 1 : 0;
        $stmt->finish() if (defined $stmt);
        $self->commit();
    };
    if ($@) {
        eval { $self->rollback() };
    }

    $dbh->{PrintError} = 1;

    return $rc;
}    

# Simple method for committing the current database transaction.
sub commit {
    my ($self) = @_;
    $self->{dbh}->commit();
}

# Simple method for rolling back the current database transaction.
sub rollback {
    my ($self) = @_;
    $self->{dbh}->rollback();
}

1;