columnTransformer has access to Key, Value information in each Table.Cell
@param table
@param columnTransformer
@param <R>
@param <C>
@param <V>
@param <C2>
@return
9013
public static <R, C, V, C2> ImmutableTable<R, C2, V> columnTransformerByCell(
      final Table<R, C, V> table,
      final Function<Table.Cell<R, C, V>, C2> columnTransformer) {
    final ImmutableTable.Builder<R, C2, V> newTable = ImmutableTable.builder();
    for(Table.Cell<R, C, V> cell : table.cellSet()) {
      C2 col = columnTransformer.apply(cell);
      newTable.put(cell.getRowKey(), col, cell.getValue());
    }
    return newTable.build();
  }
788207
@Override
    public TableCellRenderer getCellRenderer(int row, int column) {
        PropertySheetTableModel.Item item = getSheetModel()
                .getPropertySheetElement(row);

        switch (column) {
            case PropertySheetTableModel.NAME_COLUMN:
                // name column gets a custom renderer
                return nameRenderer;

            case PropertySheetTableModel.VALUE_COLUMN:
                if (!item.isProperty()) {
                    return nameRenderer;
                }

                // property value column gets the renderer from the factory
                Property property = item.getProperty();
                TableCellRenderer renderer = getRendererFactory().createTableCellRenderer(property);
                if (renderer == null) {
                    renderer = getCellRenderer(property.getType());
                }
                return renderer;
            default:
                // when will this happen, given the above?
                return super.getCellRenderer(row, column);
        }
    }
1359557
@Override
    public final void addTransformer(ClassTransformer transformerClass) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.entry(tc, "addTransformer: PUID = " + ivArchivePuId + ", transformer = " + transformerClass); //d454146
        }

        if (transformerClass != null) {
            JPAComponent jpaComp = getJPAComponent();
            if (jpaComp != null && jpaComp.getCaptureEnhancedEntityClassBytecode()) {
                transformerClass = new CapturingClassTransformer(transformerClass, ivApplInfo.getApplName(), jpaComp.getServerLogDirectory());
            }
        }

        ivTransformers.add(transformerClass);

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.exit(tc, "addTransformer : # registered transfromer = " + ivTransformers.size());
        }
    }
531542
public boolean replaceByName(String table, Cell c) {
        if (c == null) {
            throw new DeepGenericException(new IllegalArgumentException("cell parameter cannot be null"));
        }

        boolean cellFound = false;
        int position = 0;

        List<Cell> localCells = getCellsByTable(table);

        Iterator<Cell> cellsIt = localCells.iterator();
        while (!cellFound && cellsIt.hasNext()) {
            Cell currentCell = cellsIt.next();

            if (currentCell.getCellName().equals(c.getCellName())) {
                cellFound = true;
            } else {
                position++;
            }
        }

        if (cellFound) {
            localCells.remove(position);

            return localCells.add(c);
        }

        return false;
    }
540666
public List<String> getTableColumn(final By tableBy, final int columnNumber) {
		List<String> result = new ArrayList<String>();
		List<List<String>> table = this.getTableAsList(tableBy);

		for (List<String> line : table) {
			result.add(line.get(columnNumber));
		}
		return result;
	}
771960
public boolean renameColumn (Connection conn, String table, String from, String to,
                                 ColumnDefinition newColumnDef) throws SQLException
    {
        executeQuery(conn, "ALTER TABLE " + tableSQL(table) + " RENAME COLUMN " +
                     columnSQL(from) + " TO " + columnSQL(to));
        log("Renamed column '" + from + "' on table '" + table + "' to '" + to + "'");
        return true;
    }
400275
@Override
    public <E> List<E> getColumnsById(String schemaName, String tableName, String pKeyColumnName, String columnName,
        Object pKeyColumnValue, Class columnJavaType) {
        // select columnName from tableName where pKeyColumnName =
        // pKeyColumnValue
        List results = new ArrayList();
        CQLTranslator translator = new CQLTranslator();
        String selectQuery = translator.SELECT_QUERY;
        selectQuery = StringUtils.replace(selectQuery, CQLTranslator.COLUMN_FAMILY,
            translator.ensureCase(new StringBuilder(), tableName, false).toString());
        selectQuery = StringUtils.replace(selectQuery, CQLTranslator.COLUMNS,
            translator.ensureCase(new StringBuilder(), columnName, false).toString());

        StringBuilder selectQueryBuilder = new StringBuilder(selectQuery);

        selectQueryBuilder.append(CQLTranslator.ADD_WHERE_CLAUSE);

        translator.buildWhereClause(selectQueryBuilder, columnJavaType, pKeyColumnName, pKeyColumnValue,
            CQLTranslator.EQ_CLAUSE, false);
        selectQueryBuilder.delete(selectQueryBuilder.lastIndexOf(CQLTranslator.AND_CLAUSE),
            selectQueryBuilder.length());

        ResultSet rSet = execute(selectQueryBuilder.toString(), null);

        Iterator<Row> rowIter = rSet.iterator();
        while (rowIter.hasNext()) {
            Row row = rowIter.next();
            DataType dataType = row.getColumnDefinitions().getType(columnName);
            Object columnValue =
                DSClientUtilities.assign(row, null, null, dataType.getName(), null, columnName, null, null);
            results.add(columnValue);
        }
        return results;
    }
