view release on metacpan or  search on metacpan

testme.tmp.pl  view on Meta::CPAN

#memory_leak_test_bug_65734();

#memory_leak_arrays();


sub update_rule_return {

my @statements = (
    q[DROP TABLE IF EXISTS test CASCADE],
    q[CREATE TABLE test(id int primary key, animal text, sound text)],
    q[CREATE VIEW test_view AS SELECT * FROM test],

 view release on metacpan or  search on metacpan

lib/JLdap.pm  view on Meta::CPAN

	$self->{dirty} = 0  if ($status > 0);
	return $status;
}

sub update
{
	my ($self, $csr, $query) = @_;
	my ($i, $path, $regex, $table, $extra, @attblist, $filter, $all_columns);
	my $status = 0;
	my ($psuedocols) = "CURVAL|NEXTVAL|ROWNUM";

 view release on metacpan or  search on metacpan

t/ExecuteArray.pm  view on Meta::CPAN

    check_data($dbh, \@p1, \@p2);
}

# test updates
# updates are special as you can update more rows than there are parameter rows
sub update
{
    my ($self, $dbh, $ref) = @_;

    note("update test");

 view release on metacpan or  search on metacpan

examples/ora_explain.pl  view on Meta::CPAN

return($dialog);
}

################################################################################

sub update_title()
{
$PlanMain->configure(-title =>
   $User
      ? $User eq $Schema
         ? "$ProgName - connected to $DbName as $User"

 view release on metacpan or  search on metacpan

t/03_DBD-PO/15_header_msgstr_hash.t  view on Meta::CPAN

        WHERE  msgid=''
EOT
    isa_ok($sth_update, 'DBI::st', 'prepare select');
}

sub update_header {
    my $name = shift;

    my ($test_keys, $test_values) = @{ $test_data{$name} };

    my %params;

 view release on metacpan or  search on metacpan

testme.tmp.pl  view on Meta::CPAN

#memory_leak_test_bug_65734();

#memory_leak_arrays();


sub update_rule_return {

my @statements = (
    q[DROP TABLE IF EXISTS test CASCADE],
    q[CREATE TABLE test(id int primary key, animal text, sound text)],
    q[CREATE VIEW test_view AS SELECT * FROM test],

 view release on metacpan or  search on metacpan

testme.tmp.pl  view on Meta::CPAN

#memory_leak_test_bug_65734();

#memory_leak_arrays();


sub update_rule_return {

my @statements = (
    q[DROP TABLE IF EXISTS test CASCADE],
    q[CREATE TABLE test(id int primary key, animal text, sound text)],
    q[CREATE VIEW test_view AS SELECT * FROM test],

 view release on metacpan or  search on metacpan

t/36_hooks.t  view on Meta::CPAN

# hooks : just count the commits / rollbacks / updates
my ($n_commits, $n_rollbacks, $n_updates, @update_args);
sub commit_hook   {  $n_commits   += 1; return 0; }
sub rollback_hook {  $n_rollbacks += 1; return 0; }
sub update_hook   {  $n_updates   += 1; 
                     @update_args  = @_;          }

my $sql_count_rows = "SELECT COUNT(foo) FROM hook_test";

foreach my $call_func (@CALL_FUNCS) {

 view release on metacpan or  search on metacpan

t/36_hooks.t  view on Meta::CPAN

# hooks : just count the commits / rollbacks / updates
my ($n_commits, $n_rollbacks, $n_updates, @update_args);
sub commit_hook   {  $n_commits   += 1; return 0; }
sub rollback_hook {  $n_rollbacks += 1; return 0; }
sub update_hook   {  $n_updates   += 1;
                     @update_args  = @_;          }

my $sql_count_rows = "SELECT COUNT(foo) FROM hook_test";

foreach my $call_func (@CALL_FUNCS) {

 view release on metacpan or  search on metacpan

t/36_hooks.t  view on Meta::CPAN

# hooks : just count the commits / rollbacks / updates
my ($n_commits, $n_rollbacks, $n_updates, @update_args);
sub commit_hook   {  $n_commits   += 1; return 0; }
sub rollback_hook {  $n_rollbacks += 1; return 0; }
sub update_hook   {  $n_updates   += 1; 
                     @update_args  = @_;          }

my $sql_count_rows = "SELECT COUNT(foo) FROM hook_test";

foreach my $call_func (@CALL_FUNCS) {

 view release on metacpan or  search on metacpan

lib/JSprite.pm  view on Meta::CPAN

		$errdetails = $query;
		return (-503);
    }
}

sub update
{
    my ($self, $query) = @_;
    my ($i, $path, $regex, $table, $extra, $condition, $all_columns, 
	$columns, $status);
	my ($psuedocols) = "CURRVAL|NEXTVAL";

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

        $examples =~ s/\r\n/\n/g;
        update_file( 'lib/WWW/Mechanize/Chrome/Examples.pm', $examples );
    };
};

sub update_file {
    my( $filename, $new_content ) = @_;
    my $content;
    if( -f $filename ) {
        open my $fh, '<', $filename
            or die "Couldn't read '$filename': $!";

 view release on metacpan or  search on metacpan

lib/XBase.pm  view on Meta::CPAN

	$self->set_record($num, map { $data{$_} } $self->field_names );
}

# Write record, fields specified as hash, unspecified will be
# unchanged
sub update_record_hash {
	my ($self, $num) = ( shift, shift );
	$self->NullError();

	my %olddata = $self->get_record_hash($num);
	return unless %olddata;

lib/XBase.pm  view on Meta::CPAN

	$self->NullError();
	$self->write_record($num, " ");
}

# Update the last change date
sub update_last_change {
	my $self = shift;
	return 1 if defined $self->{'updated_today'};
	my ($y, $m, $d) = (localtime)[5, 4, 3]; $m++; $y -= 100 if $y >= 100;
	$self->write_to(1, pack "C3", ($y, $m, $d)) or return;
	$self->{'updated_today'} = 1;
}
# Update the number of records
sub update_last_record {
	my ($self, $last) = @_;
	$last++;
	$self->write_to(4, pack "V", $last);
	$self->{'num_rec'} = $last;
}

 view release on metacpan or  search on metacpan

lib/DBI/Easy/Record.pm  view on Meta::CPAN

sub fetched {
	return 1 if defined shift->{field_values};
}

# update by pk
sub update_by_pk {
	my $self   = shift;
	my %params = @_;
	
	# there we make decision:
	# a) programmmer can provide update values

 view release on metacpan or  search on metacpan

lib/DBD/DBM.pm  view on Meta::CPAN

    my ( $self, $data, $aryref ) = @_;
    my $meta = $self->{meta};
    delete $meta->{hash}->{ $aryref->[0] };
}

sub update_one_row ($$$)
{
    my ( $self, $data, $aryref ) = @_;
    my $meta = $self->{meta};
    my $key  = shift @$aryref;
    defined $key or return;
    my $row = ( ref($aryref) eq 'ARRAY' ) ? $aryref : [$aryref];
    $meta->{hash}->{$key} = $meta->{dbm_mldbm} ? $row : $row->[0];
}

sub update_specific_row ($$$$)
{
    my ( $self, $data, $aryref, $origary ) = @_;
    my $meta   = $self->{meta};
    my $key    = shift @$origary;
    my $newkey = shift @$aryref;

 view release on metacpan or  search on metacpan

lib/DBICx/Hooks.pm  view on Meta::CPAN

  $ret;
}


sub update {
  my $self = shift;
  my $ret  = $self->next::method(@_);

  $_->($self) for dbic_hooks_for($self, 'update');

 view release on metacpan or  search on metacpan

lib/DBICx/MaterializedPath.pm  view on Meta::CPAN

    $self->next::method(@_);
    $self->set_materialized_path;
    $self->update;
}

sub update :method {
    my $self = shift;
    my %to_update = $self->get_dirty_columns;
    my $parent_column = $self->parent_column;
    $self->next::method(@_);
    return $self unless $to_update{$parent_column};

 view release on metacpan or  search on metacpan

lib/DBICx/Modeler/Model/Source.pm  view on Meta::CPAN

    my $storage = $rs->create( $given );
    $storage->discard_changes if $self->create_refresh && $storage->can( 'discard_changes' );
    return $self->inflate( _model__storage => $storage, @_ );
}

sub update_or_create {
    my $self = shift;
    my $given = shift;

    my $rs = $self->schema->resultset( $self->moniker );
    my $storage = $rs->update_or_create( $given );

 view release on metacpan or  search on metacpan

lib/DBIO/ClickHouse/SQLMaker.pm  view on Meta::CPAN

  return $self->next::method(\%opts);
}


sub update {
  my ($self, $table, $set, $where, $options) = @_;

  $self->_assert_mutation_target(update => $table);

  $self->throw_exception(

 view release on metacpan or  search on metacpan

t/94-blob-compare.t  view on Meta::CPAN

{
  package T::Maker;
  sub new { my ($c, $sql, @bind) = @_; bless { sql => $sql, bind => \@bind }, $c }
  sub select { my $s = shift; return ($s->{sql}, @{ $s->{bind} }) }
  sub update { my $s = shift; return ($s->{sql}, @{ $s->{bind} }) }
}

my %SUB;
sub gen {
  my ($class, $op, $sql, @bind) = @_;

 view release on metacpan or  search on metacpan

lib/DBIO/Forked/Storage.pm  view on Meta::CPAN

sub select_async        { my $self = shift; $self->_run_forked('select',        @_) }
sub select_single_async { my $self = shift; $self->_run_forked('select_single', @_) }
sub insert_async        { my $self = shift; $self->_run_forked('insert',        @_) }
sub update_async        { my $self = shift; $self->_run_forked('update',        @_) }
sub delete_async        { my $self = shift; $self->_run_forked('delete',        @_) }

# txn_do_async is just _run_forked('txn_do', $body, @args): the child runs the
# inherited sync storage's txn_do($body, @args), so BEGIN/body/COMMIT all happen
# in the child on its freshly-reconnected connection. See the method POD for the

lib/DBIO/Forked/Storage.pm  view on Meta::CPAN

# and wait for it via ->get.

sub select        { my $self = shift; $self->select_async(@_)->get        }
sub select_single { my $self = shift; $self->select_single_async(@_)->get }
sub insert        { my $self = shift; $self->insert_async(@_)->get        }
sub update        { my $self = shift; $self->update_async(@_)->get        }
sub delete        { my $self = shift; $self->delete_async(@_)->get        }
sub txn_do        { my $self = shift; $self->txn_do_async(@_)->get        }

1;

 view release on metacpan or  search on metacpan

lib/DBIO/MySQL/Async/Storage.pm  view on Meta::CPAN

  my $self = shift;
  return $self->_run_crud('insert', undef, @_);
}


sub update_async {
  my $self = shift;
  return $self->_run_crud('update', undef, @_);
}

lib/DBIO/MySQL/Async/Storage.pm  view on Meta::CPAN

sub insert {
  my $self = shift;
  return $self->insert_async(@_)->get;
}

sub update {
  my $self = shift;
  return $self->update_async(@_)->get;
}

sub delete {

 view release on metacpan or  search on metacpan

t/transaction-context.t  view on Meta::CPAN

  }
  # These should NOT be reached by the context anymore — if they are, the
  # query is escaping the transaction onto a fresh pool connection.
  sub select_async        { die 'select_async on storage MUST NOT be called from txn context' }
  sub select_single_async { die 'select_single_async on storage MUST NOT be called from txn context' }
  sub update_async        { die 'update_async on storage MUST NOT be called from txn context' }
  sub delete_async        { die 'delete_async on storage MUST NOT be called from txn context' }
  sub insert_async        { die 'insert_async on storage MUST NOT be called from txn context' }
  # core karr k213: the context's pipeline runs the scaffold on the PINNED txn
  # connection via _pipeline_on_conn, with NO release coderef (the connection
  # belongs to the transaction boundary). Record exactly what it is handed:

t/transaction-context.t  view on Meta::CPAN

  sub pipeline     { push @{$_[0]->{_queries} //= []}, 'pipeline';     Future->done([]) }
  sub txn_do_async { push @{$_[0]->{_queries} //= []}, 'txn_do_async'; Future->done([]) }
  sub select          { push @{$_[0]->{_queries} //= []}, 'select'; 'SELECT_RESULT' }
  sub select_single   { push @{$_[0]->{_queries} //= []}, 'select_single'; 'SELECT_SINGLE_RESULT' }
  sub insert          { push @{$_[0]->{_queries} //= []}, 'insert'; 'INSERT_RESULT' }
  sub update          { push @{$_[0]->{_queries} //= []}, 'update'; 'UPDATE_RESULT' }
  sub delete          { push @{$_[0]->{_queries} //= []}, 'delete'; 'DELETE_RESULT' }
}
{
  package MockPoolMySQL;
  sub new { bless {}, $_[0] }

 view release on metacpan or  search on metacpan

lib/DBIO/MySQL/SQLMaker.pm  view on Meta::CPAN

  }

  return $new_sql . $sql;
}

sub update {
  my $self = shift;
  my ($target, $source, $attributes) = @_;

  my ($sql, @bind) = $self->next::method(@_);

 view release on metacpan or  search on metacpan

lib/DBIO/Oracle/Storage/LOBSupport.pm  view on Meta::CPAN

    [ @$bind, [ { dbd_attrs => undef, dbd_size => 40 }, \$rc ] ],
  );
}


sub update {
  my $self = shift;

  local $self->{_ora_lob_update_rowcount};
  my $rv = $self->next::method(@_);

 view release on metacpan or  search on metacpan

lib/DBIO/PostgreSQL/Async/Storage.pm  view on Meta::CPAN

  my $self = shift;
  return $self->_run_crud('insert', $self->_pool_runner, @_);
}


sub update_async {
  my $self = shift;
  return $self->_run_crud('update', $self->_pool_runner, @_);
}

lib/DBIO/PostgreSQL/Async/Storage.pm  view on Meta::CPAN

sub insert {
  my $self = shift;
  return $self->insert_async(@_)->get;
}

sub update {
  my $self = shift;
  return $self->update_async(@_)->get;
}

sub delete {

 view release on metacpan or  search on metacpan

lib/DBIO/Sybase/Storage/ASE.pm  view on Meta::CPAN

  delete @{$updated_cols}{ keys %{ $defaulted || {} } };

  return $updated_cols;
}

sub update {
  my $self = shift;

  # the writer storage is made by _init, at the first connect (karr k67)
  $self->_get_dbh;

 view release on metacpan or  search on metacpan

lib/DBIO/Admin.pm  view on Meta::CPAN

  print ''.ref($resultset).' ID: '.join(',', $obj->id)."\n" if !$self->quiet;
  return $obj;
}


sub update {
  my ($self, $rs, $set, $where) = @_;

  $rs ||= $self->resultset;
  $set ||= $self->set;
  $where ||= $self->where || {};

 view release on metacpan or  search on metacpan

lib/DBIx/Abstract.pm  view on Meta::CPAN

    $self->__logwrite_sql( 1, $sql, @bind_params );
    $self->__mod_query( $sql, @bind_params );
    return $self;
}

sub update {
    my $self = shift;
    my ($table, $fields, $where ) = @_;

    # $table   == Name of table to update
    # $fields  == A reference to a hash of field/value pairs containing the

 view release on metacpan or  search on metacpan

lib/DBIx/ActiveRecord/Arel.pm  view on Meta::CPAN

    my $o = $self->clone;
    $o->{query} = DBIx::ActiveRecord::Arel::Query::Insert->new($self, $hash, $columns);
    $o;
}

sub update {
    my ($self, $hash, $columns) = @_;
    my $o = $self->clone;
    $o->{query} = DBIx::ActiveRecord::Arel::Query::Update->new($self, $hash, $columns);
    $o;
}