view release on metacpan or  search on metacpan

lib/DBIx/Class/Wrapper/Factory.pm  view on Meta::CPAN

See L<DBIx::Class::ResultSet/update_or_create>

=cut

sub update_or_create {
    my ($self, $args) = @_;
    my $original = $self->dbic_rs->update_or_create($args);
    return $original ? $self->wrap($original) : undef;
}

 view release on metacpan or  search on metacpan

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

  return  1;

}

#============================================================
sub update {
#============================================================

=head2 update

 Usage     : $cmd->update()

 view release on metacpan or  search on metacpan

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

    $connection->update_lob(lob_test => 'blob_content', $lob_content, {id => 1}, 'doc_size');

=cut

sub update_lob {
    my ($self, $table_name, $lob_column_name, $lob, $primary_key_values, $lob_size_column_name) = @_;
    my $module_name = $self->load_module('SQL');
    if($module_name && $module_name->can('update_lob')) {
        $module_name->update_lob($self, $table_name, $lob_column_name, $lob, $primary_key_values, $lob_size_column_name);
    } else {

 view release on metacpan or  search on metacpan

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

        );
    }
    return 1;
}

sub update_views {
    my $self  = shift;
    my $dbh   = $self->dbh;
    my $views = shift || [];
    my @views = @$views;

 view release on metacpan or  search on metacpan

Cursor.pm  view on Meta::CPAN

    return undef;
  }
}

# ----------------------------------------------------------------------
sub update
{
  my $self = shift;

  my $data  = $self->{data};
  my $odata = $self->{olddata};

 view release on metacpan or  search on metacpan

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

  else {
    $self->execute($sql, $params->[0], %opt);
  }
}

sub update {
  my $self = shift;

  # Options
  my $param = @_ % 2 ? shift : undef;
  my %opt = @_;

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

  
  # Execute query
  $self->execute($sql, $param, %opt);
}

sub update_all { shift->update(@_, allow_update_all => 1) };

sub values_clause {
  my ($self, $param, $opts) = @_;
  
  my $wrap = $opts->{wrap} || {};

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

  
  return $self;
}

# DEPRECATED
sub update_or_insert {

  _deprecate('0.39', "DBIx::Custom::update_or_insert method is DEPRECATED!");

  my ($self, $param, %opt) = @_;
  confess "update_or_insert method need primary_key and id option "

 view release on metacpan or  search on metacpan

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

Returns the number of rows updated or C<'0E0'> for no rows to ensure the value is true,
and returns false if there was an error.

=cut

sub update {
    my $me = shift;
    my @update = $me->{DBO}{dbd_class}->_parse_set($me, @_);
    my $sql = $me->{DBO}{dbd_class}->_build_sql_update($me, @update);
    $me->{DBO}{dbd_class}->_do($me, $sql, undef, $me->{DBO}{dbd_class}->_bind_params_update($me));
}

 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

            -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' );
}