Convenience alias to {@code getBlob\(getColumnIndex(columnName))}. If the column does not
exist for the cursor, return {@code defaultValue}.
341706
public byte[] getBlob(String columnName, byte[] defaultValue) {
        int index = getColumnIndex(columnName);
        if (isValidIndex(index)) {
            return getBlob(index);
        } else {
            return defaultValue;
        }
    }
1274699
public String get(int columnIndex) throws IOException {
		checkClosed();

		if (columnIndex > -1 && columnIndex < columnsCount) {
			return values[columnIndex];
		} else {
			return "";
		}
	}
145770
@Override
	public Object getDefaultValue() {

		Indexed indexedAnnotation = getIndexAnnotation();
		if (indexedAnnotation != null && StringUtils.hasText(indexedAnnotation.defaultValue())) {
			return indexedAnnotation.defaultValue();
		}
		return null;
	}
1348534
public String getColumnClassName(int column) throws SQLException {
    Field field = getField(column);
    String result = connection.getTypeInfo().getJavaClass(field.getOID());

    if (result != null) {
      return result;
    }

    int sqlType = getSQLType(column);
    switch (sqlType) {
      case Types.ARRAY:
        return ("java.sql.Array");
      default:
        String type = getPGType(column);
        if ("unknown".equals(type)) {
          return ("java.lang.String");
        }
        return ("java.lang.Object");
    }
  }
869392
public static byte[] getBlob(Cursor cursor, String columnName) {
        if (cursor == null) {
            return null;
        }

        return cursor.getBlob(cursor.getColumnIndex(columnName));
    }
693886
public String getDefaultSQL() {

        String ddl = null;

        ddl = defaultExpression == null ? null
                                        : defaultExpression.getSQL();

        return ddl;
    }
284243
@DefinedBy(Api.COMPILER)
    public long getColumnNumber() {
        if (sourcePosition == null) {
            sourcePosition = new SourcePosition();
        }
        return sourcePosition.getColumnNumber();
    }
457560
public float getFloat(String columnName, float defaultValue) {
        int index = getColumnIndex(columnName);
        if (isValidIndex(index)) {
            return getFloat(index);
        } else {
            return defaultValue;
        }
    }
1270066
public int getInteger(String columnName, int defaultValue) {
        int index = getColumnIndex(columnName);
        if (isValidIndex(index)) {
            return getInt(index);
        } else {
            return defaultValue;
        }
    }
1326204
private Object getRawValue(String columnName, Map<String, Object> content)
            throws ColumnNotFoundException {
        String field = columnName;
        Object value = content;

        while (field != null) {
            // If at any point in the path a null is encountered stop
            if (value == null) {
                throw new ColumnNotFoundException();
            }

            // With the exception of leaf values the intermediate values must always be Maps.
            if (!(value instanceof Map)) {
                throw new ColumnNotFoundException();
            }

            //noinspection unchecked
            Map<String, Object> map = (Map<String, Object>) value;
            String nextField = null;

            int separator = field.indexOf('/');
            if (separator != -1) {
                nextField = field.substring(separator + 1);
                field = field.substring(0, separator);
            }

            // Typically Hive column names are all lower case.  Because of this we can't just look up the key directly;
            // we need to look it up in a case-insensitive fashion.  For efficiency first try it as-is.

            boolean found = false;
            if (map.containsKey(field)) {
                value = map.get(field);
                found = true;
            } else {
                // Look for the key case-insensitively
                for (Iterator<String> iter = map.keySet().iterator(); !found && iter.hasNext(); ) {
                    String key = iter.next();
                    if (key.equalsIgnoreCase(field)) {
                        value = map.get(key);
                        found = true;
                    }
                }
            }
            if (!found) {
                throw new ColumnNotFoundException();
            }

            field = nextField;
        }

        return value;
    }
1301128
private static String getValue(String[] cols, int idx) {
        if (cols == null || idx >= cols.length)
            return null;
        return cols[idx];
    }
206479
public int getColumnIndex(String name) {

        int i = findColumn(name);

        if (i == -1) {
            throw Error.error(ErrorCode.X_42501, name);
        }

        return i;
    }
649500
public Float getColumnValueAsFloat(final int col) {
		final Object value = getColumnValue(col);
		if (value == null) {
			return null;
		}
		return new Float(value.toString());
	}
777157
public static Object getValue(final ResultSet resultSet, final int columnIndex) throws SQLException {
        Object result = getValueByColumnType(resultSet, columnIndex);
        return resultSet.wasNull() ? null : result;
    }
658098
public ColumnModel getColumnByColName(String colName) {
		for (ColumnModel columnModel : columns) {
			if (columnModel.getColumnName() != null && columnModel.getColumnName().equalsIgnoreCase(colName))
				return columnModel;
		}
		return null;
	}
666366
@Override
    public int getColumnIndexOrThrow(String columnName) throws IllegalArgumentException {
        int result = getColumnIndex(columnName);
        if (result == -1) {
            throw new IllegalArgumentException("CursorList is not backed by columns.");
        }
        return result;
    }
326942
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public static int getType(Cursor cursor, String columnName) {
        if (cursor == null) {
            return Cursor.FIELD_TYPE_NULL;
        }

        return cursor.getType(cursor.getColumnIndex(columnName));
    }