@Override public ExprNodeDesc clone() { return new ExprNodeConstantDesc(typeInfo, value); }
private ExprBuilder valInternal(TypeInfo ti, Object val) { stack.push(new ExprNodeConstantDesc(ti, val)); return this; } }
private VectorExpression getGenericUDFStructField(ExprNodeFieldDesc exprNodeFieldDesc, VectorExpressionDescriptor.Mode mode, TypeInfo returnType) throws HiveException { // set the arguments for GenericUDFStructField List<ExprNodeDesc> children = new ArrayList<>(2); children.add(exprNodeFieldDesc.getDesc()); children.add(new ExprNodeConstantDesc(getStructFieldIndex(exprNodeFieldDesc))); return getVectorExpressionForUdf(null, GenericUDFStructField.class, children, mode, returnType); }
public static ExprNodeConstantDesc createDecimal(String strVal, boolean notNull) { HiveDecimal hd = HiveDecimal.create(strVal); if (notNull && hd == null) { return null; } return new ExprNodeConstantDesc(adjustType(hd), hd); }
@Override public Object process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs) throws SemanticException { if (nd instanceof ExprNodeConstantDesc) { return ((ExprNodeConstantDesc) nd).clone(); } return new ExprNodeConstantDesc(((ExprNodeDesc)nd).getTypeInfo(), null); } }
private static ExprNodeConstantDesc toMapConstDesc(ColumnInfo colInfo, ObjectInspector inspector, ObjectInspector keyOI, ObjectInspector valueOI) { PrimitiveObjectInspector keyPoi = (PrimitiveObjectInspector)keyOI; PrimitiveObjectInspector valuePoi = (PrimitiveObjectInspector)valueOI; Map<?,?> values = (Map<?,?>)((ConstantObjectInspector) inspector).getWritableConstantValue(); Map<Object, Object> constant = new LinkedHashMap<Object, Object>(); for (Map.Entry<?, ?> e : values.entrySet()) { constant.put(keyPoi.getPrimitiveJavaObject(e.getKey()), valuePoi.getPrimitiveJavaObject(e.getValue())); } ExprNodeConstantDesc constantExpr = new ExprNodeConstantDesc(colInfo.getType(), constant); constantExpr.setFoldedFromCol(colInfo.getInternalName()); return constantExpr; }
private static ExprNodeConstantDesc toStructConstDesc(ColumnInfo colInfo, ObjectInspector inspector, List<? extends StructField> fields) { List<?> values = (List<?>)((ConstantObjectInspector) inspector).getWritableConstantValue(); List<Object> constant = new ArrayList<Object>(); for (int i = 0; i < values.size(); i++) { Object value = values.get(i); PrimitiveObjectInspector fieldPoi = (PrimitiveObjectInspector) fields.get(i).getFieldObjectInspector(); constant.add(fieldPoi.getPrimitiveJavaObject(value)); } ExprNodeConstantDesc constantExpr = new ExprNodeConstantDesc(colInfo.getType(), constant); constantExpr.setFoldedFromCol(colInfo.getInternalName()); return constantExpr; }
private static ExprNodeConstantDesc toListConstDesc(ColumnInfo colInfo, ObjectInspector inspector, ObjectInspector listElementOI) { PrimitiveObjectInspector poi = (PrimitiveObjectInspector)listElementOI; List<?> values = (List<?>)((ConstantObjectInspector) inspector).getWritableConstantValue(); List<Object> constant = new ArrayList<Object>(); for (Object o : values) { constant.add(poi.getPrimitiveJavaObject(o)); } ExprNodeConstantDesc constantExpr = new ExprNodeConstantDesc(colInfo.getType(), constant); constantExpr.setFoldedFromCol(colInfo.getInternalName()); return constantExpr; }
@Before public void setup() throws Exception { name = "fixed_number"; colNames = new ArrayList<String>(); colTypes = new ArrayList<TypeInfo>(); colNames.add("x"); colTypes.add(TypeInfoFactory.intTypeInfo); colNames.add("y"); colTypes.add(TypeInfoFactory.intTypeInfo); bodyDesc = new ExprNodeConstantDesc(1); } @Test
@Override public Object process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs) throws SemanticException { TypeCheckCtx ctx = (TypeCheckCtx) procCtx; if (ctx.getError() != null) { return null; } ExprNodeDesc desc = TypeCheckProcFactory.processGByExpr(nd, procCtx); if (desc != null) { return desc; } return new ExprNodeConstantDesc(TypeInfoFactory.getPrimitiveTypeInfoFromPrimitiveWritable(NullWritable.class), null); }
@Override protected ExprNodeDesc processColumnDesc(NodeProcessorCtx procCtx, ExprNodeColumnDesc cd) { ExprNodeDesc newcd; ExprProcCtx epc = (ExprProcCtx) procCtx; if (cd.getTabAlias().equalsIgnoreCase(epc.getTabAlias()) && cd.getIsPartitionColOrVirtualCol()) { newcd = cd.clone(); } else { newcd = new ExprNodeConstantDesc(cd.getTypeInfo(), null); } return newcd; } }
public ExprNodeGenericFuncDesc equalityPredicate(String partColumn, String value) throws SemanticException { PrimitiveTypeInfo partColumnType = getTypeFor(partColumn); ExprNodeColumnDesc partColumnExpr = new ExprNodeColumnDesc(partColumnType, partColumn, null, true); ExprNodeConstantDesc valueExpr = new ExprNodeConstantDesc(partColumnType, getTypeAppropriateValueFor(partColumnType, value)); return binaryPredicate("=", partColumnExpr, valueExpr); }
private void createTestSarg( ObjectInspector inspector, GenericUDF udf, List<ExprNodeDesc> childExpr) { childExpr.add(new ExprNodeColumnDesc(Long.class, "userid", "T", false)); childExpr.add(new ExprNodeConstantDesc(100)); conf.set("hive.io.filter.expr.serialized", SerializationUtilities.serializeExpression( new ExprNodeGenericFuncDesc(inspector, udf, childExpr))); }
private static ExprNodeConstantDesc toPrimitiveConstDesc(ColumnInfo colInfo, ObjectInspector inspector) { PrimitiveObjectInspector poi = (PrimitiveObjectInspector) inspector; Object constant = ((ConstantObjectInspector) inspector).getWritableConstantValue(); ExprNodeConstantDesc constantExpr = new ExprNodeConstantDesc(colInfo.getType(), poi.getPrimitiveJavaObject(constant)); constantExpr.setFoldedFromCol(colInfo.getInternalName()); return constantExpr; }
@Test(expected = IllegalStateException.class) public void testCompactExprWhenConstNonBooleanThenException() { PartitionPruner.compactExpr(new ExprNodeConstantDesc("Some String")); } }
private Operator<? extends OperatorDesc> getFilterOp(int constVal) { ExprNodeDesc pred = new ExprNodeConstantDesc(constVal); FilterDesc fd = new FilterDesc(pred, true); Operator<? extends OperatorDesc> op = OperatorFactory.get(cCtx, fd); return op; }
private Operator<? extends OperatorDesc> getFilterOp(int constVal) { ExprNodeDesc pred = new ExprNodeConstantDesc(constVal); FilterDesc fd = new FilterDesc(pred, true); Operator<? extends OperatorDesc> op = OperatorFactory.get(cCtx, fd); return op; }
private Operator<TableScanDesc> getTsOp(int i) { Table tblMetadata = new Table("db", "table"); TableScanDesc desc = new TableScanDesc("alias"/*+ cCtx.nextOperatorId()*/, tblMetadata); List<ExprNodeDesc> as = Lists.newArrayList(new ExprNodeConstantDesc(TypeInfoFactory.intTypeInfo, Integer.valueOf(i)), new ExprNodeColumnDesc(TypeInfoFactory.intTypeInfo, "c1", "aa", false)); ExprNodeGenericFuncDesc f1 = new ExprNodeGenericFuncDesc(TypeInfoFactory.intTypeInfo, udf, as); desc.setFilterExpr(f1); Operator<TableScanDesc> ts = OperatorFactory.get(cCtx, desc); return ts; }
private Operator<TableScanDesc> getTsOp(int i) { Table tblMetadata = new Table("db", "table"); TableScanDesc desc = new TableScanDesc("alias_" + cCtx.nextOperatorId(), tblMetadata); List<ExprNodeDesc> as = Lists.newArrayList(new ExprNodeConstantDesc(TypeInfoFactory.intTypeInfo, Integer.valueOf(i)), new ExprNodeColumnDesc(TypeInfoFactory.intTypeInfo, "c1", "aa", false)); ExprNodeGenericFuncDesc f1 = new ExprNodeGenericFuncDesc(TypeInfoFactory.intTypeInfo, udf, as); desc.setFilterExpr(f1); Operator<TableScanDesc> ts = OperatorFactory.get(cCtx, desc); return ts; }
@Test public void testSerializeTimestamp() { Timestamp ts = Timestamp.ofEpochMilli(1374554702000L, 123456); ExprNodeConstantDesc constant = new ExprNodeConstantDesc(ts); List<ExprNodeDesc> children = new ArrayList<ExprNodeDesc>(1); children.add(constant); ExprNodeGenericFuncDesc desc = new ExprNodeGenericFuncDesc(TypeInfoFactory.timestampTypeInfo, new GenericUDFFromUtcTimestamp(), children); assertEquals(desc.getExprString(), SerializationUtilities.deserializeExpression( SerializationUtilities.serializeExpression(desc)).getExprString()); }