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

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

re defined update to adapt object field before update

=cut

sub update
{
  my $self = shift;
  my $rh_attrs = $_[0];
  if (defined $rh_attrs)
  {

 view release on metacpan or  search on metacpan

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

Update is done only if validate method return true

=cut

sub update {
    my $self = shift;
    if ( my $columns = shift ) {
        $self->set_inflated_columns($columns);
    }
    return $self->_try_next_method( $self->next::can, @_ );

 view release on metacpan or  search on metacpan

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

    my $query = $self->___get_primary_or_unique_key($hash, $attrs);
    my $exists = $self->exists($query);
    $self->create($hash) unless $exists;
}

sub update_or_create {
    my $self = shift;

    return $self->next::method(@_) if (defined wantarray);

    my $attrs = (@_ > 1 && ref $_[$#_] eq 'HASH' ? pop(@_) : {});

 view release on metacpan or  search on metacpan

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

		}
	}
	return $self->next::method(@_);
}
## copy of insert
sub update {
	my $self = shift;
	if (   $self->salted_enabled
		&& $self->is_column_changed( $self->salted_column ) )
	{
		my $salt;

 view release on metacpan or  search on metacpan

lib/DBIx/Class/Row/Slave.pm  view on Meta::CPAN

Throw exception if called via slave C<result_source>s.

=cut

sub update {
    my $self = shift;

    $self->throw_exception(
        "Can't update via result source \"" . $self->result_source->source_name .
        "\". This is slave connection."

 view release on metacpan or  search on metacpan

inc/DBIx/Class/TimeStamp.pm  view on Meta::CPAN

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

sub update {
    my $self = shift;

    my $now  = $self->get_timestamp();
    my %dirty = $self->get_dirty_columns();
    my @columns = @{ $self->__column_timestamp_triggers()->{on_update} };

 view release on metacpan or  search on metacpan

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

    my $row = $schema->...

    my $row2 = update_and_return();

    sub update_and_return {
        my $row = $schema->...
        $row->somefield("HLAGH");
        $row->update();
        return $row;
    }

 view release on metacpan or  search on metacpan

lib/DBIx/Class/Validation/Structure.pm  view on Meta::CPAN

   # Else do the normal insert
      $self->next::method(@_);
   }
}

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

   $self->set_inflated_columns($columns) if $columns;

 view release on metacpan or  search on metacpan

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

=item update

=cut

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

    $self->set_inflated_columns($columns) if $columns;
    $self->validate if $self->validation_auto;

 view release on metacpan or  search on metacpan

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

Overloaded method. L<DBIx::Class::Row/"update">

=cut

sub update {
    my $self = shift;
    my $attr = shift;
 
    # Filter localized values
    my ($virtual_attrs,$main_attrs) = $self->_virtual_filter($attr);

 view release on metacpan or  search on metacpan

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

=item $self->update_from_form($form)

=cut

sub update_from_form {
    my $self = shift;
    die "update_from_form cannot be called as a class method" unless ref $self;
    __PACKAGE__->_run_update( $self, @_ );
}

 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 = @_;

 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 = "";