Returns the column indeces to drop to make this table have the given columns
160101
def columns_indeces_to_drop columns
      result = []
      headers = @table[0]
      headers.each_with_index do |header, i|
        result << i unless columns.include? header
      end
      result
    end
1256929
function ( table, columns, drop )
    {
        var addColumn = 'async.series([',
            dropColumn = 'async.series([';
        var aC = util.format( '\ndb.addColumn.bind( db, \'%s\', \'%%s\', { type: \'%%s\'', table );
        var dC = util.format( '\ndb.removeColumn.bind( db, \'%s\', \'%%s\')', table );

        for ( var i = 0; i < columns.length; ++i )
        {
            if ( i > 0 )
                dropColumn += ',';

            dropColumn += util.format( dC, columns[ i ][ 0 ] );
        }

        dropColumn += '], callback);';

        addColumn += this.Columns( aC, columns, ' } ),' );
        addColumn = addColumn.substring( 0, addColumn.length - 1 ) + '], callback);';

        return this.createMigration( addColumn, dropColumn, drop );
    }
756209
def trim_empty_columns(self):
    """"""
    if self.nrows != 0 and self.ncols != 0:
      last_col = -1
      for row in self.rows:
        for i in range(last_col + 1, len(row)):
          if not self.is_cell_empty(row[i]):
            last_col = i
      ncols = last_col + 1
      self.rows = [row[:ncols] for row in self.rows]
      self.ncols = ncols
    return self
1294133
public function dropColumn($columns)
    {
        $columns = is_array($columns) ? $columns : func_get_args();

        return $this->addCommand('dropColumn', compact('columns'));
    }
615810
def _drop_collections(self, df):
        
        all_cols = df.columns
        keep_cols = []

        # Check whether each column contains collections.
        for c in all_cols:
            if len(self._col_type_set(c, df).intersection([set, dict, list])) == 0:
                keep_cols.append(c)
        return df[keep_cols]
542371
def dropna(self):
        '''
        
        '''
        new = self.copy()
        tmp = self._dict2DF(self, nan, True)
        new.row_labels = list(tmp.index)
        new.col_labels = list(tmp.columns)
        return new
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;
	}
712429
def drop_columns(self, model, *names, **kwargs):
        """"""
        fields = [field for field in model._meta.fields.values() if field.name in names]
        cascade = kwargs.pop('cascade', True)
        for field in fields:
            self.__del_field__(model, field)
            if field.unique:
                index_name = make_index_name(model._meta.table_name, [field.column_name])
                self.ops.append(self.migrator.drop_index(model._meta.table_name, index_name))
            self.ops.append(
                self.migrator.drop_column(
                    model._meta.table_name, field.column_name, cascade=cascade))
        return model
1094114
def drop_column(self, name):
        
        self._check_dropped()
        if name in list(self.table.columns.keys()):
            self.op.drop_column(self.table.name, name, schema=self.schema)
            self.table = self._update_table(self.table.name)
864880
def drop_columns(self, col):
        
        try:
            self.cleaned_data.drop(col, axis=1, inplace=True)
        except Exception as e:
            raise e
288376
def requiredUnlessTable(col_name, arg, dm, df, con=None):
    
    table_name = arg
    if col_name in df.columns:
        return None
    elif not con:
        return None
    elif table_name in con.tables:
        return None
    else:
        return "{} column is required unless table {} is present".format(col_name, table_name)
602338
function getColumnPropertiesFromColumnArray(columnProperties, columns) {
  return columns.reduce((previous, current, i) => {
    previous[current] = { id: current, order: offset + i };
    return previous;
  },
  columnProperties);
}
863029
def _get_select_columns(self, columns=None):
        
        if columns == ["*"] or columns is None:
            columns = ["%s.*" % self._related.get_table()]

        return columns + ["%s.%s" % (self._parent.get_table(), self._first_key)]
936844
function getCols(table) {
      var panel = tiaEJ.search.parentPanel(table);
      var columns = panel.getVisibleColumns();
      return columns;
    }
1006643
def _columns_for_table(table_name):
    
    return {cname: col
            for (tname, cname), col in _COLUMNS.items()
            if tname == table_name}
448917
private function removeColumnsFromEntity()
    {
        $del = $this->getDeletes();

        if ($del) {
            foreach ($del as $id => $meta) {
                $this->dropKeysFromColumnRemoved($id, $meta);

                $sql = new SqlCommand();
                $sql->exeCommand("ALTER TABLE " . PRE . $this->entity . " DROP COLUMN " . $meta['column']);
            }
        }
    }
103087
public function dropColumn() {
        $columns = func_get_args();
        foreach ($columns as $column) {
            $this->set($column);
        }
        return $this->command()->execute($this->getDropColumnSql());
    }