Package org.apache.hadoop.hive.ql.plan

Examples of org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc

295
296
297
298
299
300
301
302
303
304
305
        continue;
      }
      List<ExprNodeDesc> children = new ArrayList<ExprNodeDesc>();
      children.add(expr);
      children.add(searchCondition.getComparisonExpr());
      expr = new ExprNodeGenericFuncDesc(
        TypeInfoFactory.booleanTypeInfo,
        FunctionRegistry.getGenericUDFForAnd(),
        children);
    }
    return expr;
View Full Code Here
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
  private FilterDesc getTestFilterDesc(String column) {
    ArrayList<ExprNodeDesc> children1 = new ArrayList<ExprNodeDesc>();
    children1.add(new ExprNodeColumnDesc(TypeInfoFactory.stringTypeInfo,
        column, "", false));
    ExprNodeDesc lhs = new ExprNodeGenericFuncDesc(
        TypeInfoFactory.doubleTypeInfo, FunctionRegistry.getFunctionInfo(
        Constants.DOUBLE_TYPE_NAME).getGenericUDF(), children1);

    ArrayList<ExprNodeDesc> children2 = new ArrayList<ExprNodeDesc>();
    children2.add(new ExprNodeConstantDesc(TypeInfoFactory.longTypeInfo, Long
        .valueOf(100)));
    ExprNodeDesc rhs = new ExprNodeGenericFuncDesc(
        TypeInfoFactory.doubleTypeInfo, FunctionRegistry.getFunctionInfo(
        Constants.DOUBLE_TYPE_NAME).getGenericUDF(), children2);

    ArrayList<ExprNodeDesc> children3 = new ArrayList<ExprNodeDesc>();
    children3.add(lhs);
    children3.add(rhs);

    ExprNodeDesc desc = new ExprNodeGenericFuncDesc(
        TypeInfoFactory.booleanTypeInfo, FunctionRegistry.getFunctionInfo("<")
        .getGenericUDF(), children3);

    return new FilterDesc(desc, false);
  }
View Full Code Here
123
124
125
126
127
128
129
130
131
  private static ExprNodeDesc getListIndexNode(ExprNodeDesc node,
      ExprNodeDesc index) {
    ArrayList<ExprNodeDesc> children = new ArrayList<ExprNodeDesc>(2);
    children.add(node);
    children.add(index);
    return new ExprNodeGenericFuncDesc(((ListTypeInfo) node.getTypeInfo())
        .getListElementTypeInfo(), FunctionRegistry.getGenericUDFForIndex(),
        children);
  }
