<p>Retrieve the {@link BigDecimal} value stored in the column
specified by the index. All DECIMAL types have a fixed
scale when represented as BigDecimals.</p>

@param columnIndex Index of the column
@return BigDecimal representation.
@see #wasNull()
517854
public final BigDecimal getDecimalAsBigDecimal(int columnIndex) {
        validateColumnType(columnIndex, VoltType.DECIMAL);
        final int position = m_buffer.position();
        m_buffer.position(getOffset(columnIndex));
        final BigDecimal bd = VoltDecimalHelper.deserializeBigDecimal(m_buffer);
        m_buffer.position(position);
        m_wasNull = bd == null ? true : false;
        return bd;
    }
1223374
public double getDouble(int columnIndex) {
		Object fieldValue = data[columnIndex];
		if (fieldValue == null) {
			return 0.0;
		}
		if (fieldValue instanceof Number) {
			return ((Number) fieldValue).doubleValue();
		}
		throw new DBFException("Unsupported type for Number at column:" + columnIndex + " "
				+ fieldValue.getClass().getCanonicalName());
	}
16639
public java.math.BigInteger getBigInteger(String column) {
		return (java.math.BigInteger)getColumns().get(column);
	}
36101
public Number getValue() {
		if ((getText() == null) || "".equals(getText().trim()))
			return null;
		try {
			Number n = format.parse(getText());
			if (n.getClass() == this.numberClass)
				return n;
			else if (this.numberClass == BigDecimal.class) {
				BigDecimal bd = new BigDecimal(n.doubleValue());
				if (scale != null) {
					bd = bd.setScale(scale.intValue(), BigDecimal.ROUND_HALF_UP);
				}
				return bd;
			}
			else if (this.numberClass == Double.class)
				return new Double(n.doubleValue());
			else if (this.numberClass == Float.class)
				return new Float(n.floatValue());
			else if (this.numberClass == BigInteger.class)
				// we have called setBigDecimalFormat to make sure a BigDecimal
				// is returned so use toBigInteger on that class
				return ((BigDecimal) n).toBigInteger();
			else if (this.numberClass == Long.class)
				return new Long(n.longValue());
			else if (this.numberClass == Integer.class)
				return new Integer(n.intValue());
			else if (this.numberClass == Short.class)
				return new Short(n.shortValue());
			else if (this.numberClass == Byte.class)
				return new Byte(n.byteValue());
			return null;
		}
		catch (Exception pe) {
			log.error("Error:  " + getText() + " is not a number.", pe);
			return null;
		}
	}
493510
@SuppressWarnings("unchecked")
    public V getValue(int index)
    {
        if ((index < 0) || (index >= size()))
        {
            throw new IndexOutOfBoundsException();
        }
        return (V) _array[index * 2 + 1];
    }
1164878
@Override
    public boolean getBoolean(int columnIndex) throws SQLException {
        checkColumnBounds(columnIndex);
        // TODO: Tempting to apply a != 0 operation on numbers and
        // .equals("true") on strings, but... hacky
        try {
            return (new Long(table.getLong(columnIndex - 1))).intValue() == 1;
        } catch (Exception x) {
            throw SQLError.get(x);
        }
    }
1160944
public int getRenderIndexFromRealIdx(final int realIdx) {
        if (columnMapping == null || realIdx == -1) {
            return realIdx;
        }

        for (final Entry<Integer, Integer> entry : columnMapping.entrySet()) {
            if (entry.getValue().equals(realIdx)) {
                return entry.getKey();
            }
        }

        return realIdx;
    }
459626
@Override
	public void updateBigDecimal(final int columnIndex, final BigDecimal x) throws SQLException {
		wrapped.updateBigDecimal(columnIndex, x);
	}
1143446
public int columnIndex(final int _tableIndex, final String _columnName)
    {
        final Optional<Column> colOpt = getColumns().stream()
                        .filter(column -> column.tableIndex == _tableIndex && column.columnName.equals(_columnName))
                        .findFirst();
        final int ret;
        if (colOpt.isPresent()) {
            ret = getColumns().indexOf(colOpt.get());
        } else {
            columns.add(new Column(tablePrefix, _tableIndex, _columnName));
            ret = getColumnIdx();
        }
        return ret;
    }
12041
public Long getLong(String column) {
		Number n = getNumber(column);
		return n != null ? n.longValue() : null;
	}
1048216
public byte[] getBytes(int columnIndex) {
		Object fieldValue = data[columnIndex];
		if (fieldValue == null) {
			return null;
		}
		if (fieldValue instanceof byte[]) {
			return (byte[]) fieldValue;
		}
		throw new DBFException("Unsupported type for byte[] at column:" + columnIndex + " "
				+ fieldValue.getClass().getCanonicalName());
	}
448791
static BigDecimal decimal(String value) {
        BigDecimal result;
        if (value != null) {
            value = value.trim();
            Matcher matcher = DECIMAL_PATTERN.matcher(value);
            if (matcher.matches()) {
                result = new BigDecimal(matcher.group(1));
            } else {
                throw new IllegalArgumentException("Unknown format for value: " + value);
            }
        } else {
            result = null;
        }
        return result;
    }
682015
@Override
    public BigDecimal getBigDecimal(int index) {
        indexCheck();
        return (BigDecimal) rows.get(row).getValue(index);
    }
697275
public java.math.BigDecimal getBigDecimal(String column) {
		return (java.math.BigDecimal)getColumns().get(column);
	}
1316104
public int getInt(int columnIndex) {
		Object fieldValue = data[columnIndex];
		if (fieldValue == null) {
			return 0;
		}
		if (fieldValue instanceof Number) {
			return ((Number) fieldValue).intValue();
		}
		throw new DBFException("Unsupported type for Number at column:" + columnIndex + " "
				+ fieldValue.getClass().getCanonicalName());
	}
1152602
public double getValueAt(int index) {
		if(index <0 || index>=insertSeq.size())
			throw new IndexOutOfBoundsException();
		return insertSeq.get(index);
	}
605098
@Override
    public double getDouble(int index) {
        check(index);
        final FLValue flValue = values.get(index);
        return flValue != null ? flValue.asDouble() : 0.0;
    }