Get the column listing for a given table.

        :param table: The table
        :type table: str

        :rtype: list
555474
def get_column_listing(self, table):
        
        table = self._connection.get_table_prefix() + table

        results = self._connection.select(self._grammar.compile_column_exists(table))

        return self._connection.get_post_processor().process_column_listing(results)
474521
def lists(self, column, key=None):
        
        columns = self._get_list_select(column, key)

        if key is not None:
            results = {}
            for result in self.get(columns):
                results[result[key]] = result[column]
        else:
            results = Collection(list(map(lambda x: x[column], self.get(columns))))

        return results
64094
def get_column_definition(self, table, column):
        """"""
        # Parse column definitions for match
        for col in self.get_column_definition_all(table):
            if col.strip('`').startswith(column):
                return col.strip(',')
264412
def has_column(self, table, column):
        
        column = column.lower()

        return column in list(map(lambda x: x.lower(), self.get_column_listing(table)))
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)
629428
def get_column_names(engine: Engine, tablename: str) -> List[str]:
    
    return [info.name for info in gen_columns_info(engine, tablename)]
1170730
def index(self, column):  # pylint: disable=C6409
        
        for i, key in enumerate(self._keys):
            if key == column:
                return i
        raise ValueError('Column "%s" not found.' % column)
562831
def getall(self, table):
        
        try:
            self._check_db()
        except Exception as e:
            self.err(e, "Can not connect to database")
            return
        if table not in self.db.tables:
            self.warning("The table " + table + " does not exists")
            return
        try:
            res = self.db[table].all()
            df = pd.DataFrame(list(res))
            return df
        except Exception as e:
            self.err(e, "Error retrieving data in table")
261815
def table(self, datatype=None):
        ""
        if config.future_deprecations:
            self.param.warning(
                "The table method is deprecated and should no "
                "longer be used. Instead cast the %s to a "
                "a Table directly." % type(self).__name__)

        if datatype and not isinstance(datatype, list):
            datatype = [datatype]
        from ..element import Table
        return Table(self, **(dict(datatype=datatype) if datatype else {}))
761602
def find_unassigned_table_cell(table):
    
    for row in range(len(table)):
        for column in range(len(table[row])):
            if table[row][column] is None:
                return row, column
    return row, column
1006643
def _columns_for_table(table_name):
    
    return {cname: col
            for (tname, cname), col in _COLUMNS.items()
            if tname == table_name}
199991
def values(self):
        
        return [getattr(self, c.name, None) for c in self.__table__._columns]
545770
def select(self, *columns):
        
        if not columns:
            columns = ["*"]

        self.columns = list(columns)

        return self
1000707
def columns(self):
        
        schema = self.schema()
        return [schema.column(col) for col in self.__columns]
802247
def get_column_value(manager, table, record, column):
    
    row = row_by_name(manager, record, table)
    value = getattr(row, column, "")

    if isinstance(value, list) and len(value) == 1:
        value = value[0]

    return str(value)
590914
def _get_table(self):
        
        data = get_inner_data(self.report)
        labels = data.keys()
        row = [
            data[key]
            for key in labels
        ]
        return list(labels), [row]
349547
public static function listColumn($table) {
		if (is_string($table)) $table = config('center.tables.' . $table);
		$fields = !empty($table->list) ? $table->list : array_keys((array) $table->fields);
		foreach ($fields as $field) {
			if ($table->fields->{$field}->type == 'string') return $field;
		}
	}