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;