Message Title

To be more precise...

The problem I was referring to is that, currently, setProjection mutates the FullTextQuery, making the type returned by a given FullTextQuery change at runtime.

For instance:

 
                                                                FullTextQuery<Foo> query = session.createFullTextQuery( query, Foo.class ); // query.list() would return "List<Foo>"
query.setProjection( "someField" ); // query.list() would now return "List<Object[]>", but obviously the type of query did not change!
List<Foo> results = query.list(); // Here be dragons: results is not a List<Foo>, but a List<Object[]>. Someone will have an unpleasant suprise...

I agree there is a user mistake in this code, but the purpose of typing is precisely to avoid that kind of mistake, so we're not really making our API better here.

As discussed on HipChat, we could avoid this issue by removing setProjection and replacing it with a non-mutating method that would return a new instance, let's say ".withProjection":

 
                                                                FullTextQuery<Foo> query = session.createFullTextQuery( query, Foo.class ); // query.list() would return "List<Foo>"
query.withProjection( "someField" ); // query.list() still returns a List<Foo> ; the returned object is ignored, which could be detected by static code analysis tools (Sonar, ...)
List<Foo> results = query.list(); // Will work

Which would then be, with correct code:

 
                                                                FullTextQuery<Foo> query = session.createFullTextQuery( query, Foo.class );
FullTextQuery<Object[]> projectedQuery = query.withProjection( "someField" );
List<Object[]> results = projectedQuery.list();

Assuming setResultTransformer (which has the exact same problem) was fixed the same way (by making ResultTransformer generic), we'd still have an issue:

 
                                                                ResultTransformer<T> myTransformer = ... ;
session.createFullTextQuery( query, Foo.class )
  .withProjection( "someField" )
  .withResultTransformer( myTransformer ); // Returns FullTextQuery<T>, which matches the actual result type

session.createFullTextQuery( query, Foo.class )
  .withResultTransformer( myTransformer )
  .withProjection( "someField" ); // Returns FullTextQuery<Object[]>, but the actual result type is T, because we have a result transformer!

Also, we'd have yet another issue with the behavior described in HSEARCH-2225 Open (see the comments there).

So... Yes, I think we'll need to think about it

Add Comment

This message was sent by Atlassian JIRA