Update the filtering data for each row if needed (by invalidation or first run)
496546
function _fnFilterData ( settings )
	{
		var columns = settings.aoColumns;
		var column;
		var i, j, ien, jen, filterData, cellData, row;
		var fomatters = DataTable.ext.type.search;
		var wasInvalidated = false;
	
		for ( i=0, ien=settings.aoData.length ; i<ien ; i++ ) {
			row = settings.aoData[i];
	
			if ( ! row._aFilterData ) {
				filterData = [];
	
				for ( j=0, jen=columns.length ; j<jen ; j++ ) {
					column = columns[j];
	
					if ( column.bSearchable ) {
						cellData = _fnGetCellData( settings, i, j, 'filter' );
	
						cellData = fomatters[ column.sType ] ?
							fomatters[ column.sType ]( cellData ) :
							cellData !== null ?
								cellData :
								'';
					}
					else {
						cellData = '';
					}
	
					// If it looks like there is an HTML entity in the string,
					// attempt to decode it so sorting works as expected. Note that
					// we could use a single line of jQuery to do this, but the DOM
					// method used here is much faster http://jsperf.com/html-decode
					if ( cellData.indexOf && cellData.indexOf('&') !== -1 ) {
						__filter_div.innerHTML = cellData;
						cellData = __filter_div_textContent ?
							__filter_div.textContent :
							__filter_div.innerText;
						cellData = cellData.replace(/[\r\n]/g, '');
					}
	
					filterData.push( cellData );
				}
	
				row._aFilterData = filterData;
				row._sFilterRow = filterData.join('  ');
				wasInvalidated = true;
			}
		}
	
		return wasInvalidated;
	}
1046514
private void newFilter() {
        RowFilter<MyTableModel, Object> rf = null;
        //If current expression doesn't parse, don't update.
        try {
            rf = RowFilter.regexFilter(filterText.getText(), 0);
        } catch (java.util.regex.PatternSyntaxException e) {
            return;
        }
        sorter.setRowFilter(rf);
    }
359034
def _upsert(context, params, data):
    """"""
    table = params.get("table")
    table = datastore.get_table(table, primary_id=False)
    unique_keys = ensure_list(params.get("unique"))
    data["__last_seen"] = datetime.datetime.utcnow()
    if len(unique_keys):
        updated = table.update(data, unique_keys, return_count=True)
        if updated:
            return
    data["__first_seen"] = data["__last_seen"]
    table.insert(data)
694666
private void updateValue() {
        if (table != null) {
            int oldCount = this.count;
            this.count = table.getSelectedRowCount();
            maybeNotifyListeners(oldCount, count);
        }
    }
1268825
def _filter_rows(self, rows):
        """"""
        filtered_rows = []
        for row in rows:
            filtered_row = []
            for idx, name in enumerate(self.columns.keys()):
                if name in self.visible_columns:
                    filtered_row.append(row[idx])
            filtered_rows.append(filtered_row)
        return filtered_rows
599907
def perform_update(self, data, instance):
        

        for key, val in data.items():
            setattr(instance, key, val)
833947
def flush(self):
        
        if len(self.rows) != 0:
            self.table.mutate_rows(self.rows)
            self.total_mutation_count = 0
            self.total_size = 0
            self.rows = []
813332
def update(self, data_set):
        
        now = time.time()
        for d in data_set:
            self.timed_data[d] = now
        self._expire_data()
301736
def update(self, rows):
        
        if len(rows) == 0:
            return

        sql, sql_args = self.get_update_sql(rows)

        # get the cursor to execute the query
        cursor = self.get_cursor()

        # execute the query
        cursor.execute(sql, sql_args)
636988
def refresh(self, fields=None, **kwargs):
        
        cond = self.c[self._primary_field]==self._key
        query = self.filter(cond, **kwargs)
        if not fields:
            fields = list(self.table.c)
        
        v = query.values_one(*fields)
        if not v:
            raise NotFound('Instance <{0}:{1}> can not be found'.format(self.tablename, self._key))
        
        d = self._data_prepare(v.items())
        self.update(**d)
        self.set_saved()
895946
def update_with(self, **query):
        
        for k, v in self._filter_attrs(query).items():
            setattr(self, k, v)
        return self.save()
786923
void onCategorySelected(String columnId, int row) {
        Integer maxSelections = displayerSettings.isFilterSelfApplyEnabled() ? null : dataSet.getRowCount();
        filterUpdate(columnId, row, maxSelections);

        // Update the displayer in order to reflect the current selection
        // (only if not has already been redrawn in the previous filterUpdate() call)
        if (!displayerSettings.isFilterSelfApplyEnabled()) {
            updateVisualization();
        }
    }
57892
public final function reset(): void
    {
        // reset data
        $this->data = [];
        // reset properties
        $this->ids = [];
        $this->rowsCount = 0;
        $this->rowsAffected = 0;
    }
1137874
function onFetching(model, columns, options) {
        if (options.forUpdate && options.transacting) {
            options.query.forUpdate();
        }
    }
935399
private void updateResultSetCurrentLine(ResultSet rs, QueryParameters params) throws SQLException {
        Object value = null;
        Object prevValue = null;

        int columnIndex = -1;
        boolean readOnly = false;
        QueryParameters prevParams = get(this.currentIndex);
        ResultSetMetaData rsmd = rs.getMetaData();

        QueryParameters processedParams = typeHandler.processInput(stmt, params);

        for (String parameterName : processedParams.keySet()) {
            value = processedParams.getValue(parameterName);
            prevValue = prevParams.getValue(parameterName);

            // no need to update value if it is the same
            if (value == prevValue || (value != null && prevValue != null && value.equals(prevValue) == true)) {
                continue;
            }

            columnIndex = rs.findColumn(parameterName);
            readOnly = rsmd.isReadOnly(columnIndex) || rsmd.isAutoIncrement(columnIndex);

            if (readOnly == false) {
                rs.updateObject(parameterName, value);
            }
        }
    }
264154
def filter_update(self, id, phrase = None, context = None, irreversible = None, whole_word = None, expires_in = None):
        
        id = self.__unpack_id(id)
        params = self.__generate_params(locals(), ['id'])
        url = '/api/v1/filters/{0}'.format(str(id))
        return self.__api_request('PUT', url, params)
783816
def update(self):
        """"""
        expire_time = time.time() - self.max_time
        while self.row_deque and self.time_deque[0] < expire_time:
            self.row_deque.popleft()  # FIFO
            self.time_deque.popleft()