How to use

getLiteralList

method

in

org.apache.hadoop.hive.ql.io.sarg.PredicateLeaf

private boolean addLiteral(List<Object> literals, PredicateLeaf leaf) {
 switch (leaf.getOperator()) {
 case EQUALS:
  return literals.add(
    convertLiteral(leaf.getLiteral()));
 case IN:
  return literals.addAll(
    leaf.getLiteralList().stream().map(l -> convertLiteral(l)).collect(Collectors.toList()));
 default:
  return false;
 }
}

 private boolean addLiteral(List<Object> literals, PredicateLeaf leaf) {
  switch (leaf.getOperator()) {
  case EQUALS:
   return literals.add(leaf.getLiteral());
  case IN:
   return literals.addAll(leaf.getLiteralList());
  default:
   return false;
  }
 }
}

private static FilterPredicate buildFilterPredicateFromPredicateLeaf
  (PredicateLeaf leaf, Type parquetType) throws Exception {
 LeafFilterFactory leafFilterFactory = new LeafFilterFactory();
 FilterPredicateLeafBuilder builder;
 try {
  builder = leafFilterFactory
    .getLeafFilterBuilderByType(leaf.getType(), parquetType);
  if (isMultiLiteralsOperator(leaf.getOperator())) {
   return builder.buildPredicate(leaf.getOperator(),
     leaf.getLiteralList(),
     leaf.getColumnName());
  } else {
   return builder
     .buildPredict(leaf.getOperator(),
       leaf.getLiteral(),
       leaf.getColumnName());
  }
 } catch (Exception e) {
  LOG.error("fail to build predicate filter leaf with errors" + e, e);
  throw e;
 }
}

private static FilterPredicate buildFilterPredicateFromPredicateLeaf
  (PredicateLeaf leaf, Type parquetType) throws Exception {
 LeafFilterFactory leafFilterFactory = new LeafFilterFactory();
 FilterPredicateLeafBuilder builder;
 try {
  builder = leafFilterFactory
    .getLeafFilterBuilderByType(leaf.getType(), parquetType);
  if (isMultiLiteralsOperator(leaf.getOperator())) {
   return builder.buildPredicate(leaf.getOperator(),
     leaf.getLiteralList(),
     leaf.getColumnName());
  } else {
   return builder
     .buildPredict(leaf.getOperator(),
       leaf.getLiteral(),
       leaf.getColumnName());
  }
 } catch (Exception e) {
  LOG.error("fail to build predicate filter leaf with errors" + e, e);
  throw e;
 }
}

assertEquals(PredicateLeaf.Operator.IN, leaf.getOperator());
assertEquals("first_name", leaf.getColumnName());
assertEquals("john", leaf.getLiteralList().get(0));
assertEquals("sue", leaf.getLiteralList().get(1));
assertEquals(PredicateLeaf.Operator.IN, leaf.getOperator());
assertEquals("id", leaf.getColumnName());
assertEquals(34L, leaf.getLiteralList().get(0));
assertEquals(50L, leaf.getLiteralList().get(1));

assertEquals("id", leaf.getColumnName());
assertEquals(null, leaf.getLiteral());
assertEquals(23L, leaf.getLiteralList().get(0));
assertEquals(45L, leaf.getLiteralList().get(1));

assertEquals("first_name", leaf.getColumnName());
assertEquals(null, leaf.getLiteral());
assertEquals(null, leaf.getLiteralList());

@SuppressWarnings({ "rawtypes", "unchecked" })
private Evaluator<?> inEvaluator(PredicateLeaf predicateLeaf, PrimitiveCategory category) {
 List<Comparable<?>> literals = new ArrayList<>(predicateLeaf.getLiteralList().size());
 for (Object literalItem : predicateLeaf.getLiteralList()) {
  literals.add(toComparable(category, literalItem));
 }
 return new InEvaluator(predicateLeaf.getColumnName(), literals);
}

@SuppressWarnings({ "rawtypes", "unchecked" })
private Evaluator<?> betweenEvaluator(PredicateLeaf predicateLeaf, PrimitiveCategory category) {
 List<Object> literalList = predicateLeaf.getLiteralList();
 Comparable<?> minLiteral = toComparable(category, literalList.get(0));
 Comparable<?> maxLiteral = toComparable(category, literalList.get(1));
 return new BetweenEvaluator(predicateLeaf.getColumnName(), minLiteral, maxLiteral);
}

private static TruthValue evaluatePredicateBloomFilter(PredicateLeaf predicate,
  final Object predObj, BloomFilterIO bloomFilter, boolean hasNull) {
 switch (predicate.getOperator()) {
  case NULL_SAFE_EQUALS:
   // null safe equals does not return *_NULL variant. So set hasNull to false
   return checkInBloomFilter(bloomFilter, predObj, false);
  case EQUALS:
   return checkInBloomFilter(bloomFilter, predObj, hasNull);
  case IN:
   for (Object arg : predicate.getLiteralList()) {
    // if atleast one value in IN list exist in bloom filter, qualify the row group/stripe
    Object predObjItem = getBaseObjectForComparison(predicate.getType(), arg);
    TruthValue result = checkInBloomFilter(bloomFilter, predObjItem, hasNull);
    if (result == TruthValue.YES_NO_NULL || result == TruthValue.YES_NO) {
     return result;
    }
   }
   return hasNull ? TruthValue.NO_NULL : TruthValue.NO;
  default:
   return hasNull ? TruthValue.YES_NO_NULL : TruthValue.YES_NO;
 }
}

