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/Indexer/WebService/Solr.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/Solr.pm  view on Meta::CPAN

Will either update or add a document to the index.

=cut

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

    $self->setup_fields( ref $object );

 view release on metacpan or  search on metacpan

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

    }
}

## On update, copy row's new contents to AuditHistory

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

 view release on metacpan or  search on metacpan

lib/DBIx/Class/Objects/Base.pm  view on Meta::CPAN

        my $accessor = class_name_to_private_accessor($parent);
        $self->$accessor( $self->$relationship->result_source );
    }
}

sub update {
    my $self = shift;

    foreach my $attribute ( $self->meta->get_all_attributes ) {
        next
          unless $attribute->does(

 view release on metacpan or  search on metacpan

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

	croak "invalid optimistic_locking_strategy $strategy" unless exists $valid_strategies{$strategy};
	return $class->_opt_locking_strategy_accessor(@args);
}


sub update {
	my $self = shift;
	my $upd = shift;

	# we have to do this ahead of time to make sure our WHERE
	# clause is computed correctly

 view release on metacpan or  search on metacpan

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

	$self->_store_changes( $action, $result, {}, \%column_data );

    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/ResultSet/PhoneticSearch.pm  view on Meta::CPAN

    }

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

sub update_phonetic_columns {
    my ($self) = @_;
    my $i      = 0;
    my $source = $self->result_source;
    foreach my $column ( $source->columns ) {
        $i += $self->update_phonetic_column($column);
    }
    return $i;
}

sub update_phonetic_column {
    my ( $self, $column ) = @_;
    my $source = $self->result_source;
    my $config = $source->column_info($column)->{phonetic_search};
    my $i;
    return 0 unless ($config);

 view release on metacpan or  search on metacpan

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

    my $ret = $class->next::method(@_);
	return $ret;
}

sub update {
    my $self = shift;

	# mark row as dirty
	if ($self->result_source->schema->preview_active() && $self->result_source->can('is_preview_source')) {
		$_[0] = {} unless ref $_[0];

 view release on metacpan or  search on metacpan

lib/DBIx/Class/Result/ExternalAttribute.pm  view on Meta::CPAN

overdefinition of update function

=cut

sub update {
    my ( $self, $rh_fields ) = @_;
    my $klass = ref $self;
    foreach my $rel ( keys %{ $klass->rh_klass_attribute_column } ) {
        foreach my $col ( @{ $klass->rh_klass_attribute_column($rel)->{'columns'} } ) {
            if ( defined $rh_fields->{$col} ) {

 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();