This method expands Composite columns into individual columns where
knowledge of individual columns is necessary; for example separate
columns in the user-interface or where individual columns need to be
analysed.

@return A List of individual columns
771989
public List<BaseColumn> getExpandedColumns() {
        final List<BaseColumn> columns = new ArrayList<BaseColumn>();
        columns.add(rowNumberCol);
        columns.add(descriptionCol);
        columns.addAll(metadataCols);
        columns.addAll(attributeCols);
        for (CompositeColumn<?> cc : this.conditionPatterns) {
            boolean explode = !(cc instanceof LimitedEntryCol);
            if (explode) {
                for (BaseColumn bc : cc.getChildColumns()) {
                    columns.add(bc);
                }
            } else {
                columns.add(cc);
            }
        }
        for (ActionCol52 ac : this.actionCols) {
            if (ac instanceof BRLActionColumn) {
                if (ac instanceof LimitedEntryCol) {
                    columns.add(ac);
                } else {
                    final BRLActionColumn bac = (BRLActionColumn) ac;
                    for (BRLActionVariableColumn variable : bac.getChildColumns()) {
                        columns.add(variable);
                    }
                }
            } else {
                columns.add(ac);
            }
        }
        return columns;
    }
147631
public int[] columnMapping( String[] features ) {
    int[] map = new int[_colNames.length];
    for( int i=0; i<_colNames.length; i++ ) {
      map[i] = -1;              // Assume it is missing
      for( int j=0; j<features.length; j++ ) {
        if( _colNames[i].equals(features[j]) ) {
          if( map[i] != -1 ) throw new IllegalArgumentException("duplicate feature "+_colNames[i]);
          map[i] = j;
        }
      }
      if( map[i] == -1 ) Log.warn(Sys.SCORM,"Model feature "+_colNames[i]+" not in the provided feature list from the data");
    }
    return map;
  }
1333634
public ArrayList<String> getColumns() {
		ArrayList<String> columns = new ArrayList<String>();
		for (String col : columnLookup.keySet()) {
			HeaderInfo hi = columnLookup.get(col);
			if (!hi.isHide()) {
				columns.add(col);
			}
		}
		return columns;
	}
117676
public List<Column<?>> columns(String... columnName) {
        List<Column<?>> cols = new ArrayList<>(columnName.length);
        for (String aColumnName : columnName) {
            cols.add(column(aColumnName));
        }
        return cols;
    }
125193
public String[] getPlainProperties(){
		String[] commonColumns = {"created", "createdby", "updated","updatedby", "isactive"};
		String[] referencedProperties = getReferencedColumns();
		List<String> plainProperties = new ArrayList<String>();
		for(String att : attributes){
			if(CStringUtils.indexOf(referencedProperties, att) >= 0 ){
				//do not include referenced columns
			}
			else if(att.endsWith("_id")){
				;//do not include implied columns
			}
			else if(CStringUtils.indexOf(commonColumns, att) >= 0){
				;//do not include common columns
			}
			else{
				plainProperties.add(att);
			}
		}
		return plainProperties.toArray(new String[plainProperties.size()]);
	}
1272449
public List<ColumnResult<SqlResultSetMapping<T>>> getAllColumnResult()
   {
      List<ColumnResult<SqlResultSetMapping<T>>> list = new ArrayList<ColumnResult<SqlResultSetMapping<T>>>();
      List<Node> nodeList = childNode.get("column-result");
      for(Node node: nodeList)
      {
         ColumnResult<SqlResultSetMapping<T>>  type = new ColumnResultImpl<SqlResultSetMapping<T>>(this, "column-result", childNode, node);
         list.add(type);
      }
      return list;
   }
800057
private Map<Integer, Integer> getColumnPosSqlTypes() {
    try {
      final Map<Integer, Integer> columnPosSqlTypes = Maps.newHashMap();
      ParameterMetaData pMetaData = this.insertPstmtForFixedBatch.getParameterMetaData();
      for (int i = 1; i <= pMetaData.getParameterCount(); i++) {
        columnPosSqlTypes.put(i, pMetaData.getParameterType(i));
      }
      return columnPosSqlTypes;
    } catch (SQLException e) {
      throw new RuntimeException("Cannot retrieve columns types for batch insert", e);
    }
  }
990013
public String[] getTypes() {
        String[] types = new String[columns.getColumns().size()];
        for (int i = 0; i < columns.getColumns().size(); i++) {
            types[i] = columns.getColumns().get(i).getType();
        }
        return types;
    }
375614
public static List<String> requiredColumns() {
		List<String> requiredColumns = new ArrayList<>();
		requiredColumns.add(COLUMN_BASE_ID);
		requiredColumns.add(COLUMN_RELATED_ID);
		return requiredColumns;
	}
733236
protected List appendListOfColumns(String[] columns, StringBuffer buf)
    {
        ArrayList columnList = new ArrayList();

        for (int i = 0; i < columns.length; i++)
        {
            if (i > 0)
            {
                buf.append(",");
            }
            appendColName(columns[i], false, null, buf);
            columnList.add(columns[i]);
        }
        return columnList;
    }
151357
protected List<String> getColumnNames() {
		List<String> columnNamesList = new ArrayList<>();
		for (int col = 0; col < getTable().getColumnCount(); col++) {
			columnNamesList.add(getTable().getColumnModel().getColumn(col).getHeaderValue().toString());
		}
		return columnNamesList;
	}
947955
final List<Field> getPrimaryKeyFieldList() {

		final List<Field> fieldList = new ArrayList<Field>();

		final Set<String> columnNameSet = getAllColumnNames();

		for (String columnName : columnNameSet) {

			final D6ModelClassFieldInfo fieldInfo = getFieldInfo(columnName);

			final Field field = fieldInfo.field;

			final DBColumn dbColumn = field.getAnnotation(DBColumn.class);

			if (dbColumn.isPrimaryKey()) {

				fieldList.add(field);
			}
		}

		return fieldList;
	}
1154177
protected function getListColumnStrategyInstances()
    {
        $instances = [];

        $info = $this->getModelInformation();

        foreach ($info->list->columns as $key => $data) {

            $instance = $this->getListDisplayFactory()->make($data->strategy);

            // Feed any extra information we can gather to the instance
            $instance
                ->setListInformation($data)
                ->setOptions($data->options());

            if ($data->source) {
                if (isset($info->attributes[ $data->source ])) {
                    $instance->setAttributeInformation(
                        $info->attributes[ $data->source ]
                    );
                }
            }

            $instance->initialize($info->modelClass());

            $instances[ $key ] = $instance;
        }

        return $instances;
    }
69136
private String[] buildColumnsArray(List<TColumn> columns) {
		String[] columnsArray = new String[columns.size()];
		for (int i = 0; i < columns.size(); i++) {
			TColumn column = columns.get(i);
			columnsArray[i] = column.getName();
		}
		return columnsArray;
	}
406754
def required(cls):
        
        columns = []
        for column in cls.__table__.columns:  # pylint: disable=no-member
            is_autoincrement = 'int' in str(column.type).lower() and column.autoincrement
            if (not column.nullable and not column.primary_key) or (column.primary_key and not is_autoincrement):
                columns.append(column.name)
        return columns
1030060
public Columns addAll(Columns columns) {
        for (Column column : columns) {
            this.columns.add(column);
        }
        return this;
    }
96983
def enrich(self, columns):
        

        for column in columns:
            if column not in self.data.columns:
                return self.data

        for column in columns:
            a = self.data[column].apply(self.__remove_surrogates)
            self.data[column] = a

        return self.data