Returns the table type for this instance.
        
        :return     <subclass of orb.Table> || None
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 = ''
901709
def _extract_table_type(type):
    
    if isinstance(type, str):
        type = type.lower()
        if type[0:7] == 'binary':
            table_type = BINARY_TBL
        elif type[0:6] == 'ascii':
            table_type = ASCII_TBL
        else:
            raise ValueError(
                "table type string should begin with 'binary' or 'ascii' "
                "(case insensitive)")
    else:
        type = int(type)
        if type not in [BINARY_TBL, ASCII_TBL]:
            raise ValueError(
                "table type num should be BINARY_TBL (%d) or "
                "ASCII_TBL (%d)" % (BINARY_TBL, ASCII_TBL))
        table_type = type

    return table_type
469263
public int getDatabaseType()
    {
        // ****Override this****, If not, try to figure it out
        if (m_vRecordList != null)
            if (this.getRecordlistAt(0) != null)
                return this.getRecordlistAt(0).getDatabaseType() & DBConstants.TABLE_MASK;  // Only type and location
        return super.getDatabaseType(); // LOCAL
    }
1002109
String getJDBCStandardType() {

        switch (table.getTableType()) {

            case TableBase.VIEW_TABLE :
                return "VIEW";

            case TableBase.TEMP_TABLE :
            case TableBase.TEMP_TEXT_TABLE :
                return "GLOBAL TEMPORARY";

            case TableBase.SYSTEM_TABLE :
                return "SYSTEM TABLE";

            default :
                return "TABLE";
        }
    }
199991
def values(self):
        
        return [getattr(self, c.name, None) for c in self.__table__._columns]
229764
def table(self, name, database=None):
        
        qualified_name = self._fully_qualified_name(name, database)
        schema = self._get_table_schema(qualified_name)
        node = self.table_class(qualified_name, schema, self)
        return self.table_expr_class(node)
587013
def get_rtc_table(self):
        
        rtc_table = self._global_tables.get(RF_RTC_UC)
        # Lazy initialization of the table.
        if not rtc_table:
            rtc_table = RtcTable(self._core_service, self._signal_bus)
            self._global_tables[RF_RTC_UC] = rtc_table
            self._tables[(None, RF_RTC_UC)] = rtc_table
        return rtc_table
545022
public boolean setTableType(Session session, int newType) {

        int currentType = table.getTableType();

        if (currentType == newType) {
            return false;
        }

        switch (newType) {

            case TableBase.CACHED_TABLE :
                break;

            case TableBase.MEMORY_TABLE :
                break;

            default :
                return false;
        }

        Table tn;

        try {
            tn = table.moveDefinition(session, newType, null, null, null, -1,
                                      0, emptySet, emptySet);

            tn.moveData(session, table, -1, 0);
            updateConstraints(tn, emptySet);
        } catch (HsqlException e) {
            return false;
        }

        setNewTableInSchema(tn);
        database.persistentStoreCollection.releaseStore(table);

        table = tn;

        database.schemaManager.recompileDependentObjects(table);

        return true;
    }
1368190
public function getTablePrototype()
    {
        if ($this->tablePrototype === NULL) {
            $this->tablePrototype = \Nette\Utils\Html::el('table');
            $this->tablePrototype->id($this->getName());
        }

        return $this->tablePrototype;
    }
74142
def setTableType(self, tableType):
        
        if tableType == self._tableType:
            return
        
        # clear all the information
        blocked = self.signalsBlocked()
        
        self.blockAllSignals(True)
        
        # only clear if necessary
        if self._tableType:
            self.clearAll()
        
        # update the table type data
        self._tableType = tableType
        
        if tableType:
            self._tableTypeName = tableType.__name__
        else:
            self._tableTypeName = ''
            
        self.initializeColumns()
        self.blockAllSignals(blocked)
        
        if not self.signalsBlocked():
            self.tableTypeChanged.emit()
            self.recordsChanged.emit()
481849
def get_atom_coltype(self, kind=None):
        
        if kind is None:
            kind = self.kind
        if self.kind.startswith('uint'):
            col_name = "UInt{name}Col".format(name=kind[4:])
        else:
            col_name = "{name}Col".format(name=kind.capitalize())

        return getattr(_tables(), col_name)
1112509
def table_definitions(self):
        
        prop = self._get_sub_prop("tableDefinitions")
        if prop is not None:
            prop = _from_api_repr_table_defs(prop)
        return prop
947892
def database(self):
        
        if self._database:
            return self._database
        if self._recordSet is not None:
            return self._recordSet.database()
        else:
            return Orb.instance().database()
626620
def elem_type(self):
        
        if not hasattr(self, "_elem_type"):
            self._elem_type = get_elem_type(self.elem)
        return self._elem_type
842347
def get_table(self, table):
        
        path = '/archive/{}/tables/{}'.format(self._instance, table)
        response = self._client.get_proto(path=path)
        message = archive_pb2.TableInfo()
        message.ParseFromString(response.content)
        return Table(message)
1314192
def target_Orange_table(self):
        '''
        
        '''
        table, cls_att = self.db.target_table, self.db.target_att
        if not self.db.orng_tables:
            return self.convert_table(table, cls_att=cls_att)
        else:
            return self.db.orng_tables[table]