Write the <filterColumn> element.
341205
def write_filter_column(col_id, type, *filters) #:nodoc:
      @writer.tag_elements('filterColumn', [ ['colId', col_id] ]) do
        if type == 1
          # Type == 1 is the new XLSX style filter.
          write_filters(*filters)
        else
          # Type == 0 is the classic "custom" filter.
          write_custom_filters(*filters)
        end
      end
    end
154825
private void writeDecimalcolumn(DecimalColumnVector col, int cIdx,
                                  int rowNumber, ParseWriter dout) {
    HiveDecimalWritable[] oneColumn = col.vector;
    if(col.isRepeating) {
      HiveDecimal hd = oneColumn[0].getHiveDecimal();
      for (int rowIndex = 0; rowIndex < rowNumber; rowIndex++)
        dout.addNumCol(cIdx, hd.unscaledValue().longValue(),-hd.scale());
    } else  if(col.noNulls) {
      for (int rowIndex = 0; rowIndex < rowNumber; rowIndex++) {
        HiveDecimal hd = oneColumn[rowIndex].getHiveDecimal();
        dout.addNumCol(cIdx, hd.unscaledValue().longValue(),-hd.scale());
      }
    } else {
      boolean [] isNull = col.isNull;
      for (int rowIndex = 0; rowIndex < rowNumber; rowIndex++) {
        if (isNull[rowIndex])
          dout.addInvalidCol(cIdx);
        else {
          HiveDecimal hd = oneColumn[rowIndex].getHiveDecimal();
          dout.addNumCol(cIdx, hd.unscaledValue().longValue(), -hd.scale());
        }
      }
    }
  }
761573
def filter_data(df, filter_name, verbose=False):
    ""

    # pick only entries ending with 'Berlin' in column stop_name, incl. '(Berlin)' 
    # df = df[df.stop_name.apply(lambda cell: 'Berlin' in cell)]
    df = df[df.stop_name.apply(
        lambda cell: filter_name.encode('utf-8') in cell)]

    # remove ' (Berlin)' in column stop_name
    # df.stop_name = df.stop_name.apply(lambda cell: re.sub(' \(Berlin\)', '', cell))

    # remove initial 'S' and 'U' and 'S+U' in column stop_name
    # this creates a warning!
    # df.stop_name = df.stop_name.apply(lambda cell: re.sub('^([S\+U]+) +(.*)', lambda m: m.groups()[1], cell))

    if verbose:
        msg = '- Filtered down to %d entries containing "%s".'
        print(msg % (len(df), filter_name))

    return df
683560
protected void writeResultDetailed(Map<BioPAXElement, List<Match>> matches, OutputStream out,
		int columns) throws IOException
	{
		OutputStreamWriter writer = new OutputStreamWriter(out);

		// write the header

		String header = getHeader();
		if (header != null)
		{
			writer.write(header);
		}
		else
		{
			for (int i = 0; i < columns; i++)
			{
				writer.write("col-" + (i+1));
				if (i < columns - 1) writer.write("\t");
			}
		}

		// memory for already written lines
		Set<String> mem = new HashSet<String>();

		// write values

		for (BioPAXElement ele : matches.keySet())
		{
			for (Match m : matches.get(ele))
			{
				String line = "";
				boolean aborted = false;

				for (int i = 0; i < columns; i++)
				{
					String s = getValue(m, i);

					if (s == null)
					{
						aborted = true;
						break;
					}
					else
					{
						line += s + "\t";
					}
				}

				if (aborted) continue;

				line = line.trim();

				if (!mem.contains(line))
				{
					writer.write("\n" + line);
					mem.add(line);
				}
			}
		}
		writer.flush();
	}
630280
@Override
    public void writeColumns(Table htable, Object rowKey, Map<String, Object> columns, String columnFamilyName)
            throws IOException
    {
        if (columns != null && !columns.isEmpty())
        {
            Put p = new Put(HBaseUtils.getBytes(rowKey));
            for (String columnName : columns.keySet())
            {
                p.addColumn(columnFamilyName.getBytes(), Bytes.toBytes(columnName),
                        HBaseUtils.getBytes(columns.get(columnName)));
            }
            htable.put(p);
        }
    }
562752
void addColumn(String columnName)
    {
        data.add(new ArrayList<String>());
        columnNames.add(columnName);
    }
