File Coverage

blib/lib/DBIx/Sequence.pm

Criterion	Covered	Total	%
statement	7	9	77.7
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	10	12	83.3

package DBIx::Sequence;

use strict;
use vars qw($VERSION);
$VERSION = '1.5';

use DBI;
use Carp;

use constant COLUMN_PREFIX => '';
use constant DEFAULT_INIT_VALUE => 1;
use constant DEFAULT_ALLOW_ID_REUSE => 1;
use constant DEBUG_LEVEL => 0;
use constant DEFAULT_STATE_TABLE => 'dbix_sequence_state';
use constant DEFAULT_RELEASE_TABLE => 'dbix_sequence_release';

sub new
{
	my $class_name = shift;
	my $args = shift;

	my $self = {};
	$self = bless $self, $class_name;

	$self->{_dbh} = $args->{dbh} || $self->getDbh($args) || die 'Cannot get Database handle';

	$self->{state_table} = $args->{state_table};
	$self->{release_table} = $args->{release_table};
	$self->{_arg_reuse} = $args->{allow_id_reuse} if(exists $args->{allow_id_reuse});

	delete $self->{db_user};
	delete $self->{db_pw};
	delete $self->{db_dsn};

	$self->_InitQueries();


	return $self;
}

sub getDbh
{
	my $self = shift;
	my $args = shift;

	return DBI->connect($args->{db_dsn}, $args->{db_user}, $args->{db_pw}, {
								RaiseError => 0,
								PrintError => 0,
								AutoCommit => 1,
								Warn => 0, }) || croak __PACKAGE__.": $DBI::errstr";
}


sub Next
{
	my $self = shift;
	my $dataset = shift;

	croak "No dataset specified" if not defined $dataset;

	print STDERR "Request of Next() id\n" if $self->DEBUG_LEVEL();

	my $current_sth = $self->{_current_sth};
	my $init_sth = $self->{_init_sth};

	if($self->_Create_Dataset($dataset))
	{
		return $self->DEFAULT_INIT_VALUE();
	}

	if($self->_AllowedReuse())
	{
		my $released_ids_sth = $self->{_released_ids_sth};

		$released_ids_sth->execute($dataset);

		while(my $released_id = $released_ids_sth->fetchrow())
		{
			if($self->_release_race_for($dataset, ( $released_id =~ m/^(\d+)$/ )[0] ))
			{
				print STDERR "Returning released id $released_id\n" if $self->DEBUG_LEVEL();
				$released_ids_sth->finish;
				return $released_id;
			}
		}
	}

	my $unique_id = $self->_race_for($dataset);
	if(!$unique_id)
	{
		croak __PACKAGE__." was unable to generate a unique id for ".$dataset."\n";
	}

	print STDERR "Returning new unique id $unique_id\n" if $self->DEBUG_LEVEL();
	return $unique_id;
}

sub Currval
{
	my $self = shift;
	my $dataset = shift;

	croak "No dataset specified" if !$dataset;

	my $current_sth = $self->{_current_sth};
	$current_sth->execute($dataset) || croak __PACKAGE__.": $DBI::errstr";
	my ($c_dataset, $current_id) = $current_sth->fetchrow(); $current_sth->finish;

	print STDERR "Returning CURRVAL $current_id for $c_dataset\n";
	return $current_id;
}


sub Release
{
	my $self = shift;
	my $dataset = shift;
	my $release_id = shift;

	croak "No dataset specified" if !$dataset;
	croak __PACKAGE__." NO ID specified for Release()" if not defined $release_id;

	print STDERR "Asked to release id $release_id in dataset $dataset\n" if $self->DEBUG_LEVEL();


	if($self->_AllowedReuse())
	{
		my $release_id_sth = $self->{_release_id_sth};

		if($release_id_sth->execute($dataset, $release_id) ne 'OEO')
		{
			print STDERR "Release successful.\n" if $self->DEBUG_LEVEL();
			return 1;
		}
		return 0;
	}
	else
	{
		warn "Release() of ID not permitted by class ".__PACKAGE__;
	}
}


