Ensures that rows with errors will be placed at the top of the table.<p>
190096
public void sortByErrors() {

        ColumnSortList columnSort = m_table.getColumnSortList();
        columnSort.clear();
        columnSort.push(m_table.getErrorColumn());
        columnSort.push(m_table.getErrorColumn());
        ColumnSortEvent.fire(m_table, columnSort);
    }
806333
void validate(TableKelp table)
  {
    if (! table.isValidate()) {
      return;
    }
    
    Row row = table.row();
    
    for (BlockLeaf block : _blocks) {
      block.validateBlock(row);
    }
  }
1317281
public void moveUp(I_CmsEditableGroupRow row) {

        int index = m_container.getComponentIndex(row);
        if (index > 0) {
            m_container.removeComponent(row);
            m_container.addComponent(row, index - 1);
        }
        updateButtonBars();
    }
817054
function putRow() {
    var putParams = {
        tableName: tableName,
        condition: new TableStore.Condition(TableStore.RowExistenceExpectation.IGNORE, null),
        primaryKey: [
            { pk1: 'pk1' },
            { pk2: TableStore.PK_AUTO_INCR }
        ],
        attributeColumns: [
            { 'col1': 'col1val' }
        ],
        returnContent: { returnType: TableStore.ReturnType.Primarykey }
    };

    client.putRow(putParams, function (err, data) {
        if (err) {
            console.log('error:', err);
            return;
        }

        console.log('put row success,autoIncrement pk value:' + JSON.stringify(data.row.primaryKey));
    });

}
1308022
def ensure_hbounds(self):
        """"""
        self.cursor.x = min(max(0, self.cursor.x), self.columns - 1)
882692
private void updateGroupValidation() {

        boolean hasError = false;
        for (I_CmsEditableGroupRow row : getRows()) {
            if (hasError(row.getComponent())) {
                hasError = true;
                break;
            }
        }
        setErrorVisible(hasError);
    }
952763
protected function checkColumnsValidity(): void
    {
        $this->getAttribute('columns')->map(function (TableListColumn $column) {
            $this->checkSortableColumnHasAttribute($column);
            $isSearchable = in_array(
                $column->getAttribute('attribute'),
                $this->getAttribute('searchableColumns')->pluck('attribute')->toArray()
            );
            if ($isSearchable) {
                $this->checkSearchableColumnHasAttribute($column);
                $this->checkSearchedAttributeDoesExistInRelatedTable($column);
            }
        });
    }
613173
protected void missingRow( Example row )
    {
        Example firstChild = row.firstChild();

        firstChild.annotate( Annotations.missing() );
        stats.wrong();

        if (firstChild.hasSibling())
        {
            for (Example cell : firstChild.nextSibling())
            {
                cell.annotate( Annotations.missing() );
            }
        }
    }
1331733
public void clearErrors() {

        if ((getAliasError() != null) || (getPathError() != null)) {
            // ensure rows with errors are updated correctly
            m_isChanged = true;
        }
        m_pathError = null;
        m_aliasError = null;
    }
147363
def set_row_height(self, row, height):
        """"""

        # Mark content as changed
        post_command_event(self.main_window, self.ContentChangedMsg)

        tab = self.grid.current_table

        self.code_array.set_row_height(row, tab, height)
        self.grid.SetRowSize(row, height)
1012845
public function beforeValidate()
    {
        if ($this->owner->getIsNewRecord()) {
            // added new record always on top
            $this->owner->{$this->sortAttribute} = $this->owner->find()->andWhere($this->getCondition())->count();
        } else {
            // prevent direct change of sort field
            $this->owner->{$this->sortAttribute} = $this->owner->getOldAttribute($this->sortAttribute);
        }
    }
306587
private function validate()
    {
        if (!$this->table) {
            throw new BatchInsertException('Batch Table must be defined');
        }

        $requiredCount = count($this->rows);

        if ($requiredCount == 0) {
            throw new BatchInsertException('Batch Rows cannot be empty');
        }

        foreach ($this->values as $value) {
            if (count($value) !== $requiredCount) {
                throw new BatchInsertException('Batch Values must match the same column count of ' . $requiredCount);
            }
        }
    }
37143
@Override
	public void tableUpdated() {
		super.tableUpdated();
		synchronized(unsortedRowsCacheLock) {
			unsortedRowsCache = null;
		}
		synchronized(sortedRowsCacheLock) {
			sortedRowsCache = null;
		}
		synchronized(rowCacheLock) {
			rowCacheLoaded = false;
			rowCache.clear();
		}
	}
716020
protected void validateNew(final CmsAliasTableRow newEntry) {

        CmsRpcAction<CmsAliasEditValidationReply> action = new CmsRpcAction<CmsAliasEditValidationReply>() {

            @Override
            public void execute() {

                start(200, true);
                CmsAliasEditValidationRequest validationRequest = new CmsAliasEditValidationRequest();
                List<CmsAliasTableRow> rows = m_view.getLiveData();
                validationRequest.setEditedData(rows);
                validationRequest.setNewEntry(newEntry);
                validationRequest.setOriginalData(m_initialData);
                getService().validateAliases(validationRequest, this);
            }

            @Override
            public void onResponse(CmsAliasEditValidationReply result) {

                stop(false);
                List<CmsAliasTableRow> tableRows = result.getChangedRows();
                CmsAliasTableRow validatedNewEntry = result.getValidatedNewEntry();
                if (validatedNewEntry.hasErrors()) {
                    m_view.setNewAliasPathError(validatedNewEntry.getAliasError());
                    m_view.setNewAliasResourceError(validatedNewEntry.getPathError());
                } else {
                    m_view.clearNew();
                    tableRows.add(validatedNewEntry);
                }
                m_view.update(tableRows);
                updateValidationStatus();
            }
        };
        action.execute();
    }
129597
private void ensureTableIfNecessary(ClassDescriptorDef classDef, String checkLevel)
    {
        if (classDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_OJB_PERSISTENT, false))
        {
            if (!classDef.hasProperty(PropertyHelper.OJB_PROPERTY_TABLE))
            {
                classDef.setProperty(PropertyHelper.OJB_PROPERTY_TABLE, classDef.getDefaultTableName());
            }
        }
    }
182672
public void addRowAfter(I_CmsEditableGroupRow row) {

        int index = m_container.getComponentIndex(row);
        if (index >= 0) {
            Component component = m_newComponentFactory.get();
            I_CmsEditableGroupRow newRow = m_rowBuilder.buildRow(this, component);
            m_container.addComponent(newRow, index + 1);
        }
        updatePlaceholder();
        updateButtonBars();
        updateGroupValidation();
    }
522182
protected void preInitRuleTable(final int row,
            final int column,
            final String value) {
        this.ruleTableColumn = column;
        this.ruleTableRow = row;
        this.isInRuleTable = true;
        this._currentAgendaGroup  = getProperties().getSingleProperty( AGENDAGROUP_TAG );
        this._action              = getProperties().getSingleProperty( ACTION_TAG );
        this._horizontalCondition = getProperties().getSingleProperty( HORIZONTALCONDITION_TAG );
        this._verticalCondition   = getProperties().getSingleProperty( VERTICALCONDITION_TAG );
        String precondition       = getProperties().getSingleProperty( PRECONDITION_TAG );
        if ( precondition != null ) {
            this._currentPrecondition = new Condition();
            this._currentPrecondition.setSnippet( precondition );
        }
    }