183599
private void writeTimecolumn(LongColumnVector col, String columnType,int cIdx,
                               int rowNumber, ParseWriter dout) {
    boolean timestamp = columnType.equals("timestamp");
    long [] oneColumn = col.vector;
    if(col.isRepeating) {
      long val = timestamp ? oneColumn[0] / 1000000 : correctTimeStamp(oneColumn[0]);
      for (int rowIndex = 0; rowIndex < rowNumber; rowIndex++)
        dout.addNumCol(cIdx, val, 0);
    } else if(col.noNulls) {
      for (int rowIndex = 0; rowIndex < rowNumber; rowIndex++)
        dout.addNumCol(cIdx, timestamp ? oneColumn[rowIndex] / 1000000 : correctTimeStamp(oneColumn[rowIndex]), 0);
    } else {
      boolean[] isNull = col.isNull;
      for (int rowIndex = 0; rowIndex < rowNumber; rowIndex++) {
        if (isNull[rowIndex])
          dout.addInvalidCol(cIdx);
        else
          dout.addNumCol(cIdx, timestamp ? oneColumn[rowIndex] / 1000000 : correctTimeStamp(oneColumn[rowIndex]), 0);
      }
    }
  }
132509
private void addColumn(StringBuilder builder, Column column) {
		builder.append(column.getColumnName());
		builder.append(" ");
		builder.append(column.getDataType().getType());
		Boolean optional = column.isOptional();
		if (optional != null) {
			builder.append(optional ? " NULL" : " NOT NULL");
		}
		String extraQualifier = column.getExtraQualifier();
		if (extraQualifier != null) {
			builder.append(" ");
			builder.append(extraQualifier);
		}
	}
1208448
private function writeColumns(): void
  {
    $content = '';
    foreach ($this->columns as $table)
    {
      $width1 = 0;
      $width2 = 0;
      foreach ($table as $column)
      {
        $width1 = max(mb_strlen($column['column_name']), $width1);
        $width2 = max(mb_strlen((string)$column['length']), $width2);
      }

      foreach ($table as $column)
      {
        if (isset($column['length']))
        {
          if (isset($column['constant_name']))
          {
            $line_format = sprintf("%%s.%%-%ds %%%dd %%s\n", $width1, $width2);
            $content     .= sprintf($line_format,
                                    $column['table_name'],
                                    $column['column_name'],
                                    $column['length'],
                                    $column['constant_name']);
          }
          else
          {
            $line_format = sprintf("%%s.%%-%ds %%%dd\n", $width1, $width2);
            $content     .= sprintf($line_format,
                                    $column['table_name'],
                                    $column['column_name'],
                                    $column['length']);
          }
        }
      }

      $content .= "\n";
    }

    // Save the columns, width and constants to the filesystem.
    $this->writeTwoPhases($this->constantsFilename, $content);
  }
103980
def write_table(self, d):
        """"""
        self._flushbits()
        table_data = AMQPWriter()
        for k, v in items(d):
            table_data.write_shortstr(k)
            table_data.write_item(v, k)
        table_data = table_data.getvalue()
        self.write_long(len(table_data))
        self.out.write(table_data)
517159
public DoubleColumn filter(DoublePredicate test) {
        DoubleColumn result = DoubleColumn.create(name());
        for (int i = 0; i < size(); i++) {
            double d = getDouble(i);
            if (test.test(d)) {
                result.append(d);
            }
        }
        return result;
    }
282627
@Override
    public void filterWrite(final NextFilter nextFilter,
            final IoSession session, final WriteRequest writeRequest) {
        writeData(nextFilter, session, writeRequest, false);
    }
670444
def _remove_column(self, name):
        
        self._columns = filter(lambda c: c.name != name, self._columns)

        return self
1324529
@Override
    public boolean columnCondition(Writable writable) {
        BooleanWritable booleanWritable = (BooleanWritable) writable;
        return booleanWritable.get();
    }
1315907
function collate (columns, filter) {
  return function (words, cb) {
    const entry = columns.reduce((entry, column, index) => {
      if (column === null) {
        return entry
      }

      if (!words[index]) {
        return entry
      }

      if (words[index].toLowerCase() === column.toLowerCase()) {
        return entry
      }

      const amend = {}
      amend[column] = words[index]
      return Object.assign({}, entry, amend)
    }, {})

    const filtered = filter(entry)

    if (filtered) {
      this.push(filtered)
    }
    cb()
  }
}
594264
public void write(FileColumn[] columns, List<String[]> lines) throws IOException
    {
        Object contents = getContents(columns, lines);
        if(stream != null && contents instanceof byte[])
        {
            byte[] bytes = (byte[])contents;
            stream.write(bytes);
        }
    }

    /**
     * Close the output file objects.
     */
    public void close()
    {
        try
        {
            // Close the workbook
            if(workbook != null)
                workbook.close();
        }
        catch(Exception e)
        {
        }

        try
        {
            // Flush and close the byte stream
            if(baos != null)
            {
                baos.flush();
                baos.close();
            }
        }
1365973
function removeColumn(values, col, colsPerRow) {
  var n = 0;
  for (var i = 0, l = values.length; i < l; i++) {
    if (i % colsPerRow !== col) values[n++] = values[i];
  }
  values.length = n;
}