package DBIx::Class::Storage::DBI::Replicated;
-
+
BEGIN {
use Carp::Clan qw/^DBIx::Class/;
use DBIx::Class;
unless DBIx::Class::Optional::Dependencies->req_ok_for ('replicated');
}
-use Moose;
+use Moo;
+use Role::Tiny ();
use DBIx::Class::Storage::DBI;
-use DBIx::Class::Storage::DBI::Replicated::Pool;
-use DBIx::Class::Storage::DBI::Replicated::Balancer;
-use DBIx::Class::Storage::DBI::Replicated::Types qw/BalancerClassNamePart DBICSchema DBICStorageDBI/;
-use MooseX::Types::Moose qw/ClassName HashRef Object/;
-use Scalar::Util 'reftype';
-use Hash::Merge;
-use List::Util qw/min max/;
-
-use namespace::clean -except => 'meta';
+use Scalar::Util qw(reftype blessed);
+use List::Util qw(min max reduce);
+use Try::Tiny;
+use Sub::Name 'subname';
+use Class::Inspector;
+use DBIx::Class::Storage::DBI::Replicated::Types
+ qw(DBICSchema DBICStorageDBI ClassName HashRef Object
+ DoesDBICStorageReplicatedBalancer DBICStorageDBIReplicatedPool Defined);
=head1 NAME
$schema->storage_type( ['::DBI::Replicated', {balancer=>'::Random'}] );
$schema->connection(...);
-Next, you need to add in the Replicants. Basically this is an array of
+Next, you need to add in the Replicants. Basically this is an array of
arrayrefs, where each arrayref is database connect information. Think of these
arguments as what you'd pass to the 'normal' $schema->connect method.
my $RS = $schema->resultset('Source')->search(undef, {force_pool=>'master'});
Now $RS will force everything (both reads and writes) to use whatever was setup
-as the master storage. 'master' is hardcoded to always point to the Master,
+as the master storage. 'master' is hardcoded to always point to the Master,
but you can also use any Replicant name. Please see:
L<DBIx::Class::Storage::DBI::Replicated::Pool> and the replicants attribute for more.
=cut
has 'schema' => (
- is=>'rw',
- isa=>DBICSchema,
- weak_ref=>1,
- required=>1,
+ is=>'rw',
+ isa=>DBICSchema,
+ weak_ref=>1,
+ required=>1,
);
=head2 pool_type
-Contains the classname which will instantiate the L</pool> object. Defaults
+Contains the classname which will instantiate the L</pool> object. Defaults
to: L<DBIx::Class::Storage::DBI::Replicated::Pool>.
=cut
has 'pool_type' => (
is=>'rw',
isa=>ClassName,
- default=>'DBIx::Class::Storage::DBI::Replicated::Pool',
+ default=> sub { 'DBIx::Class::Storage::DBI::Replicated::Pool'},
handles=>{
'create_pool' => 'new',
},
has 'pool_args' => (
is=>'rw',
- isa=>HashRef,
+ isa =>HashRef,
lazy=>1,
default=>sub { {} },
);
has 'balancer_type' => (
is=>'rw',
- isa=>BalancerClassNamePart,
- coerce=>1,
- required=>1,
- default=> 'DBIx::Class::Storage::DBI::Replicated::Balancer::First',
- handles=>{
- 'create_balancer' => 'new',
- },
+ isa=>Defined,
+ default=>sub { 'DBIx::Class::Storage::DBI::Replicated::Balancer::First' },
);
+sub create_balancer {
+ my ($self, @args) = @_;
+ my $type = $self->balancer_type;
+ $type = 'DBIx::Class::Storage::DBI::Replicated::Balancer'.$type
+ if ($type=~m/^::/);
+ $self->schema->ensure_class_loaded($type);
+ return $type->new(@args);
+}
+
=head2 balancer_args
Contains a hashref of initialized information to pass to the Balancer object.
has 'balancer_args' => (
is=>'rw',
- isa=>HashRef,
+ isa =>HashRef,
lazy=>1,
- required=>1,
- default=>sub { {} },
+ default=>sub { +{} },
);
=head2 pool
-Is a <DBIx::Class::Storage::DBI::Replicated::Pool> or derived class. This is a
+Is a L<DBIx::Class::Storage::DBI::Replicated::Pool> or derived class. This is a
container class for one or more replicated databases.
=cut
has 'pool' => (
is=>'ro',
- isa=>'DBIx::Class::Storage::DBI::Replicated::Pool',
- lazy_build=>1,
+ isa =>DBICStorageDBIReplicatedPool,
+ lazy=>1,
+ builder=>'_build_pool',
+ clearer=>'clear_pool',
handles=>[qw/
connect_replicants
replicants
- has_replicants
/],
);
=head2 balancer
-Is a <DBIx::Class::Storage::DBI::Replicated::Balancer> or derived class. This
-is a class that takes a pool (<DBIx::Class::Storage::DBI::Replicated::Pool>)
+Is a L<DBIx::Class::Storage::DBI::Replicated::Balancer> or derived class. This
+is a class that takes a pool (L<DBIx::Class::Storage::DBI::Replicated::Pool>)
=cut
has 'balancer' => (
is=>'rw',
- isa=>'DBIx::Class::Storage::DBI::Replicated::Balancer',
- lazy_build=>1,
+ isa => DoesDBICStorageReplicatedBalancer,
+ lazy=>1,
+ builder=>'_build_balancer',
handles=>[qw/auto_validate_every/],
);
has 'master' => (
is=> 'ro',
- isa=>DBICStorageDBI,
- lazy_build=>1,
+ isa => DBICStorageDBI,
+ lazy=>1,
+ builder=>'_build_master',
);
=head1 ATTRIBUTES IMPLEMENTING THE DBIx::Storage::DBI INTERFACE
-The following methods are delegated all the methods required for the
+The following methods are delegated all the methods required for the
L<DBIx::Class::Storage::DBI> interface.
=head2 read_handler
has 'read_handler' => (
is=>'rw',
isa=>Object,
- lazy_build=>1,
+ lazy=>1,
+ builder=>'_build_read_handler',
handles=>[qw/
select
select_single
columns_info_for
- _dbh_columns_info_for
+ _dbh_columns_info_for
_select
/],
);
has 'write_handler' => (
is=>'ro',
isa=>Object,
- lazy_build=>1,
+ lazy=>1,
+ builder=>'_build_write_handler',
handles=>[qw/
on_connect_do
on_disconnect_do
with_deferred_fk_checks
dbh_do
reload_row
- with_deferred_fk_checks
_prep_for_execute
backup
is_datatype_numeric
- can_insert_returning
_count_select
- _subq_count_select
_subq_update_delete
svp_rollback
svp_begin
svp_release
relname_to_table_alias
- _straight_join_to_node
_dbh_last_insert_id
_fix_bind_params
_default_dbi_connect_attributes
_dbi_connect_info
+ _dbic_connect_attributes
auto_savepoint
_sqlt_version_ok
_query_end
_dbh
_select_args
_dbh_execute_array
- _sql_maker_args
_sql_maker
_query_start
_sqlt_version_error
_parse_connect_do
_dbh_commit
_execute_array
- _placeholders_supported
- _verify_pid
savepoints
_sqlt_minimum_version
_sql_maker_opts
_conn_pid
- _typeless_placeholders_supported
- _conn_tid
_dbh_autocommit
_native_data_type
_get_dbh
_resolve_column_info
_prune_unused_joins
_strip_cond_qualifiers
- _parse_order_by
_resolve_aliastypes_from_select_args
_execute
_do_query
_dbh_sth
_dbh_execute
- _prefetch_insert_auto_nextvals
/],
);
-has _master_connect_info_opts =>
- (is => 'rw', isa => HashRef, default => sub { {} });
+my @unimplemented = qw(
+ _arm_global_destructor
+ _preserve_foreign_dbh
+ _verify_pid
+ _verify_tid
+
+ get_use_dbms_capability
+ set_use_dbms_capability
+ get_dbms_capability
+ set_dbms_capability
+ _dbh_details
+
+ sql_limit_dialect
+
+ _inner_join_to_node
+ _group_over_selection
+ _extract_order_criteria
+ _is_lob_type
+ _max_column_bytesize
+ _prefetch_autovalues
+);
+
+# the capability framework
+push @unimplemented, ( grep
+ { $_ =~ /^ _ (?: use | supports | determine_supports ) _ /x }
+ @{Class::Inspector->methods('DBIx::Class::Storage::DBI')||[]}
+);
+
+for my $method (@unimplemented) {
+ {
+ no strict qw/refs/;
+ *{__PACKAGE__ ."::$method"} = subname $method => sub {
+ croak "$method must not be called on ".(blessed shift).' objects';
+ };
+ }
+}
+
+has _master_connect_info_opts => (
+ is => 'rw',
+ isa =>HashRef ,
+ default => sub { +{} },
+);
=head2 around: connect_info
around connect_info => sub {
my ($next, $self, $info, @extra) = @_;
- my $wantarray = wantarray;
-
my $merge = Hash::Merge->new('LEFT_PRECEDENT');
my %opts;
$merge->merge((delete $opts{pool_args} || {}), $self->pool_args)
);
- $self->pool($self->_build_pool)
- if $self->pool;
+ ## Since we possibly changed the pool_args, we need to clear the current
+ ## pool object so that next time it is used it will be rebuilt.
+ $self->clear_pool;
}
if (@opts{qw/balancer_type balancer_args/}) {
$self->_master_connect_info_opts(\%opts);
- my (@res, $res);
- if ($wantarray) {
+ my @res;
+ if (wantarray) {
@res = $self->$next($info, @extra);
} else {
- $res = $self->$next($info, @extra);
+ $res[0] = $self->$next($info, @extra);
}
# Make sure master is blessed into the correct class and apply role to it.
my $master = $self->master;
$master->_determine_driver;
- Moose::Meta::Class->initialize(ref $master);
- DBIx::Class::Storage::DBI::Replicated::WithDSN->meta->apply($master);
+ ## Moose::Meta::Class->initialize(ref $master);
+ Role::Tiny->apply_roles_to_object($master, 'DBIx::Class::Storage::DBI::Replicated::WithDSN');
+ ## DBIx::Class::Storage::DBI::Replicated::WithDSN->meta->apply($master);
# link pool back to master
$self->pool->master($master);
- $wantarray ? @res : $res;
+ wantarray ? @res : $res[0];
};
=head1 METHODS
This class defines the following methods.
-=head2 BUILDARGS
+=head2 new
L<DBIx::Class::Schema> when instantiating its storage passed itself as the
first argument. So we need to massage the arguments a bit so that all the
=cut
-sub BUILDARGS {
- my ($class, $schema, $storage_type_args, @args) = @_;
-
- return {
- schema=>$schema,
+around 'new', sub {
+ my ($orig, $class, $schema, $storage_type_args, @args) = @_;
+ return $orig->(
+ $class,
+ schema => $schema,
%$storage_type_args,
- @args
- }
-}
+ @args,
+ );
+};
=head2 _build_master
sub _build_master {
my $self = shift @_;
my $master = DBIx::Class::Storage::DBI->new($self->schema);
- $master
+ return $master;
}
=head2 _build_pool
my $reliably = sub {
my $name = shift @_;
$schema->resultset('User')->create({name=>$name});
- my $user_rs = $schema->resultset('User')->find({name=>$name});
+ my $user_rs = $schema->resultset('User')->find({name=>$name});
return $user_rs;
};
my @result;
my $want_array = wantarray;
- eval {
+ try {
if($want_array) {
@result = $coderef->(@args);
} elsif(defined $want_array) {
} else {
$coderef->(@args);
}
+ } catch {
+ $self->throw_exception("coderef returned an error: $_");
+ } finally {
+ ##Reset to the original state
+ $self->read_handler($current);
};
- ##Reset to the original state
- $self->read_handler($current);
-
- ##Exception testing has to come last, otherwise you might leave the
- ##read_handler set to master.
-
- if($@) {
- $self->throw_exception("coderef returned an error: $@");
- } else {
- return $want_array ? @result : $result[0];
- }
+ return wantarray ? @result : $result[0];
}
=head2 set_reliable_storage
foreach my $source ($self->all_storages) {
$source->limit_dialect(@_);
}
- return $self->master->quote_char;
+ return $self->master->limit_dialect;
}
=head2 quote_char
my $self = shift;
return max map $_->lag_behind_master, $self->replicants;
-}
+}
=head2 is_replicating
sub _driver_determined {
my $self = shift;
-
+
if (@_) {
$_->_driver_determined(@_) for $self->all_storages;
}
sub _init {
my $self = shift;
-
+
$_->_init for $self->all_storages;
}
sub _run_connection_actions {
my $self = shift;
-
+
$_->_run_connection_actions for $self->all_storages;
}
sub _do_connection_actions {
my $self = shift;
-
+
if (@_) {
$_->_do_connection_actions(@_) for $self->all_storages;
}
return min map $_->_ping, $self->all_storages;
}
+# not using the normalized_version, because we want to preserve
+# version numbers much longer than the conventional xxx.yyyzzz
+my $numify_ver = sub {
+ my $ver = shift;
+ my @numparts = split /\D+/, $ver;
+ my $format = '%d.' . (join '', ('%06d') x (@numparts - 1));
+
+ return sprintf $format, @numparts;
+};
+sub _server_info {
+ my $self = shift;
+
+ if (not $self->_dbh_details->{info}) {
+ $self->_dbh_details->{info} = (
+ reduce { $a->[0] < $b->[0] ? $a : $b }
+ map [ $numify_ver->($_->{dbms_version}), $_ ],
+ map $_->_server_info, $self->all_storages
+ )->[1];
+ }
+
+ return $self->next::method;
+}
+
+sub _get_server_version {
+ my $self = shift;
+
+ return $self->_server_info->{dbms_version};
+}
+
=head1 GOTCHAS
Due to the fact that replicants can lag behind a master, you must take care to
=head1 AUTHOR
- John Napiorkowski <john.napiorkowski@takkle.com>
+ John Napiorkowski <jjnapiork@cpan.org>
Based on code originated by:
=cut
-__PACKAGE__->meta->make_immutable;
-
1;
projects / dbsrgits/DBIx-Class.git / blobdiff