View Full Code Here
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
                        .getMsg()));
          }

          // Calculate TypeInfo
          TypeInfo t = ((ListTypeInfo) myt).getListElementTypeInfo();
          desc = new ExprNodeGenericFuncDesc(t, FunctionRegistry.getGenericUDFForIndex(), children);
        }
        else if (myt.getCategory() == Category.MAP)
        {
          // Only allow constant map key for now
          if (!(children.get(1) instanceof ExprNodeConstantDesc))
          {
            throw new SemanticException(
                SemanticAnalyzer.generateErrorMessage(expr,
                    ErrorMsg.INVALID_MAPINDEX_CONSTANT
                        .getMsg()));
          }
          if (!(((ExprNodeConstantDesc) children.get(1))
              .getTypeInfo().equals(((MapTypeInfo) myt)
              .getMapKeyTypeInfo())))
          {
            throw new SemanticException(
                ErrorMsg.INVALID_MAPINDEX_TYPE.getMsg(expr));
          }
          // Calculate TypeInfo
          TypeInfo t = ((MapTypeInfo) myt).getMapValueTypeInfo();
          desc = new ExprNodeGenericFuncDesc(t,
              FunctionRegistry.getGenericUDFForIndex(), children);
        }
        else
        {
          throw new SemanticException(
View Full Code Here
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
  public VectorExpression getVectorExpression(ExprNodeDesc exprDesc, Mode mode) throws HiveException {
    VectorExpression ve = null;
    if (exprDesc instanceof ExprNodeColumnDesc) {
      ve = getColumnVectorExpression((ExprNodeColumnDesc) exprDesc, mode);
    } else if (exprDesc instanceof ExprNodeGenericFuncDesc) {
      ExprNodeGenericFuncDesc expr = (ExprNodeGenericFuncDesc) exprDesc;
      if (isCustomUDF(expr) || isNonVectorizedPathUDF(expr)) {
        ve = getCustomUDFExpression(expr);
      } else {

        // Add cast expression if needed. Child expressions of a udf may return different data types
        // and that would require converting their data types to evaluate the udf.
        // For example decimal column added to an integer column would require integer column to be
        // cast to decimal.
        List<ExprNodeDesc> childExpressions = getChildExpressionsWithImplicitCast(expr.getGenericUDF(),
            exprDesc.getChildren(), exprDesc.getTypeInfo());
        ve = getGenericUdfVectorExpression(expr.getGenericUDF(),
            childExpressions, mode, exprDesc.getTypeInfo());
      }
    } else if (exprDesc instanceof ExprNodeConstantDesc) {
      ve = getConstantVectorExpression(((ExprNodeConstantDesc) exprDesc).getValue(), exprDesc.getTypeInfo(),
          mode);
View Full Code Here
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
      castType = updatePrecision(inputTypeInfo, (DecimalTypeInfo) castType);
      GenericUDFToDecimal castToDecimalUDF = new GenericUDFToDecimal();
      castToDecimalUDF.setTypeInfo(castType);
      List<ExprNodeDesc> children = new ArrayList<ExprNodeDesc>();
      children.add(child);
      ExprNodeDesc desc = new ExprNodeGenericFuncDesc(castType, castToDecimalUDF, children);
      return desc;
    } else if (!castTypeDecimal && inputTypeDecimal) {

      // Cast decimal input to returnType
      GenericUDF genericUdf = getGenericUDFForCast(castType);
      List<ExprNodeDesc> children = new ArrayList<ExprNodeDesc>();
      children.add(child);
      ExprNodeDesc desc = new ExprNodeGenericFuncDesc(castType, genericUdf, children);
      return desc;
    } else {

      // Casts to exact types including long to double etc. are needed in some special cases.
      if (udf instanceof GenericUDFCoalesce) {
        GenericUDF genericUdf = getGenericUDFForCast(castType);
        List<ExprNodeDesc> children = new ArrayList<ExprNodeDesc>();
        children.add(child);
        ExprNodeDesc desc = new ExprNodeGenericFuncDesc(castType, genericUdf, children);
        return desc;
      }
    }
    return null;
  }
View Full Code Here
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
    for (ExprNodeDesc desc: childExpr.subList(1, 4)) {
      if (commonType.equals(desc.getTypeInfo())) {
        castChildren.add(desc);
      } else {
        GenericUDF castUdf = getGenericUDFForCast(commonType);
        ExprNodeGenericFuncDesc engfd = new ExprNodeGenericFuncDesc(commonType, castUdf,
            Arrays.asList(new ExprNodeDesc[] { desc }));
        castChildren.add(engfd);
      }
    }
    String colType = commonType.getTypeName();
View Full Code Here
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
    }
    ExprNodeConstantDesc constExpr = (ExprNodeConstantDesc) expr;
    if (constExpr.getTypeString().equals("string")) {

      // create expression tree with type cast from string to timestamp
      ExprNodeGenericFuncDesc expr2 = new ExprNodeGenericFuncDesc();
      GenericUDFTimestamp f = new GenericUDFTimestamp();
      expr2.setGenericUDF(f);
      ArrayList<ExprNodeDesc> children = new ArrayList<ExprNodeDesc>();
      children.add(expr);
      expr2.setChildren(children);

      // initialize and evaluate
      return evaluateCastToTimestamp(expr2);
    }
View Full Code Here
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
    throw new HiveException("Udf: unhandled constant type for scalar argument. "
        + "Expecting string.");
  }

  private long evaluateCastToTimestamp(ExprNodeDesc expr) throws HiveException {
    ExprNodeGenericFuncDesc expr2 = (ExprNodeGenericFuncDesc) expr;
    ExprNodeEvaluator evaluator = ExprNodeEvaluatorFactory.get(expr2);
    ObjectInspector output = evaluator.initialize(null);
    Object constant = evaluator.evaluate(null);
    Object java = ObjectInspectorUtils.copyToStandardJavaObject(constant, output);
View Full Code Here
4642
4643
4644
4645
4646
4647
4648
4649
4650
4651
4652
        GenericUDFOPOr or = new GenericUDFOPOr();
        List<ExprNodeDesc> expressions = new ArrayList<ExprNodeDesc>(2);
        expressions.add(previous);
        expressions.add(current);
        ExprNodeDesc orExpr =
            new ExprNodeGenericFuncDesc(TypeInfoFactory.booleanTypeInfo, or, expressions);
        previous = orExpr;
      } else {
        // If an expression does not have a where clause, there can be no common filter
        previous = null;
        break;
View Full Code Here
TOP

Related Classes of org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc

  • com.facebook.presto.hive.shaded.org.apache.commons.lang.builder.HashCodeBuilder
  • com.sap.hadoop.windowing.query2.translate.WindowingTypeCheckProcFactory$DefaultExprProcessor
  • org.apache.commons.lang.builder.HashCodeBuilder
  • org.apache.hadoop.conf.Configuration
  • org.apache.hadoop.hive.accumulo.predicate.AccumuloRangeGenerator
  • org.apache.hadoop.hive.accumulo.predicate.TestAccumuloPredicateHandler
  • org.apache.hadoop.hive.accumulo.predicate.TestAccumuloRangeGenerator
  • org.apache.hadoop.hive.hbase.HBaseStorageHandler
  • org.apache.hadoop.hive.hbase.HiveHBaseTableInputFormat
  • org.apache.hadoop.hive.metastore.TestMetastoreExpr$ExprBuilder
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.