view release on metacpan or search on metacpan
lib/DBIx/Simple/Class.pm view on Meta::CPAN
return $self->update();
}
return;
}
sub update {
my ($self) = @_;
my $pk = $self->PRIMARY_KEY;
$self->{data}{$pk} || croak('Please define primary key column (\$self->$pk(?))!');
my $dbh = $self->dbh;
$self->{SQL_UPDATE} ||= do {
view release on metacpan or search on metacpan
lib/DBIx/Skinny.pm view on Meta::CPAN
my $code = $class->_attributes->{dbd}->can('bulk_insert') or Carp::croak "dbd don't provide bulk_insert method";
$code->($class, $table, $args);
}
sub update {
my ($class, $table, $args, $where) = @_;
my $schema = $class->schema;
$class->call_schema_trigger('pre_update', $schema, $table, $args);
lib/DBIx/Skinny.pm view on Meta::CPAN
$class->call_schema_trigger('post_update', $schema, $table, $rows);
return $rows;
}
sub update_by_sql {
my ($class, $sql, $bind) = @_;
Carp::carp( 'update_by_sql has been deprecated. Please use $skinny->do($sql, undef, @bind)' );
$class->do($sql, undef, @$bind);
}
view release on metacpan or search on metacpan
script/watchsheet.pl view on Meta::CPAN
my $watcher = Filesys::Notify::Simple->new([
sort keys %watch_directory,
]);
sub update_queries {
warn $file;
my $sheet = DBIx::Spreadsheet->new( file => $file );
my $dbh = $sheet->dbh;
my @eff_queries = map { -d ? glob "$_/*.sql" : $_ } @queries;
view release on metacpan or search on metacpan
lib/DBIx/Struct.pm view on Meta::CPAN
my $update;
if (not ref $table) {
# means this is just one simple table
$update = <<UPD;
sub update {
my \$self = \$_[0];
if(\@_ > 1 && CORE::ref(\$_[1]) eq 'HASH') {
my (\$set, \$where, \@bind, \@bind_where);
{
no strict 'vars';
lib/DBIx/Struct.pm view on Meta::CPAN
\$self;
}
UPD
} else {
$update = <<UPD;
sub update {}
UPD
}
$update;
}
view release on metacpan or search on metacpan
t/blog/lib/Blog/Controller/Posts.pm view on Meta::CPAN
my $id = $self->posts->add($validation->output);
$self->redirect_to('show_post', id => $id);
}
sub update {
my $self = shift;
my $validation = $self->_validation;
return $self->render(action => 'edit', post => {}) if $validation->has_error;
view release on metacpan or search on metacpan
lib/DBIx/TextIndex/DBD.pm view on Meta::CPAN
SELECT COUNT(*) FROM $self->{COLLECTION_TABLE}
END
}
sub update_collection_info {
my $self = shift;
my $field = shift;
return <<END;
UPDATE $self->{COLLECTION_TABLE}
lib/DBIx/TextIndex/DBD.pm view on Meta::CPAN
FROM $self->{ALL_DOCS_VECTOR_TABLE}
END
}
sub update_all_docs_vector {
my $self = shift;
return <<END;
REPLACE INTO $self->{ALL_DOCS_VECTOR_TABLE}
(id, all_docs_vector)
VALUES (1, ?)
lib/DBIx/TextIndex/DBD.pm view on Meta::CPAN
WHERE $self->{DOC_ID_FIELD} = ?
END
}
sub update_docweights {
my $self = shift;
return <<END;
REPLACE INTO $self->{DOCWEIGHTS_TABLE} (field_no, avg_docweight, docweights)
VALUES (?, ?, ?)
END
}
sub update_docweights_execute {
my $self = shift;
my ($sth, $fno, $avg_w_d, $packed_w_d) = @_;
$sth->execute($fno, $avg_w_d, $packed_w_d);
}
lib/DBIx/TextIndex/DBD.pm view on Meta::CPAN
END
return $delete_queue ? $delete_queue : undef;
}
sub update_delete_queue {
my $self = shift;
my $delete_queue = shift;
$self->{INDEX_DBH}->do(<<END, undef, $delete_queue, 1);
REPLACE INTO $self->{DELETE_QUEUE_TABLE} (delete_queue, id)
VALUES (?, ?)
view release on metacpan or search on metacpan
lib/DBIx/UpdateTable/FromHoH.pm view on Meta::CPAN
extra_update_columns => {
schema => ['hos*'], # XXX or code
},
},
};
sub update_table_from_hoh {
my %args = @_;
my $dbh = $args{dbh};
my $table = $args{table};
my $hoh = $args{hoh};
view release on metacpan or search on metacpan
lib/DBIx/VersionedSubs.pm view on Meta::CPAN
these will behave weird if you redefine a subroutine
that was previously closed over.
=cut
sub update_code {
my ($package) = @_;
my $version = $package->code_version || 0;
#warn "Checking against $version";
my $sth = $package->dbh->prepare_cached(sprintf <<'SQL', $package->code_history);
SELECT distinct name,action,new_code,version FROM %s
lib/DBIx/VersionedSubs.pm view on Meta::CPAN
This cannot override subroutines that don't exist in the database.
=cut
sub update_sub {
my ($package,$name,$new_code) = @_;
$package->add_code_history($name,$package->code_source->{$name},$new_code,'U');
my $sth = $package->dbh->prepare_cached(sprintf <<'SQL',$package->code_live);
UPDATE %s SET code=?
WHERE name=?
view release on metacpan or search on metacpan
This method updates an existing entry in a database table. See
_prepare_sql for the named parameters used.
=cut
sub update {
my $self = shift;
my %params = @_;
my $sql = $self->_prepare_sql ('update', \%params)
|| return undef;
view release on metacpan or search on metacpan
lib/DBIx/Wrapper.pm view on Meta::CPAN
This is so that the order of the parameters in the C<WHERE> clause
are kept in the same order. This is required to use the correct
multi field indexes in some databases.
=cut
sub update {
my ($self, $table, $keys, $data) = @_;
if (defined($keys)) {
unless ((UNIVERSAL::isa($keys, 'HASH') or UNIVERSAL::isa($keys, 'ARRAY'))) {
return $self->setErr(-1, 'DBIx::Wrapper: No keys passed to update()');
view release on metacpan or search on metacpan
lib/DBR/Config/Field.pm view on Meta::CPAN
}
### Admin functions
sub update_translator{
my $self = shift;
my $transname = shift;
$self->[O_session]->is_admin or return $self->_error('Cannot update translator in non-admin mode');
lib/DBR/Config/Field.pm view on Meta::CPAN
$FIELDS_BY_ID{ $self->[O_field_id] }->[C_trans_id] = $new_trans->{id}; # update local copy
return 1;
}
sub update_regex{
my $self = shift;
my $regex = shift;
$self->[O_session]->is_admin or return $self->_error('Cannot update translator in non-admin mode');
lib/DBR/Config/Field.pm view on Meta::CPAN
_gen_valcheck($fieldref); # Update value test sub
return 1;
}
sub update_default{
my $self = shift;
my $value = shift;
$self->[O_session]->is_admin or return $self->_error('Cannot update translator in non-admin mode');
view release on metacpan or search on metacpan
DBX/Recordset.pm view on Meta::CPAN
my ($self) = @_;
return !$self->{eof};
}
sub update
{
my ($self) = @_;
return unless $self->{dirty};
my %changed = %{$self->{changed}};
view release on metacpan or search on metacpan
lib/DB_File/DB_Database.pm view on Meta::CPAN
my %data = $self->check_field_names_hash(@_);
$self->set_record($id, map { $data{$_} } $self->field_names );
}
# ###############################################################################
# Write record, fields specified as hash, unspecified will be unchanged
sub update_record_hash {
my ($self, $id) = ( shift, shift );
my %olddata = $self->get_record_hash($id);
return unless %olddata;
$self->set_record_hash($id, %olddata, @_);
}
view release on metacpan or search on metacpan
DBomb/Base.pm view on Meta::CPAN
else{
$self->_dbo_insert_static(@_);
}
}
sub update
{
my $self = shift;
if (ref $self){
$self->_dbo_update(@_);
}
view release on metacpan or search on metacpan
lib/DNS/EasyDNS.pm view on Meta::CPAN
The function returns C<TRUE> of success. On failure it returns C<FALSE> and
sets C<$@>.
=cut
sub update {
my ($obj,%args) = @_;
my %get;
while (my ($k,$v) = each %args) {
if ( $k eq "username" ) { $obj->{"username"} = $v }
view release on metacpan or search on metacpan
lib/DNS/Hetzner/API/PrimaryServers.pm view on Meta::CPAN
sub get ($self, %params) {
return $self->_do( 'GetPrimaryServer', \%params, '/:PrimaryServerID', { type => 'get' } );
}
sub update ($self, %params) {
return $self->_do( 'UpdatePrimaryServer', \%params, '/:PrimaryServerID', { type => 'put' } );
}
1;
view release on metacpan or search on metacpan
lib/DNS/NIOS.pm view on Meta::CPAN
return $self->__request( 'POST', $args{path},
( payload => $args{payload}, params => $args{params} ) );
}
sub update {
my ( $self, %args ) = @_;
defined( $args{$_} )
or croak("$_ is required!")
for qw(path payload);
view release on metacpan or search on metacpan
lib/DNS/PunyDNS.pm view on Meta::CPAN
$self->{'password'} = $args[0]->{'password'} || die "No password provided";
return $self;
}
sub update_dns {
my ( $self, $domain, $ip, $record_type, $old_record_type ) = @_;
die "You must provide a domain" if !$domain;
die "You must provide an IP address" if !$ip;
my %args = (
view release on metacpan or search on metacpan
lib/DNS/WorldWideDns.pm view on Meta::CPAN
A hash reference identical to the one returned by getDomain().
=cut
sub updateDomain {
my ($self, $domain, $params) = @_;
# validate inputs
unless (defined $domain) {
MissingParam->throw(error=>'Need a domain.');
view release on metacpan or search on metacpan
lib/DNS/ZoneEdit.pm view on Meta::CPAN
Returns C<TRUE> on success. On failure it returns C<FALSE> and
sets C<$@>.
=cut
sub update {
my ($self,%args) = @_;
croak "update(): Argument 'username' is required"
unless defined $args{"username"};
view release on metacpan or search on metacpan
ZoneFile.pm view on Meta::CPAN
}
#updateSerial
# This function will update the serial number in the zone file loaded.
sub updateSerial
{
my $self=shift;
my $snum;
view release on metacpan or search on metacpan
sub emit {
if ($opt{0}) { push @script, splice @batch }
else { push @script, join '', splice @batch }
}
sub update {
my ($addel,$owner,$rrs) = @_;
push @batch, map "update $addel $owner $_", sort @$rrs;
}
for my $owner (keys %del) {
update 'delete', $owner, delete $del{$owner};
view release on metacpan or search on metacpan
lib/DR/Tarantool/AsyncClient.pm view on Meta::CPAN
=back
=cut
sub update {
my $self = shift;
my $space = shift;
my $key = shift;
my $op = shift;
$self->_llc->_check_cb( my $cb = pop );
view release on metacpan or search on metacpan
lib/DR/Tnt/Proto.pm view on Meta::CPAN
# HACK
_call_lua($sync, $schema_id, "box.space.$space:delete", $key);
}
sub update($$$$$) {
my ($sync, $schema_id, $space, $key, $ops) = @_;
croak 'Oplist must be Arrayref' unless 'ARRAY' eq ref $ops;
$key = [ $key ] unless ref $key;
croak "Cant convert HashRef to key" if 'HASH' eq ref $key;
view release on metacpan or search on metacpan
lib/DSP/LinPred.pm view on Meta::CPAN
}
# update only
# x should be array reference
sub update{
my $self = shift;
my $x = shift;
my $h_length = $self->h_length;
my $h = $self->h;
my $x_stack = $self->x_stack;
view release on metacpan or search on metacpan
lib/DSP/LinPred_XS.pm view on Meta::CPAN
}
# update only
# x should be array reference
sub update{
my $self = shift;
my $x = shift;
my $h_length = $self->h_length;
my $h = $self->h;
my $x_stack = $self->x_stack;
view release on metacpan or search on metacpan
lib/DTL/Fast/Tag/Ifchanged.pm view on Meta::CPAN
}
return $result;
}
sub update_preserved
{
my $self = shift;
my $context = shift;
$self->{preserved} = [ ];
view release on metacpan or search on metacpan
lib/DVB/Epg.pm view on Meta::CPAN
Return 0 if sections are already uptodate.
Return undef on error;
=cut
sub updateEit {
my $self = shift;
my $pid = shift;
my $dbh = $self->{dbh};
my $updated = 0;
lib/DVB/Epg.pm view on Meta::CPAN
Return 0 if sections are already uptodate.
Return 1 after updating sections.
=cut
sub updateEitPresent {
my $self = shift;
my $rule = shift;
my $forced = shift // 0;
my $dbh = $self->{dbh};
lib/DVB/Epg.pm view on Meta::CPAN
$rule is reference to hash containing keys:
pid, service_id, original_network_id, transport_stream_id, service_id, maxsegments, actual
=cut
sub updateEitSchedule {
my $self = shift;
my $rule = shift;
my $dbh = $self->{dbh};
my $num_subtable = int( ( $rule->{maxsegments} - 1 ) / 32 );
view release on metacpan or search on metacpan
lib/Dackup/Target/CloudFiles.pm view on Meta::CPAN
. $self->container->name . '/'
. $self->prefix
. $entry->key;
}
sub update {
my ( $self, $source, $entry ) = @_;
my $container = $self->container;
my $prefix = $self->prefix;
my $source_type = ref($source);
my $object = $self->object($entry);
view release on metacpan or search on metacpan
lib/Daemonise/Plugin/JobQueue.pm view on Meta::CPAN
return;
}
sub update_job {
my ($self, $msg, $status) = @_;
unless ((ref($msg) eq 'HASH')
and (exists $msg->{meta} and exists $msg->{meta}->{id}))
{