org.apache.calcite.rel.externalize.HeavyDBRelJson Class Reference

Collaboration diagram for org.apache.calcite.rel.externalize.HeavyDBRelJson:

Public Member Functions
	HeavyDBRelJson (JsonBuilder jsonBuilder)
RelNode	create (Map< String, Object > map)
Constructor	getConstructor (String type)
Class	typeNameToClass (String type)
String	classToTypeName (Class<?extends RelNode > class_)
Object	toJson (RelCollationImpl node)
Object	toJson (RexFieldCollation node)
RelCollation	toCollation (List< Map< String, Object >> jsonFieldCollations)
RelFieldCollation	toFieldCollation (Map< String, Object > map)
RelDistribution	toDistribution (Object o)
RelDataType	toType (RelDataTypeFactory typeFactory, Object o)
Object	toJson (AggregateCall node)

Static Public Attributes
static final List< String >	PACKAGES

Package Functions
Object	toJson (Object value)
RexNode	toRex (RelInput relInput, Object o)
SqlOperator	toOp (RelInput relInput, String name)
SqlAggFunction	toAggregation (String agg)
SqlAggFunction	toAggregation (RelInput relInput, String agg)

Private Member Functions
Object	toJson (RelDataType node)
Object	toJson (RelDataTypeField node)
Object	toJson (CorrelationId node)
Object	toJson (final RexWindowBound window_bound)
Object	toJson (RexNode node)
List< RexNode >	toRexList (RelInput relInput, List operands)
SqlOperator	toOp (String op)
SqlOperator	toOp (String op, Map< String, Object > map)
String	toJson (SqlOperator operator)

Private Attributes
final Map< String, Constructor >	constructorMap
final JsonBuilder	jsonBuilder

Detailed Description

Utilities for converting org.apache.calcite.rel.RelNode into JSON format.

Definition at line 80 of file HeavyDBRelJson.java.

Constructor & Destructor Documentation

org.apache.calcite.rel.externalize.HeavyDBRelJson.HeavyDBRelJson ( JsonBuilder  jsonBuilder )

inline

Definition at line 92 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.jsonBuilder.

                                                 {
    this.jsonBuilder = jsonBuilder;
  }

Member Function Documentation

String org.apache.calcite.rel.externalize.HeavyDBRelJson.classToTypeName ( Class<?extends RelNode >  class_ )

inline

Inverse of typeNameToClass.

Definition at line 152 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.PACKAGES.

                                                                 {
    final String canonicalName = class_.getName();
    for (String package_ : PACKAGES) {
      if (canonicalName.startsWith(package_)) {
        String remaining = canonicalName.substring(package_.length());
        if (remaining.indexOf('.') < 0 && remaining.indexOf('$') < 0) {
          return remaining;
        }
      }
    }
    return canonicalName;
  }

RelNode org.apache.calcite.rel.externalize.HeavyDBRelJson.create ( Map< String, Object >  map )

inline

Definition at line 96 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.getConstructor(), and run_benchmark_import.type.

                                                 {
    String type = (String) map.get("type");
    Constructor constructor = getConstructor(type);
    try {
      return (RelNode) constructor.newInstance(map);
    } catch (InstantiationException e) {
      throw new RuntimeException("while invoking constructor for type '" + type + "'", e);
    } catch (IllegalAccessException e) {
      throw new RuntimeException("while invoking constructor for type '" + type + "'", e);
    } catch (InvocationTargetException e) {
      throw new RuntimeException("while invoking constructor for type '" + type + "'", e);
    } catch (ClassCastException e) {
      throw new RuntimeException("while invoking constructor for type '" + type + "'", e);
    }
  }

Here is the call graph for this function:

Constructor org.apache.calcite.rel.externalize.HeavyDBRelJson.getConstructor ( String  type )

inline

Definition at line 112 of file HeavyDBRelJson.java.

