Returns the record editor from the set for the given table type.
        
        :param      tableType | <subclass of orb.Table> || None
        
        :return     <subclass of XOrbRecordWidget> || None
324582
def recordEditor(self, tableType=None):
        
        if tableType == None:
            tableType = self.tableType()
        
        return self._recordEditors.get(tableType, None)
108933
def get_editor(self):
		
		env_search = ['EDITOR']
		if 'xml' in self.content_type:
			env_search.insert(0, 'XML_EDITOR')
		default_editor = self.platform_default_editors[sys.platform]
		return self._search_env(env_search) or default_editor
448232
private BaseTable getPhysicalTable(PassThruTable table, Record record)
    {
    	BaseTable altTable = table.getNextTable();
		if (altTable instanceof PassThruTable)
		{
			BaseTable physicalTable = getPhysicalTable((PassThruTable)altTable, record);
			if (physicalTable != null)
				if (physicalTable != altTable)
					return physicalTable;
		}
		else
			if (altTable.getDatabase().getDatabaseName(true).equals(record.getTable().getDatabase().getDatabaseName(true)))
				return altTable;
    	
    	Iterator<BaseTable> tables = table.getTables();
    	while (tables.hasNext())
    	{
    		altTable = tables.next();
    		if (altTable instanceof PassThruTable)
    		{
    			BaseTable physicalTable = getPhysicalTable((PassThruTable)altTable, record);
    			if (physicalTable != null)
    				if (physicalTable != altTable)
    					return physicalTable;
    		}
    		else 
    			if (altTable.getDatabase().getDatabaseName(true).equals(record.getTable().getDatabase().getDatabaseName(true)))
    				return altTable;
    	}
    	return table;
    }
270115
public static char getPDBTypeFromDBType(int iDatabaseType)
    {
        char strPDBType = ThinPhysicalDatabase.MEMORY_TYPE;
        if ((iDatabaseType & Constants.MAPPED) != 0)
            ;
        iDatabaseType = iDatabaseType & Constants.TABLE_TYPE_MASK;
        if (iDatabaseType == Constants.LOCAL)
            strPDBType = ThinPhysicalDatabase.NET_TYPE;  // Never asked
        if (iDatabaseType == Constants.REMOTE)
            strPDBType = ThinPhysicalDatabase.NET_TYPE;  // Never asked
        if (iDatabaseType == Constants.TABLE)
            strPDBType = ThinPhysicalDatabase.NET_TYPE;
        return strPDBType;
    }
62180
def refreshRecords( self ):
        
        table_type = self.tableType()
        if ( not table_type ):
            self._records = RecordSet()
            return False
        
        search = nativestring(self.uiSearchTXT.text())
        
        query = self.query().copy()
        terms, search_query = Q.fromSearch(search)
        
        if ( search_query ):
            query &= search_query
        
        self._records = table_type.select(where = query).search(terms)
        return True
550942
def tableType( self ):
        
        if not self._tableType:
            if self._tableTypeName:
                self._tableType = Orb.instance().model(nstr(self._tableTypeName))
            
        return self._tableType
798911
def setTableType( self, tableType ):
        
        self._tableType     = tableType
        
        if tableType:
            self._tableTypeName = tableType.schema().name()
        else:
            self._tableTypeName = ''
167575
def prj_view_atype(self, *args, **kwargs):
        
        if not self.cur_prj:
            return
        i = self.prj_atype_tablev.currentIndex()
        item = i.internalPointer()
        if item:
            atype = item.internal_data()
            self.view_atype(atype)
1137891
def get(self,table, sys_id):
        
        result = self.table_api_get(table, sys_id)
        return self.to_record(result, table)
393162
def get_orm_classes_by_table_name_from_base(base: Type) -> Dict[str, Type]:
    
    # noinspection PyUnresolvedReferences
    return {cls.__tablename__: cls for cls in gen_orm_classes_from_base(base)}
625517
def setRecord( self, record ):
        
        super(XBasicCardWidget, self).setRecord(record)
        
        browser = self.browserWidget()
        if ( not browser ):
            return
        
        factory = browser.factory()
        if ( not factory ):
            return
        
        self._thumbnailButton.setIcon(factory.thumbnail(record))
        self._titleLabel.setText(factory.thumbnailText(record))
647822
def _get_table_schema_hack(cursor, table):
    
    # get the schema of the query result via a LIMIT 0 hack
    cursor.execute('SELECT * FROM %s LIMIT 0' % table)
    schema = [tup[:2] for tup in cursor.description]
    cursor.fetchall()  # resets the state of the cursor and closes operation
    return schema
110138
def get(self,table, sys_id):
        
        record = self.api.get(table, sys_id)
        return record
595497
@Override
    public ResultSet getTableTypes() throws SQLException
    {
        checkClosed();
        VoltTable vtable = new VoltTable(new ColumnInfo("TABLE_TYPE", VoltType.STRING));
        for (String type : tableTypes) {
            vtable.addRow(type);
        }
        JDBC4ResultSet res = new JDBC4ResultSet(this.sysCatalog, vtable);
        return res;
    }
1339168
def table_driven(self, in_data):
        
        # If the input data is a string, convert to bytes.
        if isinstance(in_data, str):
            in_data = [ord(c) for c in in_data]

        tbl = self.gen_table()

        register = self.DirectInit << self.CrcShift
        if not self.ReflectIn:
            for octet in in_data:
                tblidx = ((register >> (self.Width - self.TableIdxWidth + self.CrcShift)) ^ octet) & 0xff
                register = ((register << (self.TableIdxWidth - self.CrcShift)) ^ tbl[tblidx]) & (self.Mask << self.CrcShift)
            register = register >> self.CrcShift
        else:
            register = self.reflect(register, self.Width + self.CrcShift) << self.CrcShift
            for octet in in_data:
                tblidx = ((register >> self.CrcShift) ^ octet) & 0xff
                register = ((register >> self.TableIdxWidth) ^ tbl[tblidx]) & (self.Mask << self.CrcShift)
            register = self.reflect(register, self.Width + self.CrcShift) & self.Mask

        if self.ReflectOut:
            register = self.reflect(register, self.Width)
        return register ^ self.XorOut
4372
def columnOptions( self, tableType ):
        
        if ( not tableType ):
            return []
        
        schema = tableType.schema()
        return map(lambda x: x.name(), schema.columns())
272426
def record_prefix(required_type, factory):
    
    field = record_type(required_type)
    field += factory.get_rule('transaction_sequence_n')
    field += factory.get_rule('record_sequence_n')

    # field.leaveWhitespace()

    return field