this does nothing currently... but maybe it would be good to have something like this? so that you can pass columns to functions?
500494
function Column (table, header, i) {
  this._table = table, this._header = header, this._i = i
}
194234
def putvarcol(self, value, startrow=0, nrow=-1, rowincr=1):
        """"""
        return self._table.putvarcol(self._column, value, startrow, nrow, rowincr)
735788
function (columns, values) {
            return [this.insertSql(columns, sql.literal('VALUES ' + values.map(
                function (r) {
                    return this.literal(toArray(r));
                }, this).join(this._static.COMMA_SEPARATOR)))];
        }
996239
def setup_columns(self):
        """"""
        tv = self.view['tv_categories']

        # sets the model
        tv.set_model(self.model)
        
        # creates the columns
        cell = gtk.CellRendererText()
        tvcol = gtk.TreeViewColumn('Name', cell)

        def cell_data_func(col, cell, mod, it):
            if mod[it][0]: cell.set_property('text', mod[it][0].name)
            return
        tvcol.set_cell_data_func(cell, cell_data_func)
        
        tv.append_column(tvcol)                
        return
562752
void addColumn(String columnName)
    {
        data.add(new ArrayList<String>());
        columnNames.add(columnName);
    }
1328372
function(results) {
        if (results) {
            var isRows = !!results.rows;
            var numResults = (results.rows ? results.rows.length : (results.columns[0] || []).length);
            
            console.log("====== " + numResults + " RESULTS (preview: " + !!results.preview + ") ======");
            
            // If it is in column-major form, transpose it.
            if (!isRows) {
                results = transpose(results);
            }
            
            printRows(results);
        }
    }
756413
def AddTableColumn(self, table, column):
    """"""
    if column not in self._table_columns[table]:
      self._table_columns[table].append(column)
325238
def columns_formatter(cls, colname):
        """"""
        def wrapper(func):
            cls.columns_formatters[colname] = func
            return func
        return wrapper
594282
def __makeShowColumnFunction(self, column_idx):
        
        show_column = lambda checked: self.setColumnHidden(column_idx, not checked)
        return show_column
630574
def set_columns(self, columns):
        """"""
        if isinstance(columns, tuple):
            self.columns = columns
        elif is_text_string(columns):
            self.columns = tuple(int(e) for e in columns.split(','))

        self.update()
298079
function () {
		var columns = this.columns,
			col = columns.length;

		while (col--) {
			this.parseColumn(columns[col], col);
		}

	}
308724
def _with_columns(self, columns):
        """"""
        table = type(self)()
        for label, column in zip(self.labels, columns):
            self._add_column_and_format(table, label, column)
        return table
936402
def insert_cols(self, col, no_cols=1):
        

        # Mark content as changed
        post_command_event(self.main_window, self.ContentChangedMsg)

        tab = self.grid.current_table

        self.code_array.insert(col, no_cols, axis=1, tab=tab)
1214679
def AddRow(self, values):
    
    if self._number_of_columns and len(values) != self._number_of_columns:
      raise ValueError('Number of values is out of bounds.')

    if not self._column_sizes and self._columns:
      self._column_sizes = [len(column) for column in self._columns]

    value_strings = []
    for value_index, value_string in enumerate(values):
      if not isinstance(value_string, py2to3.UNICODE_TYPE):
        value_string = '{0!s}'.format(value_string)
      value_strings.append(value_string)

      self._column_sizes[value_index] = max(
          self._column_sizes[value_index], len(value_string))

    self._rows.append(value_strings)

    if not self._number_of_columns:
      self._number_of_columns = len(value_strings)
159705
function buildTotalSelectedColumn(item, columnCombinations) {
  // Build a total column equal to the sum of all the active concepts.
  if (!canTotalBeCalculatedAndIfNotWarnUser(item)) {
    return [];
  }
  var thisColumnOptions = clone(item._columnOptions);
  thisColumnOptions.tableStructure = item._tableStructure;
  thisColumnOptions.id = "total selected";
  var activeConceptIds = calculateActiveConceptIds(item);
  if (activeConceptIds.length === 0) {
    return [];
  }
  // Find all the combinations of active concepts.
  // Eg. [['GDP'], ['METHOD-A', 'METHOD-C'], ['Q']] => [['GDP', 'METHOD-A', 'Q'], ['GDP', 'METHOD-C', 'Q']]
  var activeCombinations = arrayProduct(activeConceptIds);
  // Look up which columns these correspond to.
  // Note we need to convert the arrays to strings for indexOf to work.
  // Join with + as we know it cannot appear in an id, since it's used in the URL.
  // (If this string appears in any id, it will confuse things.)
  var joinString = "+";
  var stringifiedCombinations = columnCombinations.ids.map(function(
    combination
  ) {
    return combination.join(joinString);
  });
  var indicesIntoCombinations = activeCombinations.map(function(
    activeCombination
  ) {
    var stringifiedActiveCombination = activeCombination.join(joinString);
    return stringifiedCombinations.indexOf(stringifiedActiveCombination);
  });
  // Slice off the initial region &/or time columns, and only keep the value columns (ignoring total columns which come at the end).
  var valueColumns = item._tableStructure.columns.slice(
    item._numberOfInitialColumns,
    columnCombinations.ids.length + item._numberOfInitialColumns
  );
  var includedColumns = valueColumns.filter(function(column, i) {
    return indicesIntoCombinations.indexOf(i) >= 0;
  });
  if (includedColumns.length === 0) {
    return [];
  }
  var totalColumn = new TableColumn(
    "Total selected",
    TableColumn.sumValues(includedColumns),
    thisColumnOptions
  );
  totalColumn.isActive = !item.displayPercent;
  return totalColumn;
}
1024291
def add_column(name, column_properties = {})
      validate_column_absence(name)
      create_column_properties(name, column_properties)
      @data_rows.each{|x|
        x << (yield Row.new(@column_indexes, x))
      }
      @column_indexes[name] = @column_indexes.size
      self # enable chaining
    end
1205823
def _make_columns(columns: List[Union[int, str]]) -> List[Dict]:
        """"""
        return [dict(title=str(c),
                     dataIndex=str(c),
                     key=str(c))
                for c in columns]