Loads the column information for this tree widget for the given record.
        
        :param      record      | <orb.Table>
                    columnName  | <str>
                    value       | <variant>
973636
def _loadColumns(self, record, columnName, value):
        
        value = unwrapNone(value)
        item = self.findRecordItem(record)
        if item:
            item.updateColumnValue(record.schema().column(columnName),
                                   value,
                                   self.column(columnName))
985436
def emit(self, record):
        
        # if we've already processed this record, ignore it
        if record in self._recordQueue:
            return
        
        name = record.name
        lvl = self.loggerLevel(name)
        
        # don't process this log
        if lvl > record.levelno:
            return
        
        self._recordQueue.insert(0, record)
        self._recordQueue = self._recordQueue[:10]
        
        # emit the change
        super(XLogRecordHandler, self).emit(record)
651952
def setRecord(self, record):
        
        self._record = record
        if record is not None:
            self.loadValues(record.recordValues(autoInflate=True))
        else:
            self.loadValues({})
1176283
def record_value(record, property)
      case record
        when Hash
          record.fetch(property, record[property.field])
        when Resource
          property.get!(record)
      end
    end
410958
def set_value(self, treeiter, column, value):
        

        value = self._convert_value(column, value)
        Gtk.TreeStore.set_value(self, treeiter, column, value)
399412
def _updateColumnValues(self, index, hidden):
        
        if hidden or not self.isVisible():
            return
        
        column = self.columnOf(index)
        if not column in self._loadedColumns:
            self._loadedColumns.add(column)
            
            records = self.collectRecords()
            self.loadColumnsRequested.emit(records, column)
872686
def set_value(self, treeiter, column, value):
        

        value = self._convert_value(column, value)
        Gtk.ListStore.set_value(self, treeiter, column, value)
1026389
def page(record)
      p = @pages.get(record.page_idx, record) || load(record.page_idx, record)
      unless p.uid == record.page_idx
        raise RuntimeError, "Page reference mismatch. Record " +
          "#{record.page_idx} points to page #{p.uid}"
      end

      p
    end
9442
def addRecord(self, record):
        
        if self._destroyed:
            return
        
        if not self.uiRecordBTN.isChecked():
            return
        
        self._queue.append(record)
655875
def db_update_record(self, table_name, column, value):
        
        sql = 'UPDATE {} SET {} = \'{}\''.format(table_name, column, value)
        cur = self.db_conn.cursor()
        cur.execute(sql)
649851
def collectRecords( self, column ):
        
        model   = column.referenceModel()
        if ( not model ):
            return []
        
        records = model.select()
        records.sort()
        return records
1314886
def record(index)
      seek_to_record(index)
      return nil if deleted_record?

      DBF::Record.new(@data.read(record_length), columns, version, @memo)
    end
597635
def db_get_map(self, table, record, column):
        
        val = self.db_get_val(table, record, column)
        assert isinstance(val, dict)
        return val
413276
def convert(cls, record):
        
        if isinstance(record, list):
            return [cls._convert(r) for r in record]
        else:
            return [cls._convert(record)]
992497
protected function getColumnValue($columnName, $record)
    {
        // Set custom column value from the class static method
        if ($methodName = $this->columnManager->isCustomColumn($columnName)) {
            return $this->class::$methodName($record);
        }

        if ($methodName = $this->customisesColumnValue($columnName)) {
            return $record->$methodName();
        }

        if (isRelationColumn($columnName)) {
            return $this->getRelationColumnValue($columnName, $record);
        }

        if ($this->isCarbonInstance($record->$columnName)) {
            return $record->$columnName->format(config('laratables.date_format', 'Y-m-d H:i:s'));
        }

        return $record->$columnName;
    }
41621
def format(self, record):
        

        fields = record.__dict__.copy()

        if isinstance(record.msg, dict):
            fields.update(record.msg)
            fields.pop('msg')
            msg = ""
        else:
            msg = record.getMessage()

        try:
            msg = msg.format(**fields)
        except (KeyError, IndexError, ValueError):
            pass
        except:
            # in case we can not format the msg properly we log it as is instead of crashing
            msg = msg

        if 'msg' in fields:
            fields.pop('msg')

        if 'exc_info' in fields:
            if fields['exc_info']:
                formatted = tb.format_exception(*fields['exc_info'])
                fields['exception'] = formatted
            fields.pop('exc_info')

        if 'exc_text' in fields and not fields['exc_text']:
            fields.pop('exc_text')

        logr = self.defaults.copy()

        logr.update({'@message': msg,
                     '@timestamp': datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%S.%fZ'),
                     '@source_host': self.source_host,
                     '@fields': self._build_fields(logr, fields)})

        return json.dumps(logr, default=self.json_default, cls=self.json_cls)
62059
public void logAddRecord(Rec record, int iSystemID)
    {
        try {
            this.getTable().setProperty(DBParams.SUPRESSREMOTEDBMESSAGES, DBConstants.TRUE);
            this.getTable().getDatabase().setProperty(DBParams.MESSAGES_TO_REMOTE, DBConstants.FALSE);
        
            this.addNew();
            this.getField(AnalysisLog.SYSTEM_ID).setValue(iSystemID);
            this.getField(AnalysisLog.OBJECT_ID).setValue(Debug.getObjectID(record, false));
            this.getField(AnalysisLog.CLASS_NAME).setString(Debug.getClassName(record));
            this.getField(AnalysisLog.DATABASE_NAME).setString(record.getDatabaseName());
            ((DateTimeField)this.getField(AnalysisLog.INIT_TIME)).setValue(DateTimeField.currentTime());
            this.getField(AnalysisLog.RECORD_OWNER).setString(Debug.getClassName(((Record)record).getRecordOwner()));
            this.getField(AnalysisLog.STACK_TRACE).setString(Debug.getStackTrace());
            this.add();
        } catch (DBException ex) {
            ex.printStackTrace();
        }
    }