public Partitioning deserialize()

in common/src/main/java/org/apache/gravitino/json/JsonUtils.java [1120:1219]
87 lines of code
15 McCabe index (conditional complexity)

    public Partitioning deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
      JsonNode node = p.getCodec().readTree(p);
      Preconditions.checkArgument(
          node != null && !node.isNull() && node.isObject(),
          "Cannot parse partitioning from invalid JSON: %s",
          node);
      Preconditions.checkArgument(
          node.has(STRATEGY), "Cannot parse partitioning from missing strategy: %s", node);
      String strategy = getString(STRATEGY, node);
      switch (Partitioning.Strategy.getByName(strategy)) {
        case IDENTITY:
          return IdentityPartitioningDTO.of(getStringList(FIELD_NAME, node).toArray(new String[0]));

        case YEAR:
          return YearPartitioningDTO.of(getStringList(FIELD_NAME, node).toArray(new String[0]));

        case MONTH:
          return MonthPartitioningDTO.of(getStringList(FIELD_NAME, node).toArray(new String[0]));

        case DAY:
          return DayPartitioningDTO.of(getStringList(FIELD_NAME, node).toArray(new String[0]));

        case HOUR:
          return HourPartitioningDTO.of(getStringList(FIELD_NAME, node).toArray(new String[0]));

        case BUCKET:
          int numBuckets = getInt(NUM_BUCKETS, node);
          List<String[]> fieldNames = Lists.newArrayList();
          node.get(FIELD_NAMES).forEach(field -> fieldNames.add(getStringArray((ArrayNode) field)));
          return BucketPartitioningDTO.of(numBuckets, fieldNames.toArray(new String[0][0]));

        case TRUNCATE:
          int width = getInt(WIDTH, node);
          return TruncatePartitioningDTO.of(
              width, getStringList(FIELD_NAME, node).toArray(new String[0]));

        case LIST:
          List<String[]> listFields = Lists.newArrayList();
          node.get(FIELD_NAMES).forEach(field -> listFields.add(getStringArray((ArrayNode) field)));

          if (!node.hasNonNull(ASSIGNMENTS_NAME)) {
            return ListPartitioningDTO.of(listFields.toArray(new String[0][0]));
          }

          Preconditions.checkArgument(
              node.get(ASSIGNMENTS_NAME).isArray(),
              "Cannot parse list partitioning from non-array assignments: %s",
              node);
          List<ListPartitionDTO> assignments = Lists.newArrayList();
          node.get(ASSIGNMENTS_NAME)
              .forEach(
                  assignment -> {
                    PartitionDTO partitionDTO = readPartition(assignment);
                    Preconditions.checkArgument(
                        partitionDTO instanceof ListPartitionDTO,
                        "Cannot parse list partitioning from non-list assignment: %s",
                        assignment);
                    assignments.add((ListPartitionDTO) partitionDTO);
                  });
          return ListPartitioningDTO.of(
              listFields.toArray(new String[0][0]), assignments.toArray(new ListPartitionDTO[0]));

        case RANGE:
          String[] fields = getStringList(FIELD_NAME, node).toArray(new String[0]);
          if (!node.hasNonNull(ASSIGNMENTS_NAME)) {
            return RangePartitioningDTO.of(fields);
          }

          Preconditions.checkArgument(
              node.get(ASSIGNMENTS_NAME).isArray(),
              "Cannot parse range partitioning from non-array assignments: %s",
              node);
          List<RangePartitionDTO> rangeAssignments = Lists.newArrayList();
          node.get(ASSIGNMENTS_NAME)
              .forEach(
                  assignment -> {
                    PartitionDTO partitionDTO = readPartition(assignment);
                    Preconditions.checkArgument(
                        partitionDTO instanceof RangePartitionDTO,
                        "Cannot parse range partitioning from non-range assignment: %s",
                        assignment);
                    rangeAssignments.add((RangePartitionDTO) partitionDTO);
                  });
          return RangePartitioningDTO.of(
              fields, rangeAssignments.toArray(new RangePartitionDTO[0]));

        case FUNCTION:
          String functionName = getString(FUNCTION_NAME, node);
          Preconditions.checkArgument(
              node.has(FUNCTION_ARGS),
              "Cannot parse function partitioning from missing function args: %s",
              node);
          List<FunctionArg> args = Lists.newArrayList();
          node.get(FUNCTION_ARGS).forEach(arg -> args.add(readFunctionArg(arg)));
          return FunctionPartitioningDTO.of(functionName, args.toArray(FunctionArg.EMPTY_ARGS));

        default:
          throw new IOException("Unknown partitioning strategy: " + strategy);
      }
    }