Problem with join fetch in library

[ThienPhuc92]

Hi Darrachequese,

The first, my english is not very well, so maybe some thing i explain about your problem will make you confusing. I'm sorry about that.

I had use your library, but i think your library has some problem.

Your code:

// add JOIN FETCH when necessary
      for (Column column : input.getColumns()) {
        boolean isJoinable =
            column.getSearchable() && column.getData().contains(ATTRIBUTE_SEPARATOR);
        if (!isJoinable) {
          continue;
        }
        String[] values = column.getData().split(ESCAPED_ATTRIBUTE_SEPARATOR);
        PersistentAttributeType type =
            root.getModel().getAttribute(values[0]).getPersistentAttributeType();
        if (type != PersistentAttributeType.ONE_TO_ONE
            && type != PersistentAttributeType.MANY_TO_ONE) {
          continue;
        }
        Fetch<?, ?> fetch = null;
        for (int i = 0; i < values.length - 1; i++) {
          fetch = (fetch == null ? root : fetch).fetch(values[i], JoinType.LEFT);
        }
      }

• Each column, you will join fetch table. But if column in a same table, it will make very much join fetch query. This is very bad performance.
• You cannot add a right predicate in some case:
  Example:
  You join fetch 2 table: A, B, then you want to find all result with predicate p1, and predicate p2 on table B.
  your query will be -> SELECT * FROM A a1 JOIN FETCH a1.b b1 JOIN FETCH a1.b b2 WHERE (b1 has p1) AND (b2 has p2).

Right query: SELECT * FROM A a1 JOIN FETCH a1.b b1 WHERE (b1 has p1) AND (b1 has p2)

I resolved this by i convert all column into a tree. A tree will ensure no column duplicate. So i can make right query. But my code is not clean. I wish you improve your library. Some of my code. Hope you consider it to me

@Override
	public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
		List<Predicate> predicates = new ArrayList<Predicate>();

		TreeDataTable tree = convertToTree(input.getColumns(), input.getOrder().get(0));

		boolean isCountQuery = query.getResultType() == Long.class;
		if (isCountQuery) {
			predicates.add(cb.and(joinTree(root, cb, tree).toArray(new Predicate[] {})));
		} else {
			predicates.add(cb.and(fetchTree(root, query, cb, tree).toArray(new Predicate[] {})));
		}
		
		if(!subSpecs.isEmpty()) {			
			for(Specification<T> subSpec : subSpecs) {
				predicates.add(cb.and(subSpec.toPredicate(root, query, cb)));
			}
		}

		query.distinct(true);

		return cb.and(predicates.toArray(new Predicate[] {}));
	}


public List<Predicate> fetchTree(From<?, ?> from, CriteriaQuery<?> query, CriteriaBuilder builder,
			TreeDataTable tree) {
		List<Predicate> predicates = new ArrayList<Predicate>(0);

		for (TreeDataTable treeChild : tree.getSubTrees()) {
			boolean isHasChild = treeChild.isHasChild();

			boolean isColumnOrderable = (StringUtils.hasText(treeChild.getHead().getDir()) && !isHasChild);

			String treeName = treeChild.getHead().getName();
			JoinType treeJoinType = treeChild.getHead().getJoinType();
			Class classType = treeChild.getHead().getClassType();
			HashMap<String, String> expressions = treeChild.getHead().getExpression();

			if (isHasChild) {
				Fetch<?, ?> subFetch = from.fetch(treeName, treeJoinType);
				predicates.addAll(fetchTree((From<?, ?>) subFetch, query, builder, treeChild));
			} else {
				predicates.addAll(getPredicates(from, builder, treeName, classType, expressions));

				if (isColumnOrderable) {
					if (treeChild.getHead().getDir().equalsIgnoreCase("asc")) {
						query.orderBy(builder.asc(from.get(treeName)));
					} else {
						query.orderBy(builder.desc(from.get(treeName)));
					}
				}
			}
		}

		return predicates;
	}

Edit: code style

[darrachequesne]

Hi, sorry for the delay!

It seems you're absolutely right, that's something we should fix. Could you provide the code of the convertToTree method?