view release on metacpan or search on metacpan
sv_reftype|||
sv_release_COW|||
sv_replace|||
sv_report_used|||
sv_reset|||
sv_rvweaken||5.006000|
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
sv_setpv_mg|5.004050||p
view release on metacpan or search on metacpan
sv_release_COW|||
sv_release_IVX|||
sv_replace|||
sv_report_used|||
sv_reset|||
sv_rvweaken||5.006000|
sv_setiv_mg|5.006000||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
sv_setpv_mg|5.006000||p
view release on metacpan or search on metacpan
sv_reftype|||
sv_release_COW|||
sv_replace|||
sv_report_used|||
sv_reset|||
sv_rvweaken||5.006000|
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
sv_setpv_mg|5.004050||p
view release on metacpan or search on metacpan
lib/DB/Object.pm view on Meta::CPAN
$VERSION $AUTOLOAD $CACHE_DIR $CACHE_SIZE $DRIVER2PACK
$ERROR $DEBUG $MOD_PERL $USE_BIND $USE_CACHE $PLACEHOLDER_REGEXP $SERIALISER
$SERIALISATION_VERSION $EXCEPTION_CLASS
);
use Regexp::Common;
use Scalar::Util qw( blessed weaken );
use DB::Object::Cache::Tables;
use DBI;
use JSON;
use Module::Generic::File qw( sys_tmpdir );
use Module::Generic::Global qw( :const );
lib/DB/Object.pm view on Meta::CPAN
{
$o->table_object( $self ) || return( $self->pass_error( $o->error ) );
# Weaken the back-reference from the Query object to its owning Table to break
# the circular reference cycle (Table -> query_object -> Query -> table_object -> Table)
# that prevents Perl's garbage collector from reclaiming old Query objects.
weaken( $o->{table_object} );
$o->database_object( $self->database_object ) || return( $self->pass_error( $o->error ) );
# Also weaken the database_object reference - the dbo is a long-lived singleton
# and does not own Query objects, so a weak reference is safe here.
weaken( $o->{database_object} );
# Set the table alias if any has been set
if( my $table_alias = $self->as )
{
$o->table_alias( $table_alias ) if( defined( $table_alias ) );
}
view release on metacpan or search on metacpan
lib/DBD/Avatica/Adapter/Default.pm view on Meta::CPAN
package DBD::Avatica::Adapter::Default;
use strict;
use warnings;
use Scalar::Util 'weaken';
use Carp 'croak';
use Time::Piece;
use Scalar::Util qw/looks_like_number/;
use DBI ':sql_types';
lib/DBD/Avatica/Adapter/Default.pm view on Meta::CPAN
sub new {
my ($class, %params) = @_;
my $self = {dbh => $params{dbh}};
weaken $self->{dbh};
return bless $self, $class;
}
# params:
view release on metacpan or search on metacpan
sv_reftype|||
sv_release_COW|||
sv_replace|||
sv_report_used|||
sv_reset|||
sv_rvweaken||5.006000|
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
sv_setpv_mg|5.004050||p
view release on metacpan or search on metacpan
lib/DBD/SQLcipher/VirtualTable.pm view on Meta::CPAN
#======================================================================
package DBD::SQLcipher::VirtualTable;
#======================================================================
use strict;
use warnings;
use Scalar::Util qw/weaken/;
our $VERSION = '1.48';
our @ISA;
lib/DBD/SQLcipher/VirtualTable.pm view on Meta::CPAN
db_name => $db_name,
vtab_name => $vtab_name,
columns => \@columns,
options => \%options,
};
weaken $self->{dbh_ref};
return $self;
}
sub NEW {
view release on metacpan or search on metacpan
dbdimp_virtual_table.inc view on Meta::CPAN
sqlite3_free(module_ISA);
/* build the init datastructure that will be passed to perl_vt_New() */
init_data = sqlite3_malloc(sizeof(*init_data));
init_data->dbh = newRV(dbh);
sv_rvweaken(init_data->dbh);
init_data->perl_class = sqlite3_mprintf(perl_class);
/* register within sqlite */
rc = sqlite3_create_module_v2( imp_dbh->db,
name,
view release on metacpan or search on metacpan
sv_reftype|||
sv_release_COW|||
sv_replace|||
sv_report_used|||
sv_reset|||
sv_rvweaken||5.006000|
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
sv_setpv_mg|5.004050||p
view release on metacpan or search on metacpan
lib/DBD/SQLite/VirtualTable.pm view on Meta::CPAN
#======================================================================
package DBD::SQLite::VirtualTable;
#======================================================================
use strict;
use warnings;
use Scalar::Util qw/weaken/;
our $VERSION = '1.78';
our @ISA;
lib/DBD/SQLite/VirtualTable.pm view on Meta::CPAN
db_name => $db_name,
vtab_name => $vtab_name,
columns => \@columns,
options => \%options,
};
weaken $self->{dbh_ref};
return $self;
}
sub NEW {
view release on metacpan or search on metacpan
lib/DBD/Sys.pm view on Meta::CPAN
use strict;
use warnings;
use vars qw(@ISA);
use Scalar::Util qw(weaken);
@ISA = qw(DBI::DBD::SqlEngine::Statement);
sub open_table($$$$$)
{
lib/DBD/Sys.pm view on Meta::CPAN
$meta->{$1} = $dbh->{$attr};
}
$attrs->{meta} = $meta;
$attrs->{database} = $dbh;
$attrs->{owner} = $self;
weaken( $attrs->{owner} );
weaken( $attrs->{database} );
my $tbl = $dbh->{sys_pluginmgr}->get_table( $table, $attrs );
return $tbl;
}
view release on metacpan or search on metacpan
lib/DBD/Teradata.pm view on Meta::CPAN
$debug = $ENV{TDAT_DBD_DEBUG} || 0;
$use_arm = ($Config{archname}=~/^arm-linux/i);
our $HAS_WEAKEN = eval {
require Scalar::Util;
Scalar::Util::weaken(my $test = \"foo");
1;
};
};
our %td_type_code2str = (
lib/DBD/Teradata.pm view on Meta::CPAN
$sth->STORE('NUM_OF_FIELDS', delete $args->{NUM_OF_FIELDS});
my ($key, $val);
$sth->{$key} = $val
while (($key, $val) = each %$args);
$dbh->{_stmts}{$sth->{CursorName}} = $sth;
Scalar::Util::weaken($dbh->{_stmts}{$sth->{CursorName}})
if $DBD::Teradata::HAS_WEAKEN;
$dbh->{_cursors}{$sth->{CursorName}} = $sth,
$sth->{tdat_keepresp} = 1,
$sthp[16] = 1
if ($#$stmtinfo == 1) &&
view release on metacpan or search on metacpan
SvROK_off|5.003007|5.003007|
SvROK_on|5.003007|5.003007|
SvRV|5.003007|5.003007|
SvRV_const|5.010001||Viu
SvRV_set|5.009003|5.003007|p
sv_rvunweaken|5.027004|5.027004|
sv_rvweaken|5.006000|5.006000|
SvRVx|5.003007||Viu
SvRX|5.009005|5.003007|p
SvRXOK|5.009005|5.003007|p
SV_SAVED_COPY|5.009005||Viu
SvSCREAM|5.003007||Viu
view release on metacpan or search on metacpan
lib/DBGp/Client/AnyEvent/Connection.pm view on Meta::CPAN
use strict;
use warnings;
use AnyEvent::Handle;
use DBGp::Client::AsyncConnection;
use Scalar::Util qw(weaken blessed);
sub new {
my ($class, %args) = @_;
my $self = bless {
handle => undef,
on_stream => undef,
on_notify => undef,
connection => DBGp::Client::AsyncConnection->new(socket => $args{socket}),
}, $class;
my $weak_self = $self;
weaken($weak_self);
my $handle = AnyEvent::Handle->new(
fh => $args{socket},
on_error => sub {
my ($handle, $fatal, $message) = @_;
view release on metacpan or search on metacpan
lib/DBGp/Client/AsyncConnection.pm view on Meta::CPAN
init => undef,
commands => {},
on_stream => undef,
on_notification => undef,
}, $class;
Scalar::Util::weaken($weak_self);
$stream->on_line(sub { $weak_self->_receive_line(@_) });
return $self;
}
view release on metacpan or search on metacpan
lib/DBI/Changes.pm view on Meta::CPAN
Fixed cases where ShowErrorStatement might show incorrect Statement RT#97434
Fixed DBD::Gofer for UTF-8-enabled STDIN/STDOUT
thanks to mauke PR#32
Fixed fetchall_arrayref({}) behavior with no columns
thanks to Dan McGee PR#31
Fixed tied CachedKids ref leak in attribute cache by weakening
thanks to Michael Conrad RT#113852
Fixed "panic: attempt to copy freed scalar" upon commit() or rollback()
thanks to fbriere for detailed bug report RT#102791
Ceased to ignore DESTROY of outer handle in DBI::PurePerl
Treat undef in DBI::Profile Path as string "undef"
lib/DBI/Changes.pm view on Meta::CPAN
=head2 Changes in DBI 1.59 (svn rev 9874) - 23 Aug 2007
Fixed DBI::ProfileData to unescape headers lines read from data file.
Fixed DBI::ProfileData to not clobber $_, thanks to Alexey Tourbin.
Fixed DBI::SQL::Nano to not clobber $_, thanks to Alexey Tourbin.
Fixed DBI::PurePerl to return undef for ChildHandles if weaken not available.
Fixed DBD::Proxy disconnect error thanks to Philip Dye.
Fixed DBD::Gofer::Transport::Base bug (typo) in timeout code.
Fixed DBD::Proxy rows method thanks to Philip Dye.
Fixed dbiprof compile errors, thanks to Alexey Tourbin.
Fixed t/03handle.t to skip some tests if ChildHandles not available.
lib/DBI/Changes.pm view on Meta::CPAN
Added SQL_BIGINT type code (resolved to the ODBC/JDBC value (-5))
Added $h->private_attribute_info method.
=head2 Changes in DBI 1.53 (svn rev 7995) - 31 Oct 2006
Fixed checks for weaken to work with early 5.8.x versions
Fixed DBD::Proxy handling of some methods, including commit and rollback.
Fixed t/40profile.t to be more insensitive to long double precision.
Fixed t/40profile.t to be insensitive to small negative shifts in time
thanks to Jamie McCarthy.
Fixed t/40profile.t to skip tests for perl < 5.8.0.
lib/DBI/Changes.pm view on Meta::CPAN
=head2 Changes in DBI 1.51 (svn rev 6475) - 06 Jun 2006
Fixed $dbh->clone method 'signature' thanks to Jeffrey Klein.
Fixed default ping() method to return false if !$dbh->{Active}.
Fixed t/40profile.t to be insensitive to long double precision.
Fixed for perl 5.8.0's more limited weaken() function.
Fixed DBD::Proxy to not alter $@ in disconnect or AUTOLOADd methods.
Fixed bind_columns() to use return set_err(...) instead of die()
to report incorrect number of parameters, thanks to Ben Thul.
Fixed bind_col() to ignore undef as bind location, thanks to David Wheeler.
Fixed for perl 5.9.x for non-threaded builds thanks to Nicholas Clark.
view release on metacpan or search on metacpan
lib/DBICx/Modeler.pm view on Meta::CPAN
use DBICx::Modeler::Carp;
use constant TRACE => DBICx::Modeler::Carp::TRACE;
use Class::Inspector();
use Scalar::Util qw/weaken/;
use DBICx::Modeler::Model::Source;
#########
# Class #
lib/DBICx/Modeler.pm view on Meta::CPAN
$self->_setup_schema_modeler_accessor unless $self->skip_schema_modeler_accessor;
$self->_setup_base_model_sources;
{
$self->schema->modeler( $self );
weaken $self->schema->{modeler};
}
return 1;
}
view release on metacpan or search on metacpan
lib/DBIO/Async/Pool.pm view on Meta::CPAN
my $storage = delete $args{storage};
croak('storage required') unless $storage;
my $self = $class->SUPER::new(%args);
$self->{storage} = $storage;
Scalar::Util::weaken($self->{storage}) if ref $self->{storage};
return $self;
}
sub acquire {
lib/DBIO/Async/Pool.pm view on Meta::CPAN
on_error => sub { warn $_[0] },
);
Like L<DBIO::Storage::PoolBase/new>, but requires a C<storage> argument
(the L<DBIO::Async::Storage> that owns this pool). The storage reference
is weakened to avoid a cycle (storage holds pool, pool holds storage).
=head2 acquire
Like L<DBIO::Storage::PoolBase/acquire>, but the resolved Future does not
complete until the connection is actually ready for queries. This
view release on metacpan or search on metacpan
lib/DBIO/Forked/Storage.pm view on Meta::CPAN
my $self = bless {
schema => $schema,
connect_info => undef,
debug => $ENV{DBIO_TRACE} || 0,
}, $class;
Scalar::Util::weaken($self->{schema}) if ref $self->{schema};
$self;
}
sub future_class { 'DBIO::Forked::Future' }
lib/DBIO/Forked/Storage.pm view on Meta::CPAN
=head2 new
my $storage = DBIO::Forked::Storage->new($schema);
Construct the fork-based async backend for C<$schema>. The schema reference is
weakened (the schema owns the storage, not the other way round). Connect info
is supplied separately via L</connect_info>.
=head2 future_class
Returns C<'DBIO::Forked::Future'> -- the loop-free, pipe-backed Future this
view release on metacpan or search on metacpan
t/10-mssql.t view on Meta::CPAN
use strict;
use warnings;
use Test::More;
use Test::Exception;
use Scalar::Util 'weaken';
use DBIO::Optional::Dependencies ();
use DBIO::Test;
my ($dsn, $user, $pass) = @ENV{map { "DBIO_TEST_MSSQL_${_}" } qw/DSN USER PASS/};
t/10-mssql.t view on Meta::CPAN
)
SQL
});
my $rs = $schema->resultset('Money');
weaken(my $rs_cp = $rs); # nested closure refcounting is an utter mess in perl
my $row;
lives_ok {
$row = $rs->create({ amount => 100 });
} 'inserted a money value';
t/10-mssql.t view on Meta::CPAN
$rs->next;
my $map = [ ['Artist 1', '1002.00'], ['Artist 2', '1003.00'] ];
weaken(my $a_rs_cp = $artist_rs);
lives_and {
my @results;
$wrappers->{$wrapper}->( sub {
view release on metacpan or search on metacpan
t/10-mysql.t view on Meta::CPAN
use Test::More;
use Test::Exception;
use Test::Warn;
use DBI::Const::GetInfoType;
use Scalar::Util qw/weaken/;
use DBIO::Test;
use DBIO::Util qw(peepeeness);
my ($dsn, $user, $pass) = @ENV{map { "DBIO_TEST_MYSQL_${_}" } qw/DSN USER PASS/};
t/10-mysql.t view on Meta::CPAN
skip 'DBD::MariaDB fork+auto_reconnect behaves differently', 6
if $is_mariadb;
my $schema_autorecon = DBIO::Test::Schema->connect($dsn, $user, $pass, { $ar_attr => 1 });
my $orig_dbh = $schema_autorecon->storage->_get_dbh;
weaken $orig_dbh;
ok ($orig_dbh, 'Got weak $dbh ref');
ok ($orig_dbh->{$ar_attr}, 'auto_reconnect is properly set if explicitly requested' );
my $rs = $schema_autorecon->resultset('Artist');
view release on metacpan or search on metacpan
t/32-async-load-age.t view on Meta::CPAN
size => $self->{_pool_size} || 2,
);
}
}
my $schema = DBIO::Test->init_schema; # kept alive: storages weaken their refs
# The owning SYNC storage is the composed Age storage (Age LAYER over the PG
# driver) -- it carries connect_call_load_age via the layer.
my $owner_class = DBIO::Storage::Composed->compose(
'DBIO::PostgreSQL::Storage', ['DBIO::PostgreSQL::Age::Storage'],
view release on metacpan or search on metacpan
- Async is opt-in per connection via { async => 'ev' } (ADR 0030):
loading the PostgreSQL::EV component is an inert marker, and the EV
backend is reached explicitly through
MyApp::Schema->connect($dsn, $u, $p, { async => 'ev' }). The async
storage is embedded as the async backend of the sync storage rather
than hijacking storage_type; it weakens its schema ref to break the
embed cycle and accepts the sync driver's DBI-form connect_info. The
legacy async_backend() instance method and async_fallback chain are
gone — a *_async call on a sync instance now croaks explicitly rather
than silently degrading. (ADR 0028, ADR 0030, karr #59)
- insert_async resolves with a returned-columns HASHREF, not a positional
view release on metacpan or search on metacpan
t/32-threadtxn.t view on Meta::CPAN
use Test::More;
plan skip_all => 'DBIO does not actively support threads before perl 5.8.5'
if $] < '5.008005';
use Scalar::Util 'weaken';
use DBIO::Test;
my ($dsn, $user, $pass) = @ENV{map { "DBIO_TEST_PG_${_}" } qw/DSN USER PASS/};
plan skip_all => 'Set $ENV{DBIO_TEST_PG_DSN}, _USER and _PASS to run this test'
. ' (note: creates and drops a table named cd!)' unless ($dsn && $user);
t/32-threadtxn.t view on Meta::CPAN
my @children;
while(@children < $num_children) {
my $newthread = async {
my $tid = threads->tid;
weaken(my $weak_schema = $schema);
weaken(my $weak_parent_rs = $parent_rs);
$schema->txn_do(sub {
my $child_rs = $weak_schema->resultset('CD')->search({ year => 1901 });
my $row = $weak_parent_rs->next;
if($row && $row->get_column('artist') =~ /^(?:123|456)$/) {
$weak_schema->resultset('CD')->create({ title => "test success $tid", artist => $tid, year => scalar(@children) });
view release on metacpan or search on metacpan
t/52leaks.t view on Meta::CPAN
use warnings;
use Test::More;
use DBIO::Test;
use DBIO::Test::Util::LeakTracer qw(populate_weakregistry assert_empty_weakregistry visit_refs);
use Scalar::Util qw(weaken blessed reftype);
use DBIO::Util qw(hrefaddr peepeeness sigwarn_silencer modver_gt_or_eq modver_gt_or_eq_and_lt);
BEGIN {
plan skip_all => "Your perl version $] appears to leak like a sieve - skipping test"
if peepeeness;
}
t/52leaks.t view on Meta::CPAN
# so done_testing can work on every persistent pass
$TB->reset;
}
# this is what holds all weakened refs to be checked for leakage
my $weak_registry = {};
# whether or to invoke IC::DT
my $has_dt;
t/52leaks.t view on Meta::CPAN
# this is useless on its own, it is to showcase the circref-diag
# and eventually test it when it is operational
local $TODO = 'Needs Data::Entangled or somesuch - see RT#82942';
while (@circreffed) {
weaken (my $r = shift @circreffed);
populate_weakregistry( (my $mini_registry = {}), $r );
assert_empty_weakregistry( $mini_registry );
$r->result_source(undef);
view release on metacpan or search on metacpan
lib/DBIO/Sybase/Storage/ASE.pm view on Meta::CPAN
DBIO::Storage::DBI::AutoCast
DBIO::Storage::DBI::IdentityInsert
/;
use mro 'c3';
use DBIO::Carp;
use Scalar::Util qw/blessed weaken/;
use List::Util 'first';
use Sub::Name();
use Try::Tiny;
use Context::Preserve 'preserve_context';
use DBIO::Util 'sigwarn_silencer';
lib/DBIO/Sybase/Storage/ASE.pm view on Meta::CPAN
$writer_storage->_is_writer_storage(1); # just info
$writer_storage->connect_info($self->connect_info);
$writer_storage->auto_cast($self->auto_cast);
weaken ($writer_storage->{_parent_storage} = $self);
$self->_writer_storage($writer_storage);
# create a bulk storage unless connect_info is a coderef
return if ref($self->_dbi_connect_info->[0]) eq 'CODE';
lib/DBIO/Sybase/Storage/ASE.pm view on Meta::CPAN
$bulk_storage->connect_info($self->connect_info);
# this is why
$bulk_storage->_dbi_connect_info->[0] .= ';bulkLogin=1';
weaken ($bulk_storage->{_parent_storage} = $self);
$self->_bulk_storage($bulk_storage);
}
for my $method (@also_proxy_to_extra_storages) {
no strict 'refs';
view release on metacpan or search on metacpan
lib/DBIO/Base.pm view on Meta::CPAN
no strict 'refs';
$successfully_loaded_components->{$class}
= ${"${class}::__LOADED__BY__DBIO__CAG__COMPONENT_CLASS__"}
= do { \(my $anon = 'loaded') };
Scalar::Util::weaken($successfully_loaded_components->{$class});
}
$class;
}
view release on metacpan or search on metacpan
lib/DBIx/Abstract.pm view on Meta::CPAN
# ABSTRACT: DBI SQL abstraction
package DBIx::Abstract;
$DBIx::Abstract::VERSION = '1.04';
use DBI;
use Scalar::Util 'weaken';
use Check::ISA qw( obj_does );
use strict;
use warnings;
our $AUTOLOAD;
lib/DBIx/Abstract.pm view on Meta::CPAN
$newself->{'ORIG'} = $self;
}
else {
$newself->{'ORIG'} = $self->{'ORIG'};
}
weaken( $newself->{'ORIG'} );
push( @{ $newself->{'ORIG'}->{'CLONES'} }, $newself );
weaken(
$newself->{'ORIG'}->{'CLONES'}[ $#{ $newself->{'ORIG'}->{'CLONES'} } ]
);
$self->__logwrite( 5, 'Cloned' );
return $newself;
view release on metacpan or search on metacpan
lib/DBIx/Async.pm view on Meta::CPAN
use DBIx::Async::Handle;
# temporary pending next release of curry
our $_curry_weak = sub {
my ($invocant, $code) = splice @_, 0, 2;
Scalar::Util::weaken($invocant) if Scalar::Util::blessed($invocant);
my @args = @_;
sub {
return unless $invocant;
$invocant->$code(@args => @_)
}
view release on metacpan or search on metacpan
lib/DBIx/BatchChunker.pm view on Meta::CPAN
use List::Util 1.33 (qw( min max sum any first )); # has any/all/etc.
use Math::BigInt upgrade => 'Math::BigFloat';
use Math::BigFloat;
use POSIX qw( ceil );
use Scalar::Util qw( blessed weaken );
use Term::ProgressBar 2.14; # with silent option
use Time::HiRes qw( time sleep );
use DBIx::BatchChunker::LoopState;