sub Delete_Dataset
{
	my $self = shift;
	my $dataset = shift;

	croak "No dataset specified" if !$dataset;


	my $delete_state_sth = $self->{_delete_state_sth};
	my $delete_release_sth = $self->{_delete_release_sth};

	print STDERR "Deleting dataset ".$dataset."\n" if $self->DEBUG_LEVEL();

	$delete_state_sth->execute($dataset) || croak __PACKAGE__.": $DBI::errstr";
	$delete_release_sth->execute($dataset) || croak __PACKAGE__.": $DBI::errstr";

	print STDERR "Deletion successul\n" if $self->DEBUG_LEVEL();

	return 1;
}

sub Bootstrap
{
	my $self = shift;
	my $dataset = shift;
	my $data_table = shift;
	my $data_field = shift;

	croak "No dataset specified" if !$dataset;
	croak "No data_table to Bootstrap()" if(!$data_table);
	croak "No data_field to Bootstrap()" if(!$data_field);


	print STDERR "Bootstrapping dataset ". $dataset." with $data_table and $data_field\n" if $self->DEBUG_LEVEL();

	my $bootstrap_query = "SELECT
					MAX($data_field)
				FROM
					".$data_table;

	print STDERR "\n\n", $bootstrap_query, "\n\n" if $self->DEBUG_LEVEL();

	my $bootstrap_sth = $self->{_dbh}->prepare($bootstrap_query) || croak __PACKAGE__.": $DBI::errstr";
	$bootstrap_sth->execute() || croak __PACKAGE__.": $DBI::errstr";

	my $bootstrap_id = $bootstrap_sth->fetchrow(); $bootstrap_sth->finish;

	croak "Bootstrap() failed" if(!$bootstrap_id);

	$self->_Create_Dataset($dataset);

	print STDERR "Bootstrap successfull.\n" if $self->DEBUG_LEVEL();

	my $next_id = $self->_race_for($dataset, $bootstrap_id + 1);

	print STDERR "Bootstrap next id is : $next_id\n" if $self->DEBUG_LEVEL();

	return $next_id;
}

sub _Create_Dataset
{
	my $self = shift;
	my $dataset = shift;

	croak "No dataset specified" if !$dataset;

	my $current_sth = $self->{_current_sth};
	my $init_sth = $self->{_init_sth};

        $current_sth->execute($dataset) || croak __PACKAGE__.": $DBI::errstr";
        my ($c_dataset, $current_id) = $current_sth->fetchrow(); $current_sth->finish;

        if(!$c_dataset)
        {
                $init_sth->execute($dataset,$self->DEFAULT_INIT_VALUE()) || croak __PACKAGE__.": $DBI::errstr";
                return $self->DEFAULT_INIT_VALUE();
        }
	else { return 0; }
}

sub STATE_TABLE
{
	my $self = shift;

	croak "Self not defined!" if not defined $self;

	return $self->{state_table} || $self->DEFAULT_STATE_TABLE();
}

sub RELEASE_TABLE
{
	my $self = shift;

	croak "Self not defined!" if not defined $self;

	return $self->{release_table} || $self->DEFAULT_RELEASE_TABLE();
}

sub _AllowedReuse
{
	my $self = shift;

	if(exists $self->{_arg_reuse})
	{
		return undef if($self->{_arg_reuse} =~ /no/i);
		return 1 if($self->{_arg_reuse});
		return undef;
	}
	else
	{
		return $self->DEFAULT_ALLOW_ID_REUSE();
	}
}

sub _race_for
{
	my $self = shift;
	my $dataset = shift;
	my $race_for_id = shift;

	croak "No dataset specified" if !$dataset;

	my $current_sth = $self->{_current_sth};
	my $race_sth = $self->{_race_sth};

	my $unique_id;
	my $got_id = 0;
	my $current_id;
	while($got_id == 0)
	{
		$current_sth->execute($dataset) || croak __PACKAGE__.": $DBI::errstr";
		$current_id = ($current_sth->fetchrow() =~ m/^(\d+)$/ )[0]; $current_sth->finish;

		if(!$race_for_id || $race_for_id <= $current_id)
		{
			$race_for_id = $current_id + 1;
		}

		if ($race_sth->execute(($race_for_id), $dataset, $current_id) ne '0E0')
                {
			$unique_id = $race_for_id;
                        $got_id = 1;
                }
	}

	return $unique_id;
}

