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/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

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/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

  $self->_insert_blobs ($source, $blob_cols, $final_row) if $blob_cols;

  return $updated_cols;
}

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

  #
  # When *updating* identities, ASE requires SET IDENTITY_UPDATE called

 view release on metacpan or  search on metacpan

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

  my $obj = $resultset->new_result($set)->insert;
  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;
}

 view release on metacpan or  search on metacpan

example/DB/Default.pm  view on Meta::CPAN

                  ($p{include_expired} ? "" : "AND WebItem.date_expires > now()"),
            (@bind ? (bind => \@bind) : ()),
            );
}

sub update_announce {
    my $self = shift;
    my %p = @_;
    
    $p{expires} = $self->sql_date_struct($p{expires});
    $p{live} = $self->sql_date_struct($p{live});

example/DB/Default.pm  view on Meta::CPAN

                    WHERE id = ?",
            bind => [ @p{qw(title link expires live id)} ],
            );
}

sub update_news {
    my $self = shift;
    my %p = @_;
    
    $p{expires} = $self->sql_date_struct($p{expires});
    $p{live} = $self->sql_date_struct($p{live});

example/DB/Default.pm  view on Meta::CPAN

                    WHERE id = ?",
            bind => [ @p{qw(title link expires live id)} ],
            );
}

sub update_event {
    my $self = shift;
    my %p = @_;
    
    $p{expires} = $self->sql_date_struct($p{expires});
    $p{live} = $self->sql_date_struct($p{live});

example/DB/Default.pm  view on Meta::CPAN

                    WHERE id = ?",
            bind => [ @p{qw(title link expires live location booth id)} ],
            );
}

sub update_pr {
    my $self = shift;
    my %p = @_;
    
    $p{expires} = $self->sql_date_struct($p{expires});
    $p{live} = $self->sql_date_struct($p{live});

example/DB/Default.pm  view on Meta::CPAN

                    WHERE id = ?",
            bind => [ @p{qw(title expires live subtitle location body id)} ],
            );
}

sub update_asset_column {
    my $self = shift;
    my ($id, $column, $value) = @_;
    
    $self->do_sql(
                sql => "UPDATE WebItem

example/DB/Default.pm  view on Meta::CPAN

                bind => $id,
                )
            };
}

sub update_user {
    my $self = shift;
    my %p = @_;
    
    if ($p{password}) {
        $p{password_md5} = md5_hex($p{password});

 view release on metacpan or  search on metacpan

Broker.pm  view on Meta::CPAN

    $self->__sql_execute( \@values );
	return $self->{'statement'}->{'mysql_insertid'}  if  ( $self->{'driver'} eq 'mysql' );
}


sub update {
    my $self            =  shift;
    my $table           =  shift;                #   send only one table
    my %new_data        =  %{ shift @_ };
    my $stipulations    =  shift;
    my @fields          =  keys( %new_data );       #   these are promised to be in the same order,

 view release on metacpan or  search on metacpan

Browse.pm  view on Meta::CPAN

}

#
# update: update a row in the main table.
#
sub update {
    my $self  = shift;
    my $rec   = shift;
    my $where = shift;
    my @fields = $self->fields;

 view release on metacpan or  search on metacpan

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

    $future->on_done(sub { say "Batch update complete." });

=cut

sub update {
    my $self = shift;
    my ($cond, $updates);

    # Logic to handle both:
    #   ->update({ col => val })

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

        print "Successfully updated $count specific records.\n";
    });

=cut

sub update_all {
    my ($self, $updates) = @_;
    my $bridge = $self->{_async_db};

    return $self->all->then(sub {
        my $rows = shift;

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

        }
    });

=cut

sub update_or_new {
    my ($self, $data, $attrs) = @_;
    $attrs //= {};

    # Identify the primary key or unique constraint values for the lookup
    my $lookup = $self->_extract_unique_lookup($data, $attrs);

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

        die "Sync failed: " . shift;
    });

=cut

sub update_or_create {
    my ($self, $data, $attrs) = @_;
    $attrs //= {};

    my $lookup = $self->_extract_unique_lookup($data, $attrs);

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

    warn "About to execute: $$sql with binds: @bind";
    $rs->update({ active => 1 })->get;  # Now execute

=cut

sub update_query {
    my ($self, $values) = @_;

    my $bridge       = $self->{_async_db};
    my $schema_class = $bridge->{_schema_class};

 view release on metacpan or  search on metacpan

lib/DBIx/Class/AuditLog.pm  view on Meta::CPAN

    }

    return $result;
}

sub update {
    my $self = shift;

    return $self->next::method(@_) if !$enabled;

    my $stored_row      = $self->get_from_storage;

 view release on metacpan or  search on metacpan

lib/DBIx/Class/BatchUpdate/Batch.pm  view on Meta::CPAN

has pk_column => ( is => "ro", required => 1 );

has ids => ( is => "lazy" );
sub _build_ids { [] }

sub update {
    my $self = shift;
    $self->resultset
        ->search({ $self->pk_column => { -in => $self->ids } })
        ->update( $self->key_value );
}

 view release on metacpan or  search on metacpan

lib/DBIx/Class/BcryptColumn.pm  view on Meta::CPAN

  my $self = shift;
  $self->_bcrypt_set_columns;
  $self->next::method(@_);
}
 
