public static String getTargetSql()

in v2/googlecloud-to-neo4j/src/main/java/com/google/cloud/teleport/v2/neo4j/utils/ModelUtils.java [86:186]
92 lines of code
24 McCabe index (conditional complexity)

  public static String getTargetSql(
      Target target,
      NodeTarget startNodeTarget,
      NodeTarget endNodeTarget,
      Set<String> fieldNameMap,
      boolean generateSqlSort,
      String baseSql) {

    TargetType targetType = target.getTargetType();
    if (targetType != TargetType.NODE && targetType != TargetType.RELATIONSHIP) {
      throw new IllegalArgumentException(
          String.format("Expected node or relationship target, got %s", targetType));
    }

    var entityTarget = (EntityTarget) target;
    var transformations = entityTarget.getSourceTransformations();
    try {
      var statement = new PlainSelect();
      statement.withFromItem(new Table("PCOLLECTION"));
      if (generateSqlSort) {
        List<OrderByElement> orderBy = new ArrayList<>();
        if (targetType == TargetType.RELATIONSHIP) {
          var reversedMappings =
              endNodeTarget.getProperties().stream()
                  .collect(
                      Collectors.toMap(
                          PropertyMapping::getTargetProperty, PropertyMapping::getSourceField));
          for (String key : endNodeTarget.getKeyProperties()) {
            String keyField = reversedMappings.get(key);
            String field = CypherPatterns.sanitize(keyField);
            orderBy.add(
                new OrderByElement().withExpression(CCJSqlParserUtil.parseExpression(field)));
          }
        }
        if (orderBy.isEmpty() && transformations != null) {
          for (OrderBy orderByClause : transformations.getOrderByClauses()) {
            orderBy.add(convertToJsqlElement(orderByClause));
          }
        }

        if (!orderBy.isEmpty()) {
          statement.withOrderByElements(orderBy);
        }
      }

      if (transformations != null) {
        /////////////////////////////////
        // Grouping transform
        List<Aggregation> aggregations = transformations.getAggregations();
        if (transformations.isEnableGrouping() || !aggregations.isEmpty()) {
          Set<PropertyMapping> allProperties =
              allPropertyMappings(entityTarget, startNodeTarget, endNodeTarget);
          Column[] groupByFields =
              allProperties.stream()
                  .map(PropertyMapping::getSourceField)
                  .filter(fieldNameMap::contains)
                  .map(field -> new Column(CypherPatterns.sanitize(field)))
                  .toArray(Column[]::new);
          if (groupByFields.length == 0) {
            throw new RuntimeException(
                String.format(
                    "Could not find mapped fields for target: %s. Please verify that target fields exist in source query.",
                    target.getName()));
          }
          statement.addSelectItems(groupByFields);
          if (!aggregations.isEmpty()) {
            for (Aggregation aggregation : aggregations) {
              String keyField = aggregation.getFieldName();
              statement.addSelectItem(
                  CCJSqlParserUtil.parseExpression(aggregation.getExpression()),
                  new Alias(CypherPatterns.sanitize(keyField)));
            }
          }

          String whereClause = transformations.getWhereClause();
          if (StringUtils.isNotBlank(whereClause)) {
            statement.withWhere(CCJSqlParserUtil.parseExpression(whereClause));
          }
          for (Column groupByField : groupByFields) {
            statement.addGroupByColumnReference(groupByField);
          }
          var limit = transformations.getLimit() != null ? transformations.getLimit() : -1;
          if (limit > -1) {
            statement.setLimit(new Limit().withRowCount(new LongValue(limit)));
          }
        }
      }

      if (statement.getSelectItems() == null || statement.getSelectItems().isEmpty()) {
        statement.addSelectItems(new AllColumns());
      }

      String statementText = statement.toString();
      if (StringUtils.isNotBlank(baseSql)) {
        statementText = statementText.replace("PCOLLECTION", String.format("(%s)", baseSql));
      }
      return statementText;
    } catch (JSQLParserException e) {
      throw new RuntimeException(e);
    }
  }