sub _release_race_for
{
	my $self = shift;
	my $dataset = shift;
	my $release_id = shift;

	croak "No dataset specified" if !$dataset;
	croak "No ID specified for release race" if not defined $release_id;

	if($self->{_race_release_sth}->execute($dataset, $release_id) ne 'OEO')
	{
		return 1;
	}
	return 0;
}

sub _InitQueries
{
	my $self = shift;


	my $current_query = "SELECT
				".$self->COLUMN_PREFIX()."dataset,
				".$self->COLUMN_PREFIX()."state_id
				FROM
					".$self->STATE_TABLE()."
				WHERE
					".$self->COLUMN_PREFIX()."dataset = ?";

	print STDERR "\n\n", $current_query, "\n\n" if $self->DEBUG_LEVEL();

	$self->{_current_sth} = $self->{_dbh}->prepare_cached($current_query) || croak __PACKAGE__.": $DBI::errstr";

	my $init_query = "INSERT INTO
				".$self->STATE_TABLE()." (
								".$self->COLUMN_PREFIX()."dataset,
								".$self->COLUMN_PREFIX()."state_id
							) values (?,?)";

	print STDERR "\n\n", $init_query, "\n\n" if $self->DEBUG_LEVEL();

	$self->{_init_sth} = $self->{_dbh}->prepare_cached($init_query) || croak __PACKAGE__.": $DBI::errstr";


	my $race_query = "UPDATE
				".$self->STATE_TABLE()."
				SET
					".$self->COLUMN_PREFIX()."state_id  = ?
				WHERE
					".$self->COLUMN_PREFIX()."dataset = ?
				AND
					".$self->COLUMN_PREFIX()."state_id = ?";


	print STDERR "\n\n", $race_query, "\n\n" if $self->DEBUG_LEVEL();

	$self->{_race_sth} = $self->{_dbh}->prepare_cached($race_query) || croak __PACKAGE__.": $DBI::errstr";


	my $release_query = "DELETE FROM
					".$self->RELEASE_TABLE()."
				WHERE
					".$self->COLUMN_PREFIX()."dataset = ?
				AND
					".$self->COLUMN_PREFIX()."released_id = ?";


	print STDERR "\n\n", $release_query, "\n\n" if $self->DEBUG_LEVEL();

	$self->{_race_release_sth} = $self->{_dbh}->prepare_cached($release_query) || croak __PACKAGE__.": $DBI::errstr";


	my $released_ids_query = "SELECT
					".$self->COLUMN_PREFIX()."released_id
				FROM
					".$self->RELEASE_TABLE()."
				WHERE
					".$self->COLUMN_PREFIX()."dataset = ?";

	print STDERR "\n\n", $released_ids_query, "\n\n" if $self->DEBUG_LEVEL();

	$self->{_released_ids_sth} = $self->{_dbh}->prepare_cached($released_ids_query) || croak __PACKAGE__.": $DBI::errstr";



	my $release_id_query = "INSERT INTO
					".$self->RELEASE_TABLE()."
					(
					".$self->COLUMN_PREFIX()."dataset,
					".$self->COLUMN_PREFIX()."released_id
					) values (?,?)";

	print STDERR "\n\n", $release_id_query, "\n\n" if $self->DEBUG_LEVEL();

	$self->{_release_id_sth} = $self->{_dbh}->prepare_cached($release_id_query) || croak __PACKAGE__.": $DBI::errstr";


	my $delete_state_query = "DELETE FROM
						".$self->STATE_TABLE()."
					WHERE
						dataset = ?";

	print STDERR "\n\n", $delete_state_query, "\n\n" if $self->DEBUG_LEVEL();

	$self->{_delete_state_sth} = $self->{_dbh}->prepare_cached($delete_state_query) || croak __PACKAGE__.": $DBI::errstr";


	my $delete_release_query = "DELETE FROM
						".$self->RELEASE_TABLE()."
					WHERE
						dataset = ?";

	print STDERR "\n\n", $delete_release_query, "\n\n" if $self->DEBUG_LEVEL();

	$self->{_delete_release_sth} = $self->{_dbh}->prepare_cached($delete_release_query) || croak __PACKAGE__.": $DBI::errstr";


	return 1;
}

42;


__END__