Return a table expression referencing a table in this database

        Returns
        -------
        table : TableExpr
977630
def table(self, name):
        
        qualified_name = self._qualify(name)
        return self.client.table(qualified_name, self.name)
376822
def table(self, table):
        
        return DataFrame.from_spark_rdd(self.sql_ctx.table(table),
                                        self.sql_ctx)
1360533
def get_table(self, name):
        
        response = self.layer1.describe_table(name)
        return Table(self,  response)
357594
def over(self, window):
        
        return GroupedTableExpr(
            self.table,
            self.by,
            having=self._having,
            order_by=self._order_by,
            window=window,
        )
372022
def table table_name
    table = JDBCHelper::TableWrapper.new(self, table_name)
    table = table.fetch_size(@fetch_size) if @fetch_size
    @table_wrappers[table_name] ||= table
  end
277260
def _build_projection_expression(clean_table_keys):
    
    projection_expression = ''
    for key in clean_table_keys[:-1]:
        projection_expression += ('{},').format(key)
    projection_expression += clean_table_keys[-1]
    return projection_expression
928279
private Table getTableStrict(EntityConfig entityConfig) {
        Assert.isTrue(entityConfig.hasTableName(), "A tableName is expected for the entityConfig " + entityConfig.getEntityName());
        Table table = config.getMetadata().getTableBySchemaAndName(entityConfig.getSchemaName(), entityConfig.getTableName());
        Assert.notNull(table, "Could not find table named " + entityConfig.getTableName());
        return table;
    }
605930
def __get_table(self, bucket):
        
        table_name = self.__mapper.convert_bucket(bucket)
        if self.__dbschema:
            table_name = '.'.join((self.__dbschema, table_name))
        return self.__metadata.tables[table_name]
745784
def table_names(self):
        """"""
        query = "SELECT name FROM sqlite_master WHERE type='table'"
        cursor = self.connection.execute(query)
        results = cursor.fetchall()
        return [result_tuple[0] for result_tuple in results]
1303785
def get_tables(self, models):
        '''
        
        '''
        return { obj._meta.db_table : obj for obj in
                models.__dict__.itervalues() if
                isinstance(obj, peewee.BaseModel) and
                len(obj._meta.fields) > 1
            }
474016
def results(self):
    
    self.wait()
    if self.failed:
      raise Exception('Query failed: %s' % str(self.errors))
    return self._table
67082
@Override
    public Object getTable(String tableName) {
	logger.debug("OMID Begin of getTable for " + tableName);
        TTable table = tableNameHandleMap.get(tableName);
        if (table != null) {
            logger.debug("OMIDE Found a cached handle for table " + tableName);
            return table;
        }
        try {
            table = new TTable(this.getHbcfg(), tableName);
        } catch (IOException e) {
            logger.error("OMID Error trying to get a TransactionTable of OMID.");
            logger.error(e.getMessage());
        }
        tableNameHandleMap.put(tableName, table);
        logger.debug("OMID Cached a handle of table: " + tableName);
        return table;
    }
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
179283
def _all_expressions_evaluated(self):
        
        def present(expr):
            return expr.stmt == expr.column and expr.column in self.data
        return all(present(expr) for expr in self.expressions)
1296453
def get_column(self, name):
        
        import ibis.expr.operations as ops

        ref = ops.TableColumn(name, self)
        return ref.to_expr()
1269005
def tables_(self) -> list:
        
        if self._check_db() == False:
            return
        try:
            return self._tables()
        except Exception as e:
            self.err(e, "Can not print tables")
872160
def projection(self, exprs):
        
        w = self._get_window()
        windowed_exprs = []
        exprs = self.table._resolve(exprs)
        for expr in exprs:
            expr = L.windowize_function(expr, w=w)
            windowed_exprs.append(expr)
        return self.table.projection(windowed_exprs)