private void readRel()

in core/src/main/java/org/apache/calcite/rel/externalize/RelJsonReader.java [131:324]
162 lines of code
14 McCabe index (conditional complexity)

  private void readRel(final Map<String, Object> jsonRel) {
    String id = (String) requireNonNull(jsonRel.get("id"), "jsonRel.id");
    String type = (String) requireNonNull(jsonRel.get("relOp"), "jsonRel.relOp");
    Constructor constructor = relJson.getConstructor(type);
    RelInput input = new RelInput() {
      @Override public RelOptCluster getCluster() {
        return cluster;
      }

      @Override public RelTraitSet getTraitSet() {
        return cluster.traitSetOf(Convention.NONE);
      }

      @Override public RelOptTable getTable(String table) {
        final List<String> list =
            requireNonNull(getStringList(table),
                () -> "getStringList for " + table);
        return requireNonNull(relOptSchema.getTableForMember(list),
            () -> "table " + table + " is not found in schema " + relOptSchema);
      }

      @Override public RelNode getInput() {
        final List<RelNode> inputs = getInputs();
        assert inputs.size() == 1;
        return inputs.get(0);
      }

      @Override public List<RelNode> getInputs() {
        final List<String> jsonInputs = getStringList("inputs");
        if (jsonInputs == null) {
          return ImmutableList.of(requireNonNull(lastRel, "lastRel"));
        }
        final ImmutableList.Builder<RelNode> inputs = new ImmutableList.Builder<>();
        for (String jsonInput : jsonInputs) {
          inputs.add(lookupInput(jsonInput));
        }
        return inputs.build();
      }

      @Override public @Nullable RexNode getExpression(String tag) {
        return relJson.toRex(this, jsonRel.get(tag));
      }

      @Override public ImmutableBitSet getBitSet(String tag) {
        return ImmutableBitSet.of(requireNonNull(getIntegerList(tag), tag));
      }

      @Override public @Nullable List<ImmutableBitSet> getBitSetList(String tag) {
        List<List<Integer>> list = getIntegerListList(tag);
        if (list == null) {
          return null;
        }
        final ImmutableList.Builder<ImmutableBitSet> builder =
            ImmutableList.builder();
        for (List<Integer> integers : list) {
          builder.add(ImmutableBitSet.of(integers));
        }
        return builder.build();
      }

      @Override public @Nullable List<String> getStringList(String tag) {
        //noinspection unchecked
        return (List<String>) jsonRel.get(tag);
      }

      @Override public @Nullable List<Integer> getIntegerList(String tag) {
        //noinspection unchecked
        return (List<Integer>) jsonRel.get(tag);
      }

      @Override public @Nullable List<List<Integer>> getIntegerListList(String tag) {
        //noinspection unchecked
        return (List<List<Integer>>) jsonRel.get(tag);
      }

      @Override public List<AggregateCall> getAggregateCalls(String tag) {
        @SuppressWarnings("unchecked")
        final List<Map<String, Object>> jsonAggs = (List) getNonNull(tag);
        final List<AggregateCall> inputs = new ArrayList<>();
        for (Map<String, Object> jsonAggCall : jsonAggs) {
          inputs.add(toAggCall(jsonAggCall));
        }
        return inputs;
      }

      @Override public @Nullable Object get(String tag) {
        return jsonRel.get(tag);
      }

      private Object getNonNull(String tag) {
        return requireNonNull(get(tag), () -> "no entry for tag " + tag);
      }

      @Override public @Nullable String getString(String tag) {
        return (String) get(tag);
      }

      @Override public float getFloat(String tag) {
        return ((Number) getNonNull(tag)).floatValue();
      }

      @Override public BigDecimal getBigDecimal(String tag) {
        return SqlFunctions.toBigDecimal(getNonNull(tag));
      }

      @Override public boolean getBoolean(String tag, boolean default_) {
        final Boolean b = (Boolean) get(tag);
        return b != null ? b : default_;
      }

      @Override public <E extends Enum<E>> @Nullable E getEnum(String tag, Class<E> enumClass) {
        return Util.enumVal(enumClass,
            ((String) getNonNull(tag)).toUpperCase(Locale.ROOT));
      }

      @Override public @Nullable List<RexNode> getExpressionList(String tag) {
        @SuppressWarnings("unchecked")
        final List<Object> jsonNodes = (List) jsonRel.get(tag);
        if (jsonNodes == null) {
          return null;
        }
        final List<RexNode> nodes = new ArrayList<>();
        for (Object jsonNode : jsonNodes) {
          nodes.add(relJson.toRex(this, jsonNode));
        }
        return nodes;
      }

      @Override public RelDataType getRowType(String tag) {
        final Object o = getNonNull(tag);
        return relJson.toType(cluster.getTypeFactory(), o);
      }

      @Override public RelDataType getRowType(String expressionsTag, String fieldsTag) {
        final List<RexNode> expressionList = getExpressionList(expressionsTag);
        @SuppressWarnings("unchecked") final List<String> names =
            (List<String>) getNonNull(fieldsTag);
        return cluster.getTypeFactory().createStructType(
            new AbstractList<Map.Entry<String, RelDataType>>() {
              @Override public Map.Entry<String, RelDataType> get(int index) {
                return Pair.of(names.get(index),
                    requireNonNull(expressionList, "expressionList").get(index).getType());
              }

              @Override public int size() {
                return names.size();
              }
            });
      }

      @Override public RelCollation getCollation() {
        //noinspection unchecked
        return relJson.toCollation((List) getNonNull("collation"));
      }

      @Override public RelDistribution getDistribution() {
        //noinspection unchecked
        return relJson.toDistribution((Map<String, Object>) getNonNull("distribution"));
      }

      @Override public ImmutableList<ImmutableList<RexLiteral>> getTuples(String tag) {
        //noinspection unchecked
        final List<List> jsonTuples = (List) getNonNull(tag);
        final ImmutableList.Builder<ImmutableList<RexLiteral>> builder =
            ImmutableList.builder();
        for (List jsonTuple : jsonTuples) {
          builder.add(getTuple(jsonTuple));
        }
        return builder.build();
      }

      public ImmutableList<RexLiteral> getTuple(List jsonTuple) {
        final ImmutableList.Builder<RexLiteral> builder =
            ImmutableList.builder();
        for (Object jsonValue : jsonTuple) {
          builder.add((RexLiteral) relJson.toRex(this, jsonValue));
        }
        return builder.build();
      }
    };
    try {
      final RelNode rel = (RelNode) constructor.newInstance(input);
      relMap.put(id, rel);
      lastRel = rel;
    } catch (InstantiationException | IllegalAccessException e) {
      throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
      final Throwable e2 = e.getCause();
      if (e2 instanceof RuntimeException) {
        throw (RuntimeException) e2;
      }
      throw new RuntimeException(e2);
    }
  }