Return the actual column name from a composite column name.
<p/>
i.e. key_1:key_2:key_3:column_name

@param columnName
@return
439318
private String handleCompositeColumnName(final String columnName) {
        final String columnKey = columnName.substring(columnName.lastIndexOf(":") + 1);
        return columnKey.equals("") ? columnName : columnKey;
    }
1240233
public int[] getIndexOfColumns(Collection<String> columnNames) {
        return getIndexOfColumns(columnNames.toArray(new String[columnNames.size()]));
    }
1104523
public Optional<ColumnMapping> getColumnMapping(final String columnName) {
        return columns.stream()
                .filter(c -> c.getName() != null && c.getName().equals(columnName))
                .findFirst();
    }
989500
public Table sortOn(String... columnNames) {

        Sort key = null;
        List<String> names = columnNames().stream().map(String::toUpperCase).collect(toList());

        for (String columnName : columnNames) {
            Sort.Order order = Sort.Order.ASCEND;
            if (!names.contains(columnName.toUpperCase())) {
                // the column name has been annotated with a prefix.
                // get the prefix which could be - or +
                String prefix = columnName.substring(0, 1);

                // remove - prefix so provided name matches actual column name
                columnName = columnName.substring(1, columnName.length());

                order = getOrder(prefix);
            }

            if (key == null) { // key will be null the first time through
                key = first(columnName, order);
            } else {
                key.next(columnName, order);
            }
        }
        return sortOn(key);
    }
883861
public boolean hasColumn(String columnName) {
        Integer idx = columnNamesIndex.get(columnName);
        return idx != null;
    }
843103
@Override
    public String[] columnNames() {
        return getInputSchema().getColumnNames().toArray(new String[getInputSchema().getColumnNames().size()]);
    }
1297538
protected String getColName(TableAlias aTableAlias, PathInfo aPathInfo, boolean translate)
	{
        FieldDescriptor fld = null;
        String result;

        if (translate)
        {
            fld = getFieldDescriptor(aTableAlias, aPathInfo);
        }

        if (fld != null)
        {
            // BRJ : No alias for delete
            result = fld.getColumnName();
        }
        else
        {
            result = aPathInfo.column;
        }

       return result;
   }
1188976
public int columnIndex(String columnName) {
        for (int i = 0; i < columnCount(); i++) {
            if (columnNames().get(i).equalsIgnoreCase(columnName)) {
                return i;
            }
        }
        throw new IllegalArgumentException(String.format("Column %s is not present in table %s", columnName, name
                ()));
    }
434317
public String columnName(String columnName) {
    if (columnName.length() > MaxLength) logger.warn("{}'s length greate than 30!", columnName);
    return columnName;
  }
1036899
@Override
	public boolean isKeyColumn(String columnName) {
		for ( String keyColumName : getColumnNames() ) {
			if ( keyColumName.equals( columnName ) ) {
				return true;
			}
		}

		return false;
	}
212079
public ColumnModel getColumn(String colOrFieldName) {
		for (ColumnModel columnModel : columns) {
			if (columnModel.getColumnName() != null && columnModel.getColumnName().equalsIgnoreCase(colOrFieldName))
				return columnModel;
			if (columnModel.getEntityField() != null && columnModel.getEntityField().equalsIgnoreCase(colOrFieldName))
				return columnModel;
		}
		return null;
	}
1235530
public int getIndexOfColumn(String columnName) {
        Integer idx = columnNamesIndex.get(columnName);
        if (idx == null)
            throw new NoSuchElementException("Unknown column: \"" + columnName + "\"");
        return idx;
    }
1057727
public List<NumericColumn<?>> numericColumns(String ... columnNames) {
        List<NumericColumn<?>> cols = new ArrayList<>();
        for (String name : columnNames) {
            cols.add(numberColumn(name));
        }

        return cols;
    }
1372013
protected String columnNameToPropertyName(String columnName){
		String normalized = columnName.replaceAll("[^a-zA-Z0-9]+", " ");
		String capitalized = WordUtils.capitalizeFully(normalized);
		String blankRemmoved = StringUtils.remove(capitalized, ' ');
		return StringUtils.uncapitalize(blankRemmoved);
	}
1186995
final Set<String> getPrimaryColumnNames() {
		final List<DBColumn> primaryKeyColumnList = getPrimaryKeyColumnList();
		final Set<String> primaryKeyColumnNameSet = new LinkedHashSet<String>();
		for (DBColumn col : primaryKeyColumnList) {

			primaryKeyColumnNameSet.add(col.columnName());
		}
		return primaryKeyColumnNameSet;
	}
651783
public FieldType getFieldTypeByColumnName(String columnName) {
		if (fieldNameMap == null) {
			// build our alias map if we need it
			Map<String, FieldType> map = new HashMap<String, FieldType>();
			for (FieldType fieldType : fieldTypes) {
				map.put(databaseType.downCaseString(fieldType.getColumnName(), true), fieldType);
			}
			fieldNameMap = map;
		}
		FieldType fieldType = fieldNameMap.get(databaseType.downCaseString(columnName, true));
		// if column name is found, return it
		if (fieldType != null) {
			return fieldType;
		}
		// look to see if someone is using the field-name instead of column-name
		for (FieldType fieldType2 : fieldTypes) {
			if (fieldType2.getFieldName().equals(columnName)) {
				throw new IllegalArgumentException("You should use columnName '" + fieldType2.getColumnName()
						+ "' for table " + tableName + " instead of fieldName '" + fieldType2.getFieldName() + "'");
			}
		}
		throw new IllegalArgumentException("Unknown column name '" + columnName + "' in table " + tableName);
	}
113151
def getcolkeyword(self, columnname, keyword):
        
        if isinstance(keyword, str):
            return self._getkeyword(columnname, keyword, -1)
        else:
            return self._getkeyword(columnname, '', keyword)