sub update {
  my ($self, $upd, @rest) = @_;
  if (ref $upd) {
    my @columns = $self->bcrypt_columns;
    foreach my $column (@columns) {
      next unless exists $upd->{$column};

 view release on metacpan or  search on metacpan

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

  
  return $self->search({ $type => $query });
  
}

sub update {
  my ($self, $data, @rest) = @_;
  my $source = $self->result_source;
  my $row = $self->new_result({});
  while(my ($k, $value) = each %{$data || {}}) {
    my $info = $source->column_info($k);

 view release on metacpan or  search on metacpan

lib/DBIx/Class/CompressColumns.pm  view on Meta::CPAN

=item update

=cut

sub update {
    my ( $self, $upd, @rest ) = @_;
    if ( ref $upd ) {
        for my $col ( @{$self->compress_auto_columns} ) {
			$upd->{$col} = compress($upd->{$col},9) if ( exists $upd->{$col} );
        }

 view release on metacpan or  search on metacpan

lib/DBIx/Class/DigestColumns.pm  view on Meta::CPAN

=item update

=cut

sub update {
    my ( $self, $upd, @rest ) = @_;
    if ( ref $upd ) {
        for my $col ( @{$self->digest_auto_columns} ) {
	    $self->set_column($col => delete $upd->{$col}) 
		if ( exists $upd->{$col} );

 view release on metacpan or  search on metacpan

lib/DBIx/Class/DynamicDefault.pm  view on Meta::CPAN

    }

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

sub update {
    my ($self, $upd) = @_;

    $self->set_inflated_columns($upd) if $upd;
    my %dirty = $self->get_dirty_columns;

 view release on metacpan or  search on metacpan

lib/DBIx/Class/Events.pm  view on Meta::CPAN

    $self->event( insert => { details => \%inserted } );

    return $self;
};

sub update {
    my ( $self, @args ) = @_;

    # Do this here instead of letting our parent do it
    # so that we can use get_dirty_columns.
    $self->set_inflated_columns(@args) if @args;

 view release on metacpan or  search on metacpan

lib/DBIx/Class/FromSledge.pm  view on Meta::CPAN

    }

    return $rs->create($cols);
}

sub update_from_sledge {
    my ($self, $page, $args) = @_;
    croak "error detected at validator" if $page->valid->is_error;

    for my $col ($self->result_source->columns) {
        if ($page->valid->{PLAN}->{$col}) {

 view release on metacpan or  search on metacpan

lib/DBIx/Class/FromValidators.pm  view on Meta::CPAN

        return $self->create($cols);
    }
}

sub update_from_fv {
    my ($self, $results, $args) = @_;
    croak "pass me a form results object" unless blessed($results);
    croak "pass me a object which can call 'success' and 'valid'"
        unless $results->can('success') and $results->can('valid');
    croak "has error on form" unless $results->success;

 view release on metacpan or  search on metacpan

lib/DBIx/Class/FrozenColumns.pm  view on Meta::CPAN

=head2 update

=cut

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

 view release on metacpan or  search on metacpan

lib/DBIx/Class/Helper/ResultSet/DateMethods1.pm  view on Meta::CPAN

      if $self->_resolved_attrs->{_DBICH_DM1};

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

sub update {
   my $self = shift;

   $self = $self->as_subselect_rs
      if $self->_resolved_attrs->{_DBICH_DM1};

 view release on metacpan or  search on metacpan

lib/DBIx/Class/I18NColumns.pm  view on Meta::CPAN

=head2 update

Overloaded L<DBIx::Class::Row/update> to manage i18n columns cleanly. 

=cut
sub update {
    my $self = shift;

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

    if ( $self->_i18n_column_row ) {

 view release on metacpan or  search on metacpan

lib/DBIx/Class/Indexed.pm  view on Meta::CPAN

Sends the object to the indexer's C<update> method, if C<index_on_update> is true.

=cut

sub update {
    my $self   = shift;
    my $result = $self->next::method( @_ );
    
    if ( $self->index_on_update and my $indexer = $self->indexer ) {
        $indexer->update( $self, @_ );

 view release on metacpan or  search on metacpan

lib/DBIx/Class/Indexer/WebService/Dezi.pm  view on Meta::CPAN

Handles the insert operation.

=cut

sub update_or_create_document {
    my $self   = shift;
    my $object = shift;

    $self->setup_fields( ref $object );
    $self->_dezi->index( $self->as_document( $object ), $object->id, $self->content_type );

lib/DBIx/Class/Indexer/WebService/Dezi.pm  view on Meta::CPAN

Handles the update operation.

=cut

sub update {
    my $self   = shift;
    my $object = shift;
    return if $self->disabled;
    
    $self->update_or_create_document( $object );

 view release on metacpan or  search on metacpan

lib/DBIx/Class/Indexer/WebService/Lucene.pm  view on Meta::CPAN

Calls C<update_or_create_document>.

=cut

sub update {
    my $self   = shift;
    my $object = shift;
    
    $self->update_or_create_document( $object );
}

lib/DBIx/Class/Indexer/WebService/Lucene.pm  view on Meta::CPAN

Will either update or add a document to the index, depending
on its existence in the index.

=cut

sub update_or_create_document {
    my $self   = shift;
    my $object = shift;
    my $index  = $self->_obj;

    $self->setup_fields( ref $object );

 view release on metacpan or  search on metacpan

lib/DBIx/Class/Admin.pm  view on Meta::CPAN

update takes the name of a resultset from the schema_class, a hashref of data to update and
a where hash used to form the search for the rows to update.

=cut

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

  $rs ||= $self->resultset();
  $where ||= $self->where();
  $set ||= $self->set();