203672
@Override
    @Nullable
    public Constant getConstant(int column) throws OntopResultConversionException {
        final MainTypeLangValues cell = row.get(column - 1);
        if (cell.getMainValue() == null) {
            return null;
        } else {
            return constantRetriever.getConstantFromJDBC(cell);
        }
    }
1299812
@Override
  public ImmutableMap<R, V> column(C columnKey) {
    checkNotNull(columnKey);
    return MoreObjects.firstNonNull(
        (ImmutableMap<R, V>) columnMap().get(columnKey), ImmutableMap.<R, V>of());
  }
134390
private static Set<String> getIndexedColumnSetForTable(Table table) {
        HashSet<String> columns = new HashSet<>();

        for (Index index : table.getIndexes()) {
            for (ColumnRef colRef : index.getColumns()) {
                columns.add(colRef.getColumn().getTypeName());
            }
        }

        return columns;
    }
629625
public Collection<Object> getCellValues(String table) {
        List<Object> res = new ArrayList<>();

        for (Cell c : getCellsByTable(table)) {
            res.add(c.getCellValue());
        }
        return res;
    }
412977
void switchTwoColumns(int columnIndex, int columnToIndex) {
        for (int i = 0; i < getRowCount() - 1; i++) {
            Object cellData = getItems()[i][columnToIndex];
            getItems()[i][columnToIndex] = getItems()[i][columnIndex];
            getItems()[i][columnIndex] = cellData;
        }
    }
573022
public Collection<Map<String, Object>> listColumnsDetails(String table)
	    throws SQLException {
	Collection<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
	ResultSet rs = null;
	DatabaseMetaData dbm = connection.getMetaData();
	rs = dbm.getColumns(null, null, table, null);
	while (rs.next()) {
	    Map<String, Object> resMap = new HashMap<String, Object>();

	    resMap.put("COLUMN_NAME", rs.getString("COLUMN_NAME"));
	    resMap.put("DATA_TYPE", rs.getInt("DATA_TYPE"));
	    resMap.put("COLUMN_DEF", rs.getString("COLUMN_DEF"));

	    // System.out.println(rs.getString("COLUMN_NAME")+" type: "+rs.getInt("DATA_TYPE")+" with "+rs.getString("COLUMN_DEF"));

	    result.add(resMap);
	}
	if (rs != null) {
	    rs.close();
	}
	return result;
    }
681046
private static PropertyChangeListener createAncestorPropertyChangeListener(final JTable table) {
        return new PropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent event) {
                if (table.getParent() instanceof JViewport && table.getParent().getParent() instanceof JScrollPane) {
                    table.getParent().repaint();
                }
            }
        };
    }
914868
public static TableCellElement getCell( Element root, int column, int row )
	{
		TableSectionElement tbody = getTBodyElement( root );
		
		TableRowElement tr = tbody.getChild( row ).cast();
		TableCellElement td = tr.getChild( column ).cast();
		
		return td;
	}
931362
protected TableColumnHeader createTableColumnHeader(TableColumnBase col) {
        return col.getColumns().isEmpty() ?
            new JFXTableColumnHeader(getTableViewSkin(), col) :
            new NestedTableColumnHeader(getTableViewSkin(), col);
    }
1336958
def _get_table_with_column_changes(self, blueprint, table):
        
        table = table.clone()

        for fluent in blueprint.get_changed_columns():
            column = self._get_column_for_change(table, fluent)

            for key, value in fluent.get_attributes().items():
                option = self._map_fluent_option(key)

                if option is not None:
                    method = "set_%s" % option

                    if hasattr(column, method):
                        getattr(column, method)(self._map_fluent_value(option, value))

        return table