References run_benchmark_import.type, and org.apache.calcite.rel.externalize.HeavyDBRelJson.typeNameToClass().

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.create().

                                                 {
    Constructor constructor = constructorMap.get(type);
    if (constructor == null) {
      Class clazz = typeNameToClass(type);
      try {
        // noinspection unchecked
        constructor = clazz.getConstructor(RelInput.class);
      } catch (NoSuchMethodException e) {
        throw new RuntimeException(
                "class does not have required constructor, " + clazz + "(RelInput)");
      }
      constructorMap.put(type, constructor);
    }
    return constructor;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlAggFunction org.apache.calcite.rel.externalize.HeavyDBRelJson.toAggregation ( String  agg )

inlinepackage

Definition at line 575 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp().

                                           {
    return (SqlAggFunction) toOp(agg);
  }

Here is the call graph for this function:

SqlAggFunction org.apache.calcite.rel.externalize.HeavyDBRelJson.toAggregation ( RelInput  relInput, String  agg  )

inlinepackage

Definition at line 579 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp().

                                                              {
    return (SqlAggFunction) toOp(relInput, agg);
  }

Here is the call graph for this function:

RelCollation org.apache.calcite.rel.externalize.HeavyDBRelJson.toCollation ( List< Map< String, Object >>  jsonFieldCollations )

inline

Definition at line 185 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toFieldCollation().

                                                                                 {
    final List<RelFieldCollation> fieldCollations = new ArrayList<RelFieldCollation>();
    for (Map<String, Object> map : jsonFieldCollations) {
      fieldCollations.add(toFieldCollation(map));
    }
    return RelCollations.of(fieldCollations);
  }

Here is the call graph for this function:

RelDistribution org.apache.calcite.rel.externalize.HeavyDBRelJson.toDistribution ( Object  o )

inline

Definition at line 202 of file HeavyDBRelJson.java.

                                                  {
    return RelDistributions.ANY; // TODO:
  }

RelFieldCollation org.apache.calcite.rel.externalize.HeavyDBRelJson.toFieldCollation ( Map< String, Object >  map )

inline

Definition at line 193 of file HeavyDBRelJson.java.

References field(), and Integer.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.toCollation().

                                                                     {
    final Integer field = (Integer) map.get("field");
    final RelFieldCollation.Direction direction = Util.enumVal(
            RelFieldCollation.Direction.class, (String) map.get("direction"));
    final RelFieldCollation.NullDirection nullDirection = Util.enumVal(
            RelFieldCollation.NullDirection.class, (String) map.get("nulls"));
    return new RelFieldCollation(field, direction, nullDirection);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( RelCollationImpl  node )

inline

Definition at line 165 of file HeavyDBRelJson.java.

References setup.name.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

                                              {
    final List<Object> list = new ArrayList<Object>();
    for (RelFieldCollation fieldCollation : node.getFieldCollations()) {
      final Map<String, Object> map = jsonBuilder.map();
      map.put("field", fieldCollation.getFieldIndex());
      map.put("direction", fieldCollation.getDirection().name());
      map.put("nulls", fieldCollation.nullDirection.name());
      list.add(map);
    }
    return list;
  }

Here is the caller graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( RexFieldCollation  node )

inline

Definition at line 177 of file HeavyDBRelJson.java.

References setup.name, and org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

                                               {
    final Map<String, Object> map = jsonBuilder.map();
    map.put("field", toJson(node.left));
    map.put("direction", node.getDirection().name());
    map.put("nulls", node.getNullDirection().name());
    return map;
  }

Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( AggregateCall  node )

inline

Definition at line 234 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

                                           {
    final Map<String, Object> map = jsonBuilder.map();
    map.put("agg", toJson(node.getAggregation()));
    map.put("type", toJson(node.getType()));
    map.put("distinct", node.isDistinct());
    map.put("operands", node.getArgList());
    return map;
  }

Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( Object  value )

inlinepackage

Definition at line 243 of file HeavyDBRelJson.java.

References Integer, and org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

                              {
    if (value == null || value instanceof Number || value instanceof String
            || value instanceof Boolean) {
      return value;
    } else if (value instanceof RexNode) {
      return toJson((RexNode) value);
    } else if (value instanceof CorrelationId) {
      return toJson((CorrelationId) value);
    } else if (value instanceof List) {
      final List<Object> list = jsonBuilder.list();
      for (Object o : (List) value) {
        list.add(toJson(o));
      }
      return list;
    } else if (value instanceof ImmutableBitSet) {
      final List<Object> list = jsonBuilder.list();
      for (Integer integer : (ImmutableBitSet) value) {
        list.add(toJson(integer));
      }
      return list;
    } else if (value instanceof AggregateCall) {
      return toJson((AggregateCall) value);
    } else if (value instanceof RelCollationImpl) {
      return toJson((RelCollationImpl) value);
    } else if (value instanceof RexFieldCollation) {
      return toJson((RexFieldCollation) value);
    } else if (value instanceof RelDataType) {
      return toJson((RelDataType) value);
    } else if (value instanceof RelDataTypeField) {
      return toJson((RelDataTypeField) value);
    } else if (value instanceof JoinType) {
      return value.toString();
    } else if (value instanceof Operation) {
      return value.toString();
    } else {
      throw new UnsupportedOperationException("type not serializable: " + value
              + " (type " + value.getClass().getCanonicalName() + ")");
    }
  }

Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( RelDataType  node )

inlineprivate

Definition at line 283 of file HeavyDBRelJson.java.

References field(), setup.name, and org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

                                          {
    if (node.isStruct()) {
      final List<Object> list = jsonBuilder.list();
      for (RelDataTypeField field : node.getFieldList()) {
        list.add(toJson(field));
      }
      return list;
    } else {
      final Map<String, Object> map = jsonBuilder.map();
      map.put("type", node.getSqlTypeName().name());
      map.put("nullable", node.isNullable());
      if (node.getSqlTypeName().allowsPrec()) {
        map.put("precision", node.getPrecision());
      }
      if (node.getSqlTypeName().allowsScale()) {
        map.put("scale", node.getScale());
      }
      return map;
    }
  }

Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( RelDataTypeField  node )

inlineprivate

Definition at line 304 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

                                               {
    final Map<String, Object> map = (Map<String, Object>) toJson(node.getType());
    map.put("name", node.getName());
    return map;
  }

Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( CorrelationId  node )

inlineprivate

Definition at line 310 of file HeavyDBRelJson.java.

                                            {
    return node.getId();
  }

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( final RexWindowBound  window_bound )

inlineprivate

Definition at line 314 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

                                                           {
    final Map<String, Object> map = jsonBuilder.map();
    map.put("unbounded", toJson(window_bound.isUnbounded()));
    map.put("preceding", toJson(window_bound.isPreceding()));
    map.put("following", toJson(window_bound.isFollowing()));
    map.put("is_current_row", toJson(window_bound.isCurrentRow()));
    map.put("offset",
            window_bound.getOffset() != null ? toJson(window_bound.getOffset()) : null);
    map.put("order_key", toJson(window_bound.getOrderKey()));
    return map;
  }

Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( RexNode  node )

inlineprivate

Definition at line 326 of file HeavyDBRelJson.java.

References gpu_enabled.lower_bound(), setup.name, org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson(), and gpu_enabled.upper_bound().

                                      {
    final Map<String, Object> map;
    switch (node.getKind()) {
      case FIELD_ACCESS:
        map = jsonBuilder.map();
        final RexFieldAccess fieldAccess = (RexFieldAccess) node;
        map.put("field", fieldAccess.getField().getName());
        map.put("expr", toJson(fieldAccess.getReferenceExpr()));
        return map;
      case LITERAL:
        final RexLiteral literal = (RexLiteral) node;
        final Object value2 = literal.getValue2();
        map = jsonBuilder.map();
        if (value2 instanceof TimeUnitRange || value2 instanceof SqlTrimFunction.Flag) {
          map.put("literal", value2.toString());
        } else {
          map.put("literal", value2);
        }
        map.put("type", literal.getTypeName().name());
        map.put("target_type", literal.getType().getSqlTypeName().toString());
        final Object value = literal.getValue();
        if (value instanceof BigDecimal) {
          map.put("scale", ((BigDecimal) value).scale());
          map.put("precision", ((BigDecimal) value).precision());
        } else {
          map.put("scale", literal.getType().getScale());
          map.put("precision", literal.getType().getPrecision());
        }
        map.put("type_scale", literal.getType().getScale());
        map.put("type_precision", literal.getType().getPrecision());
        return map;
      case INPUT_REF:
        map = jsonBuilder.map();
        map.put("input", ((RexInputRef) node).getIndex());
        return map;
      case CORREL_VARIABLE:
        map = jsonBuilder.map();
        map.put("correl", ((RexCorrelVariable) node).getName());
        map.put("type", toJson(node.getType()));
        return map;
      default:
        if (node instanceof RexCall) {
          final RexCall call = (RexCall) node;
          map = jsonBuilder.map();
          map.put("op", toJson(call.getOperator()));
          final List<Object> list = jsonBuilder.list();
          for (RexNode operand : call.getOperands()) {
            list.add(toJson(operand));
          }
          map.put("operands", list);
          map.put("type", toJson(node.getType()));
          if (node instanceof RexSubQuery) {
            final HeavyDBRelJsonWriter subqueryWriter = new HeavyDBRelJsonWriter();
            ((RexSubQuery) node).rel.explain(subqueryWriter);
            map.put("subquery", subqueryWriter.asJsonMap());
          }
          if (node instanceof RexOver) {
            final RexWindow window = ((RexOver) node).getWindow();
            final List<Object> partitionKeyList = jsonBuilder.list();
            for (final RexNode partitionKey : window.partitionKeys) {
              partitionKeyList.add(toJson(partitionKey));
            }
            map.put("partition_keys", partitionKeyList);
            final List<Object> orderKeyList = jsonBuilder.list();
            for (final RexFieldCollation orderKey : window.orderKeys) {
              orderKeyList.add(toJson(orderKey));
            }
            map.put("order_keys", orderKeyList);
            RexWindowBound lower_bound = window.getLowerBound();
            RexWindowBound upper_bound = window.getUpperBound();
            map.put("lower_bound", toJson(lower_bound));
            map.put("upper_bound", toJson(upper_bound));
            map.put("is_rows", toJson(window.isRows()));
          }
          if (call.getOperator() instanceof SqlFunction) {
            switch (((SqlFunction) call.getOperator()).getFunctionType()) {
              case USER_DEFINED_CONSTRUCTOR:
              case USER_DEFINED_FUNCTION:
              case USER_DEFINED_PROCEDURE:
              case USER_DEFINED_SPECIFIC_FUNCTION:
                map.put("class", call.getOperator().getClass().getName());
            }
          }
          return map;
        }
        throw new UnsupportedOperationException("unknown rex " + node);
    }
  }

Here is the call graph for this function:

String org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( SqlOperator  operator )

inlineprivate

Definition at line 583 of file HeavyDBRelJson.java.

                                              {
    // User-defined operators are not yet handled.
    return operator.getName();
  }

SqlOperator org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp ( String  op )

inlineprivate

Definition at line 523 of file HeavyDBRelJson.java.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.toAggregation(), and org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex().

                                      {
    return toOp(op, new HashMap<>());
  }

Here is the caller graph for this function:

SqlOperator org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp ( String  op, Map< String, Object >  map  )

inlineprivate

Definition at line 527 of file HeavyDBRelJson.java.

                                                               {
    // TODO: build a map, for more efficient lookup
    // TODO: look up based on SqlKind
    HeavyDBSqlOperatorTable operatorTable =
            new HeavyDBSqlOperatorTable(SqlStdOperatorTable.instance());
    operatorTable.addUDF(null);
    final List<SqlOperator> operatorList = operatorTable.getOperatorList();
    for (SqlOperator operator : operatorList) {
      if (operator.getName().equals(op)) {
        return operator;
      }
    }
    String class_ = (String) map.get("class");
    if (class_ != null) {
      try {
        return (SqlOperator) Class.forName(class_).newInstance();
      } catch (InstantiationException e) {
        throw new RuntimeException(e);
      } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
      } catch (ClassNotFoundException e) {
        throw new RuntimeException(e);
      }
    }
    throw new RuntimeException("Operator " + op + " does not supported");
  }

SqlOperator org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp ( RelInput  relInput, String  name  )

inlinepackage

Definition at line 554 of file HeavyDBRelJson.java.

References setup.name.

                                                   {
    // in case different operator has the same kind, check with both name and kind.
    String kind = name;
    String syntax = "FUNCTION";
    SqlKind sqlKind = SqlKind.valueOf(kind);
    SqlSyntax sqlSyntax = SqlSyntax.valueOf(syntax);
    HeavyDBSqlOperatorTable operatorTable =
            new HeavyDBSqlOperatorTable(SqlStdOperatorTable.instance());
    operatorTable.addUDF(null);
    final List<SqlOperator> operators = operatorTable.getOperatorList();
    List<String> names = new ArrayList<>();
    for (SqlOperator operator : operators) {
      names.add(operator.toString());
      if (operator.getName().equals(name)) {
        return operator;
      }
    }
    throw new RuntimeException("Aggregation function with name " + name
            + " not found, search in " + names.toString());
  }

RexNode org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex ( RelInput  relInput, Object  o  )

inlinepackage

Definition at line 415 of file HeavyDBRelJson.java.

References Double, field(), Float, Integer, org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp(), org.apache.calcite.rel.externalize.HeavyDBRelJson.toRexList(), org.apache.calcite.rel.externalize.HeavyDBRelJson.toType(), and run_benchmark_import.type.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJsonReader.readRel(), and org.apache.calcite.rel.externalize.HeavyDBRelJson.toRexList().

                                             {
    final RelOptCluster cluster = relInput.getCluster();
    final RexBuilder rexBuilder = cluster.getRexBuilder();
    if (o == null) {
      return null;
    } else if (o instanceof Map) {
      Map map = (Map) o;
      final String op = (String) map.get("op");
      if (op != null) {
        final List operands = (List) map.get("operands");
        final Object jsonType = map.get("type");
        final SqlOperator operator = toOp(op, map);
        final List<RexNode> rexOperands = toRexList(relInput, operands);
        RelDataType type;
        if (jsonType != null) {
          type = toType(cluster.getTypeFactory(), jsonType);
        } else {
          type = rexBuilder.deriveReturnType(operator, rexOperands);
        }
        return rexBuilder.makeCall(type, operator, rexOperands);
      }
      final Integer input = (Integer) map.get("input");
      if (input != null) {
        List<RelNode> inputNodes = relInput.getInputs();
        int i = input;
        for (RelNode inputNode : inputNodes) {
          final RelDataType rowType = inputNode.getRowType();
          if (i < rowType.getFieldCount()) {
            final RelDataTypeField field = rowType.getFieldList().get(i);
            return rexBuilder.makeInputRef(field.getType(), input);
          }
          i -= rowType.getFieldCount();
        }
        throw new RuntimeException("input field " + input + " is out of range");
      }
      final String field = (String) map.get("field");
      if (field != null) {
        final Object jsonExpr = map.get("expr");
        final RexNode expr = toRex(relInput, jsonExpr);
        return rexBuilder.makeFieldAccess(expr, field, true);
      }
      final String correl = (String) map.get("correl");
      if (correl != null) {
        final Object jsonType = map.get("type");
        RelDataType type = toType(cluster.getTypeFactory(), jsonType);
        return rexBuilder.makeCorrel(type, new CorrelationId(correl));
      }
      if (map.containsKey("literal")) {
        final Object literal = map.get("literal");
        final SqlTypeName sqlTypeName =
                Util.enumVal(SqlTypeName.class, (String) map.get("type"));
        if (literal == null) {
          return rexBuilder.makeNullLiteral(
                  cluster.getTypeFactory().createSqlType(sqlTypeName));
        }

        // HEAVY.AI serializes numeric literals differently, we need more data
        // then the number. So, we need to have a special case for that.
        if (literal instanceof Number) {
          final SqlTypeName targetTypeName =
                  Util.enumVal(SqlTypeName.class, (String) map.get("target_type"));
          final long scale = ((Number) map.get("scale")).longValue();
          final long precision = ((Number) map.get("precision")).longValue();
          final long typeScale = ((Number) map.get("type_scale")).longValue();
          final long typePrecision = ((Number) map.get("type_precision")).longValue();
          RelDataTypeFactory typeFactory = cluster.getTypeFactory();

          BigDecimal value =
                  BigDecimal.valueOf(((Number) literal).longValue(), (int) scale);

          if (typeScale != 0 && typeScale != -2147483648) {
            return rexBuilder.makeLiteral(value,
                    typeFactory.createSqlType(
                            SqlTypeName.DECIMAL, (int) typePrecision, (int) typeScale),
                    false);
          } else {
            return rexBuilder.makeLiteral(
                    value, typeFactory.createSqlType(targetTypeName), false);
          }
        } else {
          return toRex(relInput, literal);
        }
      }
      throw new UnsupportedOperationException("cannot convert to rex " + o);
    } else if (o instanceof Boolean) {
      return rexBuilder.makeLiteral((Boolean) o);
    } else if (o instanceof String) {
      return rexBuilder.makeLiteral((String) o);
    } else if (o instanceof Number) {
      final Number number = (Number) o;
      if (number instanceof Double || number instanceof Float) {
        return rexBuilder.makeApproxLiteral(BigDecimal.valueOf(number.doubleValue()));
      } else {
        return rexBuilder.makeExactLiteral(BigDecimal.valueOf(number.longValue()));
      }
    } else {
      throw new UnsupportedOperationException("cannot convert to rex " + o);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

List<RexNode> org.apache.calcite.rel.externalize.HeavyDBRelJson.toRexList ( RelInput  relInput, List  operands  )

inlineprivate

Definition at line 515 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex().

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex().

                                                                    {
    final List<RexNode> list = new ArrayList<RexNode>();
    for (Object operand : operands) {
      list.add(toRex(relInput, operand));
    }
    return list;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

RelDataType org.apache.calcite.rel.externalize.HeavyDBRelJson.toType ( RelDataTypeFactory  typeFactory, Object  o  )

inline

Definition at line 206 of file HeavyDBRelJson.java.

References Integer, and run_benchmark_import.type.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex().

                                                                      {
    if (o instanceof List) {
      @SuppressWarnings("unchecked")
      final List<Map<String, Object>> jsonList = (List<Map<String, Object>>) o;
      final RelDataTypeFactory.Builder builder = typeFactory.builder();
      for (Map<String, Object> jsonMap : jsonList) {
        builder.add((String) jsonMap.get("name"), toType(typeFactory, jsonMap));
      }
      return builder.build();
    } else {
      final Map<String, Object> map = (Map<String, Object>) o;
      final SqlTypeName sqlTypeName =
              Util.enumVal(SqlTypeName.class, (String) map.get("type"));
      final Integer precision = (Integer) map.get("precision");
      final Integer scale = (Integer) map.get("scale");
      final RelDataType type;
      if (precision == null) {
        type = typeFactory.createSqlType(sqlTypeName);
      } else if (scale == null) {
        type = typeFactory.createSqlType(sqlTypeName, precision);
      } else {
        type = typeFactory.createSqlType(sqlTypeName, precision, scale);
      }
      final boolean nullable = (Boolean) map.get("nullable");
      return typeFactory.createTypeWithNullability(type, nullable);
    }
  }

Here is the caller graph for this function:

Class org.apache.calcite.rel.externalize.HeavyDBRelJson.typeNameToClass ( String  type )

inline

Converts a type name to a class. E.g.

getClass("LogicalProject") 

returns org.apache.calcite.rel.logical.LogicalProject.class.

Definition at line 132 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.PACKAGES, and run_benchmark_import.type.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.getConstructor().

                                            {
    if (!type.contains(".")) {
      for (String package_ : PACKAGES) {
        try {
          return Class.forName(package_ + type);
        } catch (ClassNotFoundException e) {
          // ignore
        }
      }
    }
    try {
      return Class.forName(type);
    } catch (ClassNotFoundException e) {
      throw new RuntimeException("unknown type " + type);
    }
  }

Here is the caller graph for this function:

Member Data Documentation

final Map<String, Constructor> org.apache.calcite.rel.externalize.HeavyDBRelJson.constructorMap

private

Initial value:

=
          new HashMap<String, Constructor>()

Definition at line 81 of file HeavyDBRelJson.java.

final JsonBuilder org.apache.calcite.rel.externalize.HeavyDBRelJson.jsonBuilder

private

Definition at line 83 of file HeavyDBRelJson.java.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.HeavyDBRelJson().

final List<String> org.apache.calcite.rel.externalize.HeavyDBRelJson.PACKAGES

static

Initial value:

= ImmutableList.of("org.apache.calcite.rel.",
          "org.apache.calcite.rel.core.",
          "org.apache.calcite.rel.logical.",
          "org.apache.calcite.adapter.jdbc.",
          "org.apache.calcite.adapter.enumerable.",
          "org.apache.calcite.adapter.jdbc.JdbcRules$")

Definition at line 85 of file HeavyDBRelJson.java.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.classToTypeName(), and org.apache.calcite.rel.externalize.HeavyDBRelJson.typeNameToClass().

---

The documentation for this class was generated from the following file:

• /home/jenkins-slave/workspace/core-os-doxygen/java/calcite/src/main/java/org/apache/calcite/rel/externalize/HeavyDBRelJson.java