private static TruthValue evaluatePredicateBloomFilter(PredicateLeaf predicate,
  final Object predObj, BloomFilterIO bloomFilter, boolean hasNull) {
 switch (predicate.getOperator()) {
  case NULL_SAFE_EQUALS:
   // null safe equals does not return *_NULL variant. So set hasNull to false
   return checkInBloomFilter(bloomFilter, predObj, false);
  case EQUALS:
   return checkInBloomFilter(bloomFilter, predObj, hasNull);
  case IN:
   for (Object arg : predicate.getLiteralList()) {
    // if atleast one value in IN list exist in bloom filter, qualify the row group/stripe
    Object predObjItem = getBaseObjectForComparison(predicate.getType(), arg);
    TruthValue result = checkInBloomFilter(bloomFilter, predObjItem, hasNull);
    if (result == TruthValue.YES_NO_NULL || result == TruthValue.YES_NO) {
     return result;
    }
   }
   return hasNull ? TruthValue.NO_NULL : TruthValue.NO;
  default:
   return hasNull ? TruthValue.YES_NO_NULL : TruthValue.YES_NO;
 }
}

 for (Object arg : predicate.getLiteralList()) {
  predObj = getBaseObjectForComparison(predicate.getType(), arg);
  loc = compareToRange((Comparable) predObj, minValue, maxValue);
} else {
 for (Object arg : predicate.getLiteralList()) {
  predObj = getBaseObjectForComparison(predicate.getType(), arg);
  loc = compareToRange((Comparable) predObj, minValue, maxValue);
List<Object> args = predicate.getLiteralList();
if (args == null || args.isEmpty()) {
 return TruthValue.YES_NO;

 for (Object arg : predicate.getLiteralList()) {
  predObj = getBaseObjectForComparison(predicate.getType(), arg);
  loc = compareToRange((Comparable) predObj, minValue, maxValue);
} else {
 for (Object arg : predicate.getLiteralList()) {
  predObj = getBaseObjectForComparison(predicate.getType(), arg);
  loc = compareToRange((Comparable) predObj, minValue, maxValue);
List<Object> args = predicate.getLiteralList();
Object predObj1 = getBaseObjectForComparison(predicate.getType(), args.get(0));

 for (Object arg : predicate.getLiteralList()) {
  predObj = getBaseObjectForComparison(predicate.getType(), arg);
  loc = compareToRange((Comparable) predObj, minValue, maxValue);
} else {
 for (Object arg : predicate.getLiteralList()) {
  predObj = getBaseObjectForComparison(predicate.getType(), arg);
  loc = compareToRange((Comparable) predObj, minValue, maxValue);
List<Object> args = predicate.getLiteralList();
Object predObj1 = getBaseObjectForComparison(predicate.getType(), args.get(0));

private static TruthValue evaluatePredicateBloomFilter(PredicateLeaf predicate,
  final Object predObj, BloomFilter bloomFilter, boolean hasNull, boolean useUTCTimestamp) {
 switch (predicate.getOperator()) {
  case NULL_SAFE_EQUALS:
   // null safe equals does not return *_NULL variant. So set hasNull to false
   return checkInBloomFilter(bloomFilter, predObj, false, useUTCTimestamp);
  case EQUALS:
   return checkInBloomFilter(bloomFilter, predObj, hasNull, useUTCTimestamp);
  case IN:
   for (Object arg : predicate.getLiteralList()) {
    // if atleast one value in IN list exist in bloom filter, qualify the row group/stripe
    Object predObjItem = getBaseObjectForComparison(predicate.getType(), arg);
    TruthValue result = checkInBloomFilter(bloomFilter, predObjItem, hasNull, useUTCTimestamp);
    if (result == TruthValue.YES_NO_NULL || result == TruthValue.YES_NO) {
     return result;
    }
   }
   return hasNull ? TruthValue.NO_NULL : TruthValue.NO;
  default:
   return hasNull ? TruthValue.YES_NO_NULL : TruthValue.YES_NO;
 }
}

private FilterPredicate buildFilterPredicateFromPredicateLeaf(PredicateLeaf leaf) {
 LeafFilterFactory leafFilterFactory = new LeafFilterFactory();
 FilterPredicateLeafBuilder builder;
 try {
  builder = leafFilterFactory
   .getLeafFilterBuilderByType(leaf.getType());
  if (builder == null) {
   return null;
  }
  if (isMultiLiteralsOperator(leaf.getOperator())) {
   return builder.buildPredicate(leaf.getOperator(),
     leaf.getLiteralList(),
     leaf.getColumnName());
  } else {
   return builder
    .buildPredict(leaf.getOperator(),
     leaf.getLiteral(),
     leaf.getColumnName());
  }
 } catch (Exception e) {
  LOG.error("fail to build predicate filter leaf with errors" + e, e);
  return null;
 }
}