RETURN ALL COLUMNS THAT column_name REFERS TO
186152
def values(self, column_name, exclude_type=STRUCT):
        
        column_name = unnest_path(column_name)
        columns = self.columns
        output = []
        for path in self.query_path:
            full_path = untype_path(concat_field(path, column_name))
            for c in columns:
                if c.jx_type in exclude_type:
                    continue
                # if c.cardinality == 0:
                #     continue
                if untype_path(c.name) == full_path:
                    output.append(c)
            if output:
                return output
        return []
65674
def get_column_definition_all(self, table):
        """"""
        # Get complete table definition
        col_defs = self.get_table_definition(table).split('\n')

        # Return only column definitions
        return [i[0:-1].strip().replace(',', ', ') for i in col_defs if i.strip().startswith('`')]
746712
def colindex_by_colname(self, colname):
        
        for i, coldef in enumerate(self):    # iterate each column's definition
            if coldef.name == colname:
                return i
        raise ValueError('No column named "%s" found' % (colname))
629428
def get_column_names(engine: Engine, tablename: str) -> List[str]:
    
    return [info.name for info in gen_columns_info(engine, tablename)]
384036
def PyobjColumns(obj):
    ''
    return [ColumnAttr(k, type(getattr(obj, k))) for k in getPublicAttrs(obj)]
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(',')
319525
def _default_return_columns(self):
        
        return_columns = []
        parsed_expr = []

        for key, value in self.components._namespace.items():
            if hasattr(self.components, value):
                sig = signature(getattr(self.components, value))
                # The `*args` reference handles the py2.7 decorator.
                if len(set(sig.parameters) - {'args'}) == 0:
                    expr = self.components._namespace[key]
                    if not expr in parsed_expr:
                        return_columns.append(key)
                        parsed_expr.append(expr)

        return return_columns
924504
def get_orm_column_names(cls: Type, sort: bool = False) -> List[str]:
    
    colnames = [col.name for col in get_orm_columns(cls)]
    return sorted(colnames) if sort else colnames
894412
def _get_column_names(self):
        
        column_names = set()
        for column in self.df:
            column_names.add(column)
        for column in self.unmaterialized_cols:
            column_names.add(column)
        return list(column_names)
278051
function findAllColumnNames(rows) {
  const columnNames = []

  for (let i = 0; i < rows.length; i++) {
    for (let key in rows[i]) {
      if (columnNames.includes(key)) {
        continue
      }

      columnNames.push(key)
    }
  }

  return columnNames
}
870602
def get_column(self, column_name):
        
        frame = self._call_func()
        return DataFrameWrapper(self.name, frame,
                                copy_col=self.copy_col).get_column(column_name)
1192455
def _get_aliased_pivot_columns(self):
        
        defaults = [self._foreign_key, self._other_key]

        columns = []

        for column in defaults + self._pivot_columns:
            value = '%s.%s AS pivot_%s' % (self._table, column, column)
            if value not in columns:
                columns.append('%s.%s AS pivot_%s' % (self._table, column, column))

        return columns
1051850
def _get_str_columns(sf):
    
    return [name for name in sf.column_names() if sf[name].dtype == str]
132209
def _get_select_columns(self, columns=None):
        
        if columns == ['*'] or columns is None:
            columns = ['%s.*' % self._related.get_table()]

        return columns + self._get_aliased_pivot_columns()
823779
def getColumnsByName(elem, name):
	
	name = StripColumnName(name)
	return elem.getElements(lambda e: (e.tagName == ligolw.Column.tagName) and (e.Name == name))
798062
def get_column_names(self, X):
        
        if isinstance(X, pd.DataFrame):
            return X.columns

        return range(X.shape[1])
1253081
def get_column_name(self, column_name):
        
        name = pretty_name(column_name)
        if column_name in self._meta.columns:
            column_cls = self._meta.columns[column_name]
            if column_cls.verbose_name:
                name = column_cls.verbose_name
        return name