@Override public Object toObject(Object object, PDataType actualType) { Integer v = (Integer) PInteger.INSTANCE.toObject(object, actualType); throwIfNonNegativeNumber(v); return v; }
@Override public Object toObject(byte[] b, int o, int l, PDataType actualType, SortOrder sortOrder, Integer maxLength, Integer scale) { Integer v = (Integer) PInteger.INSTANCE.toObject(b, o, l, actualType, sortOrder); throwIfNonNegativeNumber(v); return v; }
private int getInteger(Put p, byte[] family, byte[] qualifier) { List<Cell> cells = p.get(family, qualifier); if (cells != null && cells.size() > 0) { Cell cell = cells.get(0); return (Integer)PInteger.INSTANCE.toObject(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()); } return 0; }
private void init() { Expression offsetExpr = children.get(1); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); if (offsetExpr.isStateless() && offsetExpr.getDeterminism() == Determinism.ALWAYS && offsetExpr.evaluate(null, ptr)) { offsetPreCompute = (Integer) PInteger.INSTANCE.toObject(ptr, offsetExpr.getSortOrder()); } else offsetPreCompute = null; }
private void init() { Expression offsetExpr = children.get(1); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); if (offsetExpr.isStateless() && offsetExpr.getDeterminism() == Determinism.ALWAYS && offsetExpr.evaluate(null, ptr)) { offsetPreCompute = (Integer) PInteger.INSTANCE.toObject(ptr, offsetExpr.getSortOrder()); } else offsetPreCompute = null; }
public RoundDecimalExpression(List<Expression> children) { super(children); LiteralExpression scaleChild = (LiteralExpression)children.get(1); PDataType scaleType = scaleChild.getDataType(); Object scaleValue = scaleChild.getValue(); if(scaleValue != null) { if (scaleType.isCoercibleTo(PInteger.INSTANCE, scaleValue)) { int scale = (Integer) PInteger.INSTANCE.toObject(scaleValue, scaleType); if (scale <= PDataType.MAX_PRECISION) { this.scale = scale; return; } } throw new IllegalDataException("Invalid second argument for scale: " + scaleValue + ". The scale must be between 0 and " + PDataType.MAX_PRECISION + " inclusive."); } }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { // get offset parameter Expression offsetExpr = children.get(1); if (!offsetExpr.evaluate(tuple, ptr)) return false; if (ptr.getLength()==0) return true; int offset = (Integer) PInteger.INSTANCE.toObject(ptr, offsetExpr.getSortOrder()); // get newValue parameter Expression newValueExpr = children.get(2); if (!newValueExpr.evaluate(tuple, ptr)) return false; if (ptr.getLength()==0) return true; int newValue = (Integer) PInteger.INSTANCE.toObject(ptr, newValueExpr.getSortOrder()); byte newByteValue = (byte) (newValue & 0xff); // get binary data parameter Expression dataExpr = children.get(0); if (!dataExpr.evaluate(tuple, ptr)) return false; if (ptr.getLength() == 0) return true; int len = ptr.getLength(); offset = (offset % len + len) % len; // set result ((PBinaryBase) dataExpr.getDataType()).setByte(ptr, dataExpr.getSortOrder(), offset, newByteValue, ptr); return true; }
byte[] groupByLimitBytes = scan.getAttribute(BaseScannerRegionObserver.GROUP_BY_LIMIT); if (groupByLimitBytes != null) { groupByLimit = (Integer) PInteger.INSTANCE.toObject(groupByLimitBytes);
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { // get offset parameter Expression offsetExpr = children.get(1); if (!offsetExpr.evaluate(tuple, ptr)) return false; if (ptr.getLength()==0) return true; int offset = (Integer) PInteger.INSTANCE.toObject(ptr, offsetExpr.getSortOrder()); // get newValue parameter Expression newValueExpr = children.get(2); if (!newValueExpr.evaluate(tuple, ptr)) return false; if (ptr.getLength()==0) return true; int newValue = (Integer) PInteger.INSTANCE.toObject(ptr, newValueExpr.getSortOrder()); byte newByteValue = (byte) (newValue & 0x1); // get binary data parameter Expression dataExpr = children.get(0); if (!dataExpr.evaluate(tuple, ptr)) return false; if (ptr.getLength()==0) return true; if (ptr.getLength() == 0) return true; int len = ptr.getLength() * Byte.SIZE; offset = (offset % len + len) % len; // set result ((PBinaryBase) dataExpr.getDataType()).setBit(ptr, dataExpr.getSortOrder(), offset, newByteValue, ptr); return true; }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { // get offset parameter int offset; if (offsetPreCompute == null) { Expression offsetExpr = children.get(1); if (!offsetExpr.evaluate(tuple, ptr)) return false; if (ptr.getLength() == 0) return true; offset = (Integer) PInteger.INSTANCE.toObject(ptr, offsetExpr.getSortOrder()); } else offset = offsetPreCompute; // get binary data parameter Expression dataExpr = children.get(0); if (!dataExpr.evaluate(tuple, ptr)) return false; if (ptr.getLength() == 0) return true; int len = ptr.getLength() * Byte.SIZE; offset = (offset % len + len) % len; // set result ((PBinaryBase) dataExpr.getDataType()).getBit(ptr, dataExpr.getSortOrder(), offset, ptr); return true; }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { // get offset parameter int offset; if (offsetPreCompute == null) { Expression offsetExpr = children.get(1); if (!offsetExpr.evaluate(tuple, ptr)) return false; if (ptr.getLength() == 0) return true; offset = (Integer) PInteger.INSTANCE.toObject(ptr, offsetExpr.getSortOrder()); } else offset = offsetPreCompute; // get binary data parameter Expression dataExpr = children.get(0); if (!dataExpr.evaluate(tuple, ptr)) return false; if (ptr.getLength() == 0) return true; int len = ptr.getLength(); offset = (offset % len + len) % len; // set result ((PBinaryBase) dataExpr.getDataType()).getByte(ptr, dataExpr.getSortOrder(), offset, ptr); return true; }
public static Integer getRemainingOffset(Tuple offsetTuple) { if (offsetTuple != null) { ImmutableBytesPtr rowKeyPtr = new ImmutableBytesPtr(); offsetTuple.getKey(rowKeyPtr); if (QueryConstants.OFFSET_ROW_KEY_PTR.compareTo(rowKeyPtr) == 0) { Cell cell = offsetTuple.getValue(QueryConstants.OFFSET_FAMILY, QueryConstants.OFFSET_COLUMN); return PInteger.INSTANCE.toObject(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength(), PInteger.INSTANCE, SortOrder.ASC, null, null); } } return null; }
private void assertResult(List<KeyRange> result,int start,int end) { int expectStart=start; for(KeyRange rowKeyRange : result) { byte[] lowerRange=rowKeyRange.getLowerRange(); assertTrue(Bytes.equals(lowerRange, PInteger.INSTANCE.toBytes(expectStart))); byte[] upperRange=rowKeyRange.getUpperRange(); expectStart=((Integer)PInteger.INSTANCE.toObject(upperRange)).intValue()+1; } assertTrue(expectStart-1==end); }
Integer na = 4; byte[] b = PInteger.INSTANCE.toBytes(na); Integer nb = (Integer) PInteger.INSTANCE.toObject(b); assertEquals(na,nb); Object obj = PInteger.INSTANCE.toObject(value, PLong.INSTANCE); assertTrue(obj instanceof Integer); assertEquals(100, ((Integer)obj).intValue()); Object unsignedFloatObj = PInteger.INSTANCE.toObject(unsignedFloatValue, PUnsignedFloat.INSTANCE); assertTrue(unsignedFloatObj instanceof Integer); assertEquals(100, ((Integer)unsignedFloatObj).intValue()); Object unsignedDoubleObj = PInteger.INSTANCE.toObject(unsignedDoubleValue, PUnsignedDouble.INSTANCE); assertTrue(unsignedDoubleObj instanceof Integer); assertEquals(100, ((Integer)unsignedDoubleObj).intValue()); Object floatObj = PInteger.INSTANCE.toObject(floatValue, PFloat.INSTANCE); assertTrue(floatObj instanceof Integer); assertEquals(100, ((Integer)floatObj).intValue()); Object doubleObj = PInteger.INSTANCE.toObject(doubleValue, PDouble.INSTANCE); assertTrue(doubleObj instanceof Integer); assertEquals(100, ((Integer)doubleObj).intValue()); Object shortObj = PInteger.INSTANCE.toObject(shortValue, PSmallint.INSTANCE); assertTrue(shortObj instanceof Integer); assertEquals(100, ((Integer)shortObj).intValue());
private Object executeFunction(Expression inputArg) throws SQLException { ExternalSqlTypeIdFunction externalIdFunction = new ExternalSqlTypeIdFunction(Lists.newArrayList(inputArg)); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); assertTrue(externalIdFunction.evaluate(null, ptr)); return PInteger.INSTANCE.toObject(ptr.get(), ptr.getOffset(), ptr.getLength(), PInteger.INSTANCE, inputArg.getSortOrder()); } }
private void init() { ImmutableBytesWritable ptr = new ImmutableBytesWritable(); Expression patternExpr = getPatternExpression(); if (patternExpr.isStateless() && patternExpr.getDeterminism() == Determinism.ALWAYS && patternExpr.evaluate(null, ptr)) { String patternStr = (String) patternExpr.getDataType().toObject(ptr, patternExpr.getSortOrder()); if (patternStr != null) { pattern = compilePatternSpec(patternStr); } } // If the source string has a fixed width, then the max length would be the length // of the source string minus the offset, or the absolute value of the offset if // it's negative. Offset number is a required argument. However, if the source string // is not fixed width, the maxLength would be null. Expression offsetExpr = getOffsetExpression(); if (offsetExpr.isStateless() && offsetExpr.getDeterminism() == Determinism.ALWAYS && offsetExpr.evaluate(null, ptr)) { offset = (Integer)PInteger.INSTANCE.toObject(ptr, offsetExpr.getDataType(), offsetExpr.getSortOrder()); if (offset != null) { PDataType type = getSourceStrExpression().getDataType(); if (type.isFixedWidth()) { if (offset >= 0) { Integer maxLength = getSourceStrExpression().getMaxLength(); this.maxLength = maxLength - offset - (offset == 0 ? 0 : 1); } else { this.maxLength = -offset; } } } } }
false, PNameFactory.newName("2147483646"), PInteger.INSTANCE.toBytes(PInteger.INSTANCE.toObject("2147483646")) });
Integer scanOffset = null; if (scanOffsetBytes != null) { scanOffset = (Integer)PInteger.INSTANCE.toObject(scanOffsetBytes);
private void init() { Expression offsetExpr = children.get(1); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); if (offsetExpr.isStateless() && offsetExpr.getDeterminism() == Determinism.ALWAYS && offsetExpr.evaluate(null, ptr)) { offsetPreCompute = (Integer) PInteger.INSTANCE.toObject(ptr, offsetExpr.getSortOrder()); } else offsetPreCompute = null; }
if (withOrdinality) { assertTrue(indexExpr.evaluate(tuple, ptr)); Object index = PInteger.INSTANCE.toObject(ptr); assertEquals(o[1], index);