How to use

DetachableMixin

in

com.mysema.query.support

public DetachableQuery(QueryMixin<Q> queryMixin) {
  super(queryMixin);
  this.detachableMixin = new DetachableMixin(queryMixin);
}

@Override
public ListSubQuery<Tuple> list(Object... args) {
  return list(convert(args));
}

@Override
public NumberSubQuery<Long> count() {
  return detachableMixin.count();
}

@Override
public SimpleSubQuery<Tuple> unique(Object... args) {
  return unique(convert(args));
}

@Override
public <RT extends Comparable<?>> ComparableSubQuery<RT> unique(ComparableExpression<RT> projection) {
  return detachableMixin.unique(projection);
}

@Override
public StringSubQuery unique(StringExpression projection) {
  return new StringSubQuery(uniqueProjection(projection));
}

@Override
public ListSubQuery<Tuple> list(Expression<?>... args) {
  return new ListSubQuery<Tuple>(Tuple.class, projection(args));
}

@Override
public ListSubQuery<Tuple> list(Object... args) {
  return detachableMixin.list(args);
}

@Override
public BooleanExpression exists() {
  return detachableMixin.exists();
}

private Expression<?>[] convert(Object... args) {
  final Expression<?>[] exprs = new Expression[args.length];
  for (int i = 0; i < exprs.length; i++) {
    exprs[i] = convert(args[i]);
  }
  return exprs;
}

@Override
public BooleanExpression notExists() {
  return detachableMixin.notExists();
}

private QueryMetadata projection(Expression<?>... projection) {
  QueryMetadata metadata = queryMixin.getMetadata().clone();
  for (Expression<?> expr : projection) {
    expr = queryMixin.convert(expr, false);
    metadata.addProjection(nullAsTemplate(expr));
  }
  return metadata;
}

@Override
public StringSubQuery unique(StringExpression projection) {
  return detachableMixin.unique(projection);
}

@Override
public SimpleSubQuery<Tuple> unique(Expression<?>... args) {
  return new SimpleSubQuery<Tuple>(Tuple.class, uniqueProjection(args));
}

private QueryMetadata uniqueProjection(Expression<?>... projection) {
  QueryMetadata metadata = projection(projection);
  metadata.setUnique(true);
  return metadata;
}

public ListSubQuery<Tuple> list(Object arg) {
  return detachableMixin.list(arg);
}

@Override
public BooleanExpression notExists() {
  return exists().not();
}

@Override
public <RT extends Number & Comparable<?>> NumberSubQuery<RT> unique(NumberExpression<RT> projection) {
  return detachableMixin.unique(projection);
}

@Override
public BooleanSubQuery unique(Predicate projection) {
  return new BooleanSubQuery(uniqueProjection(projection));
}

public ListSubQuery<Tuple> list(Object arg) {
  return list((Expression)convert(arg));
}