view release on metacpan or  search on metacpan

DBO2/Record.pm  view on Meta::CPAN

=cut

use Class::MakeMethods::Composite::Inheritable(hook=>'ok_update pre_update post_update'); 

# $record->update_record()
sub update_record {
  my $self = shift;
  my $class = ref( $self ) or croak("Not a class method");
  my $table = $class->demand_table();
  my @flags = $self->ok_update;
  if ( grep { length $_ and ! $_ } @flags ) {

 view release on metacpan or  search on metacpan

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

  return(query($queryStr));
}



sub update { 
  my ($this)   = @_; 
  my $queryStr = ""; 
  my $fieldStr = ""; 
  my $whereStr = ""; 

 view release on metacpan or  search on metacpan

DBSchema.pm  view on Meta::CPAN

Same as sql_update_schema, except actually runs the SQL commands to update
the schema.  Throws a fatal error if any statement fails.

=cut

sub update_schema {
  #my($self, $new, $dbh) = ( shift, shift, _dbh(@_) );
  my($self, $opt, $new, $dbh) = ( shift, _parse_opt(\@_), shift, _dbh(@_) );

  foreach my $statement ( $self->sql_update_schema( $opt, $new, $dbh ) ) {
    $dbh->do( $statement )

 view release on metacpan or  search on metacpan

DBIx/DBStag.pm  view on Meta::CPAN

        $cache->{$valstr} = $insert_h;
    }
    return 1;
}

sub update_cache {
    my $self = shift;
    my $element = shift;
    my $store_hash = shift;
    my $unique_constr = shift;

DBIx/DBStag.pm  view on Meta::CPAN

        trace(0, "PKVAL = $pkval") if $TRACE;
    }
    return $pkval;
}

sub updaterow {
    my $self = shift;
    my ($table, $set, $where) = @_;

    confess("must specify table") unless $table;

 view release on metacpan or  search on metacpan

lib/DBIx/DataModel/Source/Table.pm  view on Meta::CPAN

}




sub update  {
  my $self = shift;

  # prepare datastructures for generating the SQL
  my ($to_set, $where) = $self->_parse_update_args(@_);
  $self->_apply_handlers_for_update($to_set, $where);

 view release on metacpan or  search on metacpan

lib/DBIx/EAV/Entity.pm  view on Meta::CPAN

    # return the number os attrs loaded
    $total;
}

sub update {
    my $self = shift;
    $self->set(@_)->save;
}

sub set {

 view release on metacpan or  search on metacpan

Easy.pm  view on Meta::CPAN

=back

=cut

sub update
  {
	my $self = shift;
	my $table = shift;
	my $conditions = shift;
	my (@columns);

 view release on metacpan or  search on metacpan

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

  } else {
    $self->update( $self->TableName($table) , { sen => $data , where => $where } );
  }
}

sub update {
  my $self  = shift;
  my $table = $self->TableName(shift);
  my $skeel = shift;

  $skeel->{sen} = $self->extra_args($skeel->{sen},@_) if scalar @_ > 0;

 view release on metacpan or  search on metacpan

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

sub last_insert_id {
	my ($self, @args) = @_;
	return $self->{dbh}->last_insert_id(@args);
}

sub update_query {
	my ($self, $table) = @_;
	return DBIx::Foo::UpdateQuery->new($table, $self);
}

1;

 view release on metacpan or  search on metacpan

DBIx/Frame.pm  view on Meta::CPAN

If C<ALLOW_ADMIN> is set, then you may work with fields that are protected
by the C<ADMIN> array.  (This doesn't actually work yet.)

=cut

sub update {
  my ($self, $table, $datahash, $selecthash, $admin ) = @_;
  my $db = _db_or_die($self) || return undef;
  $self->_test_table($table) || $self->set_error("Bad table") &&  return undef;

  my $hash   = $self->_parse_hash($table, $datahash)    || {};

 view release on metacpan or  search on metacpan

lib/DBIx/FullTextSearch/Blob.pm  view on Meta::CPAN

sub delete_document {
	my $self = shift;
	for my $id (@_) { $self->update_document($id, {}); }
}

sub update_document {
	my ($self, $id, $words) = @_;
	my $fts = $self->{'fts'};
	my $dbh = $fts->{'dbh'};
	my $data_table = $fts->{'data_table'};

 view release on metacpan or  search on metacpan

IO/OracleIO.pm  view on Meta::CPAN

    my $crs = $dbh->prepare_cached("SELECT $seq.NEXTVAL FROM DUAL") || return undef;
    $crs->execute() || return undef;
    return (($crs->fetchrow_array)[0]);
}

sub update_hash
{
    my ($self,$update,$key,$date_format,$hint) = @_;
    ref($self) || (warn("\$self not an object"),return undef);
    ref($update) || ($self->_alert("\$update not a hash ref"), return undef);
    %$update || return -1;

 view release on metacpan or  search on metacpan

Perform.pm  view on Meta::CPAN

    }
    $APP->statusbar("Enter row to add.  ESC stores; DEL cancels the add.");
}

# called from button_push with the top-level form.
sub updatemode
{
    my $form = shift;

    return if check_rows_and_advise($form);
    my $subform = $form->getSubform('DBForm');

 view release on metacpan or  search on metacpan

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

=back

=cut

sub update {
    my ($self, $data, $vars, $where, $table, $dbh) = @_;
    my @vars = ($vars ? @$vars : ());

    # object defaults
    if (ref $self) {

 view release on metacpan or  search on metacpan

lib/DBIx/Lite/ResultSet.pm  view on Meta::CPAN

    
    # return a DBIx::Lite::Row object with the inserted values
    return $self->_inflate_row($insert_cols);
}

sub update_sql {
    my $self = shift;
    my $update_cols = shift;
    ref $update_cols eq 'HASH' or croak "update_sql() requires a hashref";
    
    my $update_where = { -and => $self->{where} };

lib/DBIx/Lite/ResultSet.pm  view on Meta::CPAN

        -set    => $update_cols,
        -where  => $update_where,
    );
}

sub update_sth {
    my $self = shift;
    my $update_cols = shift;
    ref $update_cols eq 'HASH' or croak "update_sth() requires a hashref";
    
    my ($sql, @bind) = $self->update_sql($update_cols);
    return $self->{dbix_lite}->dbh->prepare($sql) || undef, @bind;
}

sub update {
    my $self = shift;
    my $update_cols = shift;
    ref $update_cols eq 'HASH' or croak "update() requires a hashref";
    
    my $affected_rows;

 view release on metacpan or  search on metacpan

lib/DBIx/Mint/Table.pm  view on Meta::CPAN

    my @ids = $mint->connector->run( fixup => $sub );
    return wantarray ? @ids : $ids[0][0];
}


sub update {
    # Input:
    # Case 1) a class name, a Mint object, two hash refs 
    # Case 2) a class name, two hash refs
    # Case 3) a blessed object

 view release on metacpan or  search on metacpan

lib/DBIx/MoCo/DataBase.pm  view on Meta::CPAN

    my ($sql, @binds) = $sqla->delete($table,$where);
    $sql =~ /WHERE/io or croak "where is not specified to delete from $table";
    $class->execute($sql,undef,\@binds);
}

sub update {
    my $class = shift;
    my ($table, $args, $where) = @_;
    $where or croak "where is not specified to update $table";
    (ref $where eq 'HASH' && %$where) or croak "where is not specified to update $table";
    my ($sql, @binds) = $sqla->update($table,$args,$where);

 view release on metacpan or  search on metacpan

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

=back

=cut

sub update ## no critic (Subroutines::RequireArgUnpacking)
{
	croak 'The first argument passed must be a hashref'
		if !Data::Validate::Type::is_hashref( $_[1] );

	my ( $self, $data, %args ) = @_;

 view release on metacpan or  search on metacpan

lib/DBIx/NoSQL/Model/Index.pm  view on Meta::CPAN

    }

    return $search;
}

sub update {
    my $self = shift;
    my $key = shift;
    my $target = shift;

    $self->prepare;

 view release on metacpan or  search on metacpan

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

Saves any modified columns to the database.

=cut

sub update {
    my $class = shift;
    if (ref $class) {
        $class->_do_update;
    } else {
        my ($fieldvals, $where) = @_;

 view release on metacpan or  search on metacpan

lib/DBIx/ObjectMapper/Engine.pm  view on Meta::CPAN

sub get_column_info          { }
sub get_unique_key           { }
sub get_tables               { }
sub select                   { }
sub select_single            { }
sub update                   { }
sub insert                   { }
sub create                   { }
sub delete                   { }
sub iterator                 { }

 view release on metacpan or  search on metacpan

PDlib.pm  view on Meta::CPAN

		carp "Unable to execute insert handle at line $line in file $file package $pkg\n";
		return;
	}
}

sub update
{
	my ($pkg,$file,$line) = caller;

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

 view release on metacpan or  search on metacpan

Perform.pm  view on Meta::CPAN

    my $subform = shift;
    addmode(@_);
    $subform->setField( 'FOCUSED', 'DBForm' );
}

sub updatemode {
    my $form = $GlobalUi->get_current_form;

#    $GlobalUi->update_info_message( $form, 'update' );
    return if check_rows_and_advise($form);

Perform.pm  view on Meta::CPAN

        my $w = $subform->getWidget($ft);
        next unless $col;
    }
}

sub updatemode_resume {
    my ($form) = @_;
    updatemode(@_);
    $form->setField( 'FOCUSED', 'DBForm' );
}

 view release on metacpan or  search on metacpan

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

		}
	}
}

# XXX refactor update/delete into a single implemention if possible?
sub update
{
	my ($moi, $sub) = @_;
	my $me = ref $moi ? $moi : {};

	my $dbh = $me->{dbh};

 view release on metacpan or  search on metacpan

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

        $sth->run;
        return $self;
    }

    sub update {
        my ( $self, $table_name, $params, $where, $attr, $cache_type ) = @_;

        my ( $sql, @variables ) = $self->_param('sql_abstract')->update( $table_name, $params, $where );
        my $sth = $self->sql( $sql, $attr, $cache_type, \@variables );

 view release on metacpan or  search on metacpan

lib/DBIx/QuickORM/Connection.pm  view on Meta::CPAN

sub by_id   { my $arg = pop; shift->handle(@_)->by_id($arg) }
sub iterate { my $arg = pop; shift->handle(@_)->iterate($arg) }
sub insert  { my $arg = pop; shift->handle(@_)->insert($arg) }
sub vivify  { my $arg = pop; shift->handle(@_)->vivify($arg) }
sub update  { my $arg = pop; shift->handle(@_)->update($arg) }

sub update_or_insert { my $arg = pop; shift->handle(@_)->update_or_insert($arg) }
sub find_or_insert   { my $arg = pop; shift->handle(@_)->update_or_insert($arg) }

sub by_ids {
    my $self = shift;
    my ($from, @ids) = @_;

 view release on metacpan or  search on metacpan

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

Note we do not ecnrypt age because it is most likely stored as an integer in the database.

=cut

sub update {
	my $self = shift;
	my $params = $self->_params(@_);

	croak "href and table are required for update" unless $params->{href} and $params->{table};

 view release on metacpan or  search on metacpan

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

Creates and executes an UPDATE statement.

=cut

sub update {
    my ($self, $fields) = @_;
    my ($sql, @bind) = $self->abstract->update( $self->table(), $fields, $self->where() );
    $self->_dbi_execute( 'do', $sql, \@bind );
    return;
}

 view release on metacpan or  search on metacpan

Roles/SQLAbstract.pm  view on Meta::CPAN

	my $sth = $self-> prepare( $query);
	$sth-> execute( @bindval) if $sth;
	return $sth;
}

sub update 
{ 
	my ( $self, $sql) = @_;
	my ( $query, @bindval) = abstract('update', @_);
	$self-> do( $query, {}, @bindval);
}

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

        $examples =~ s/\r\n/\n/g;
        update_file( $example_file, $examples );
    };
};

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