int offset = ((IntExpression) valueArg1).getInt(); prefixLength = ((IntExpression) valueArg2).getInt(); this.isRowKeyPrefixComparison = true; return visitRowKeyPrefixConvertExpression(e, prefixLength, valueArg); && (isEqualityFn || encodingType.startsWith("U"))) { bb = newByteBuf(4, encodingType.endsWith("_BE")); bb.writeInt(((IntExpression) valueArg).getInt()); if (encodingType.endsWith("_OBD")) { org.apache.hadoop.hbase.util.OrderedBytes.encodeInt32(br, ((IntExpression) valueArg).getInt(), Order.DESCENDING); this.sortOrderAscending = false; } else { org.apache.hadoop.hbase.util.OrderedBytes.encodeInt32(br, ((IntExpression) valueArg).getInt(), Order.ASCENDING);
public static LogicalExpression getNumericExpression(String sign, String s, ExpressionPosition ep) { String numStr = (sign == null) ? s : sign+s; try { int a = Integer.parseInt(numStr); return new IntExpression(a, ep); } catch (Exception e) { } try { long l = Long.parseLong(numStr); return new LongExpression(l, ep); } catch (Exception e) { } try { double d = Double.parseDouble(numStr); return new DoubleExpression(d, ep); } catch (Exception e) { } throw new IllegalArgumentException(String.format("Unable to parse string %s as integer or floating point number.", numStr)); }
int offset = ((IntExpression) valueArg1).getInt(); prefixLength = ((IntExpression) valueArg2).getInt(); this.isRowKeyPrefixComparison = true; return visitRowKeyPrefixConvertExpression(e, prefixLength, valueArg); && (isEqualityFn || encodingType.startsWith("U"))) { bb = newByteBuf(4, encodingType.endsWith("_BE")); bb.writeInt(((IntExpression) valueArg).getInt()); if (encodingType.endsWith("_OBD")) { org.apache.hadoop.hbase.util.OrderedBytes.encodeInt32(br, ((IntExpression) valueArg).getInt(), Order.DESCENDING); this.sortOrderAscending = false; } else { org.apache.hadoop.hbase.util.OrderedBytes.encodeInt32(br, ((IntExpression) valueArg).getInt(), Order.ASCENDING);
val = ((IntExpression) valueArg).getInt();
this.value = KeyValueBuilder.initFrom(((IntExpression)valueArg).getInt()); this.path = path; return true;
newArgs.add(new ValueExpressions.IntExpression(type.getPrecision(), null)); newArgs.add(new ValueExpressions.IntExpression(type.getScale(), null)); } else if (!Types.isFixedWidthType(type)) { //VarLen type newArgs.add(new ValueExpressions.LongExpression(type.getPrecision(), null));
castArgs.add(new ValueExpressions.IntExpression(toType.getPrecision(), null)); castArgs.add(new ValueExpressions.IntExpression(toType.getScale(), null)); } else if (!Types.isFixedWidthType(toType) && !Types.isUnion(toType)) {
private void setupBuild64Hash(ClassGenerator<Hash64> cg, MappingSet incomingMapping, VectorAccessible batch, LogicalExpression[] keyExprs, TypedFieldId[] toHashKeyFieldIds) throws SchemaChangeException { cg.setMappingSet(incomingMapping); if (keyExprs == null || keyExprs.length == 0) { cg.getEvalBlock()._return(JExpr.lit(0)); } String seedValue = "seedValue"; String fieldId = "fieldId"; LogicalExpression seed = ValueExpressions.getParameterExpression(seedValue, Types.required(TypeProtos.MinorType.INT)); LogicalExpression fieldIdParamExpr = ValueExpressions.getParameterExpression(fieldId, Types.required(TypeProtos.MinorType.INT)); ClassGenerator.HoldingContainer fieldIdParamHolder = cg.addExpr(fieldIdParamExpr); int i = 0; for (LogicalExpression expr : keyExprs) { TypedFieldId targetTypeFieldId = toHashKeyFieldIds[i]; ValueExpressions.IntExpression targetBuildFieldIdExp = new ValueExpressions.IntExpression(targetTypeFieldId.getFieldIds()[0], ExpressionPosition.UNKNOWN); JFieldRef targetBuildSideFieldId = cg.addExpr(targetBuildFieldIdExp, ClassGenerator.BlkCreateMode.TRUE_IF_BOUND).getValue(); JBlock ifBlock = cg.getEvalBlock()._if(fieldIdParamHolder.getValue().eq(targetBuildSideFieldId))._then(); cg.nestEvalBlock(ifBlock); LogicalExpression hashExpression = HashPrelUtil.getHash64Expression(expr, seed, true); LogicalExpression materializedExpr = ExpressionTreeMaterializer.materializeAndCheckErrors(hashExpression, batch, context.getFunctionRegistry()); ClassGenerator.HoldingContainer hash = cg.addExpr(materializedExpr, ClassGenerator.BlkCreateMode.TRUE_IF_BOUND); ifBlock._return(hash.getValue()); cg.unNestEvalBlock(); i++; } cg.getEvalBlock()._return(JExpr.lit(0)); }
@Override public TypeProtos.MajorType getType(List<LogicalExpression> logicalExpressions, FunctionAttributes attributes) { TypeProtos.DataMode mode = attributes.getReturnValue().getType().getMode(); int scale = 0; int precision = 0; if (attributes.getNullHandling() == FunctionTemplate.NullHandling.NULL_IF_NULL) { // if any one of the input types is nullable, then return nullable return type for (LogicalExpression e : logicalExpressions) { precision = Math.max(precision, e.getMajorType().getPrecision()); if (e.getMajorType().getMode() == TypeProtos.DataMode.OPTIONAL) { mode = TypeProtos.DataMode.OPTIONAL; } } // Used by functions like round, truncate which specify the scale for the output as the second argument assert (logicalExpressions.size() == 2) && (logicalExpressions.get(1) instanceof ValueExpressions.IntExpression); // Get the scale from the second argument which should be a constant scale = ((ValueExpressions.IntExpression) logicalExpressions.get(1)).getInt(); } return TypeProtos.MajorType.newBuilder() .setMinorType(attributes.getReturnValue().getType().getMinorType()) .setScale(Math.max(scale, 0)) .setPrecision(precision) .setMode(mode) .build(); } }
public static LogicalExpression getNumericExpression(String sign, String s, ExpressionPosition ep) { String numStr = (sign == null) ? s : sign+s; try { int a = Integer.parseInt(numStr); return new IntExpression(a, ep); } catch (Exception e) { } try { long l = Long.parseLong(numStr); return new LongExpression(l, ep); } catch (Exception e) { } try { double d = Double.parseDouble(numStr); return new DoubleExpression(d, ep); } catch (Exception e) { } throw new IllegalArgumentException(String.format("Unable to parse string %s as integer or floating point number.", numStr)); }
/** * Defines function return type and sets precision if it pad length parameter is int expression. * If pad length is less than zero, return type precision is 0. * * @param logicalExpressions logical expressions * @param attributes function attributes * @return return type */ @Override public TypeProtos.MajorType getType(List<LogicalExpression> logicalExpressions, FunctionAttributes attributes) { TypeProtos.MajorType.Builder builder = TypeProtos.MajorType.newBuilder() .setMinorType(attributes.getReturnValue().getType().getMinorType()) .setMode(FunctionUtils.getReturnTypeDataMode(logicalExpressions, attributes)); if (logicalExpressions.get(1).iterator().hasNext() && logicalExpressions.get(1).iterator().next() instanceof ValueExpressions.IntExpression) { int precision = ((ValueExpressions.IntExpression) logicalExpressions.get(1).iterator().next()).getInt(); // if pad length is less than zero, output length is 0 builder.setPrecision(Math.max(precision, 0)); } return builder.build(); } }
/** * Wraps the comparison function in an If-statement which compares the types first, evaluating the comaprison function only * if the types are equivialent * * @param comparisonFunction * @param args * @return */ private static LogicalExpression getTypeComparisonFunction(LogicalExpression comparisonFunction, HoldingContainer... args) { List<LogicalExpression> argExpressions = Lists.newArrayList(); List<MajorType> argTypes = Lists.newArrayList(); for(HoldingContainer c : args) { argTypes.add(c.getMajorType()); argExpressions.add(new HoldingContainerExpression(c)); } FunctionCall call = new FunctionCall("compareType", argExpressions, ExpressionPosition.UNKNOWN); List<LogicalExpression> newArgs = Lists.newArrayList(); newArgs.add(call); newArgs.add(new IntExpression(0, ExpressionPosition.UNKNOWN)); FunctionCall notEqual = new FunctionCall("not_equal", newArgs, ExpressionPosition.UNKNOWN); IfExpression.IfCondition ifCondition = new IfCondition(notEqual, call); IfExpression ifExpression = IfExpression.newBuilder().setIfCondition(ifCondition).setElse(comparisonFunction).build(); return ifExpression; }
@Override public TypeProtos.MajorType getType(List<LogicalExpression> logicalExpressions, FunctionAttributes attributes) { TypeProtos.DataMode mode = FunctionUtils.getReturnTypeDataMode(logicalExpressions, attributes); if (logicalExpressions.size() != 3) { StringBuilder err = new StringBuilder(); for (int i = 0; i < logicalExpressions.size(); i++) { err.append("arg").append(i).append(": ").append(logicalExpressions.get(i).getMajorType().getMinorType()); } throw new DrillRuntimeException("Decimal cast function invoked with incorrect arguments" + err); } int scale = ((ValueExpressions.IntExpression) logicalExpressions.get(logicalExpressions.size() - 1)).getInt(); int precision = ((ValueExpressions.IntExpression) logicalExpressions.get(logicalExpressions.size() - 2)).getInt(); return TypeProtos.MajorType.newBuilder() .setMinorType(attributes.getReturnValue().getType().getMinorType()) .setScale(scale) .setPrecision(precision) .setMode(mode) .build(); } }
public static LogicalExpression getInt(int i){ return new IntExpression(i, ExpressionPosition.UNKNOWN); }
@Override public ValueHolder visitIntConstant(ValueExpressions.IntExpression e, Integer inIndex) throws RuntimeException { return ValueHolderHelper.getIntHolder(e.getInt()); }
@Override public Void visitIntConstant(IntExpression e, Void v) { ref.value = new Long(e.getInt()); return null; }
@Override public Void visitIntConstant(IntExpression e, Void v) { ref.value = new Integer(e.getInt()); return null; } }, null);
@Override public Void visitIntConstant(IntExpression intExpr, StringBuilder sb) throws RuntimeException { sb.append(intExpr.getInt()); return null; }
@Override public LogicalExpression visitIntConstant(IntExpression intExpr, Void value) throws RuntimeException { return new IntExpression(intExpr.getInt(), intExpr.getPosition()); }
private int numTilesFromExpression(LogicalExpression numTilesExpr) { if ((numTilesExpr instanceof ValueExpressions.IntExpression)) { int nt = ((ValueExpressions.IntExpression) numTilesExpr).getInt(); if (nt > 0) { return nt; } } throw UserException.functionError().message("NTILE only accepts positive integer argument").build(logger); }