> Query<Customer> custQuery = Ebean.find(Customer.class);
> custQuery.where().startWith("name", "A");

> Query<Order> custOrderQuery = custQuery.findMany("orders",
> Order.class);
> custOrderQuery.where().eg("status", Order.Status.NEW).gt("orderDate",
> lastWeek);

> But this might be too much work, no?

> > Daryl, Mario ... are you happy to go with Option 2 ?

> Yep, 2 seems good to me!

> > Ebean.find(Customer.class)
> >   .where().startsWith("name","A")
> >   .*filterMany()*.eq("orders.status",
> > Order.Status.NEW).gt("orders.orderDate", lastWeek)

> Hmmm ... about the filterMany() api.

> In the above statement it is not clear which relation is filtered. If
> you mix filtering *ToMay and Root-Filtering you might get confused.

> At least adding the relation name on filterMany() might be required:

> Ebean.find(Customer.class)
>    .where().startsWith("name","A")
>     .*filterMany("orders")*.eq("orders.status",
>     Order.Status.NEW).gt("orders.orderDate", lastWeek)

> ... or what about that:

> Query<Customer> custQuery = Ebean.find(Customer.class);
> custQuery.where().startWith("name", "A");

> Query<Order> custOrderQuery = custQuery.findMany("orders",
> Order.class);
> custOrderQuery.where().eg("status", Order.Status.NEW).gt("orderDate",
> lastWeek);

> But this might be too much work, no?

> Ciao,
> Mario

> > Query<Order> custOrderQuery = custQuery.findMany("orders",
> > Order.class);
> > custOrderQuery.where().eg("status", Order.Status.NEW).gt("orderDate",
> > lastWeek);

> > > Query<Order> custOrderQuery = custQuery.findMany("orders",
> > > Order.class);
> > > custOrderQuery.where().eg("status", Order.Status.NEW).gt("orderDate",
> > > lastWeek);

> Yea, my example was not quite right - probably this makes more sense?

> Query<Customer> custQuery = Ebean.find(Customer.class);
> custQuery.where().startWith("name", "A");

> ExpressionList<Order> custOrderQuery = custQuery.findMany("orders",
> Order.class);
> custOrderQuery.eg("status", Order.Status.NEW).gt("orderDate",
> lastWeek);

> List<Customer> list = custQuery.findList();

> Point is, that I think the findMany() should return some sort of
> "other" query which one should configure the filter instead of simply
> "streamlining" it into a normal query. I think that makes it clearer
> what the result of the criteria will be. For all the eq/gt etc

> Next, what if you need to join custQuery and custOrderQuery? Then we
> would need something like this:

> custOrderQuery.eq("xyz", custQuery.getProperty("xyz"));

> I would like that syntax, even for the normal "query.join" as then you
> do not have to take care about the alias stuff.

> In fact, in our application I've create a slim query wrapper which
> simulates that syntax.

> Ciao,
> Mario

> Maybe I misunderstood this... but I don't think this makes sense at the sql
> level.  The joins have different cardinality and are effectively
> independent.

> > Maybe I misunderstood this... but I don't think this makes sense at the
> sql
> > level.  The joins have different cardinality and are effectively
> > independent.

> Yep, it is not required to fix this filter thing. I just thought about
> it as additional feature ... but yes, nothing we have to address yet.

> Ciao,
> Mario

> I'd suggest as filtered but not sure.

> On Mar 9, 2:24 am, Rob Bygrave <robin.bygr...@gmail.com> wrote:
> > > Will it reload the collection as filtered or load the full list?

> > I'd suggest as filtered but not sure.

> Yeah, that's a tough one. I'm not sure what I'd expect it to do.

> /Daryl

> This is now in head and deployed to:

> http://www.avaje.org/archiva/repository/snapshots/org/avaje/ebean/2.5...

> I will do some work on the filterMany part aiming for something like
> Mario's last suggestion and see how that goes.

> Query<Customer> rootQuery = ...

> ExpressionList<Order> ordersFilter =
> rootQuery.filterMany("orders",Order.class);
> ordersFilter.eq("status", Order.Status.NEW).gt("orderDate", lastWeek);

> ...

> On Wed, Mar 10, 2010 at 10:23 AM, Daryl Stultz <kungfumachin...@gmail.com>wrote:

>> On Mar 9, 2:24 am, Rob Bygrave <robin.bygr...@gmail.com> wrote:
>> > > Will it reload the collection as filtered or load the full list?

>> > I'd suggest as filtered but not sure.

>> Yeah, that's a tough one. I'm not sure what I'd expect it to do.

>> /Daryl

> // the filter is remembered and applied on refresh
> Ebean.refreshMany(customer, "orders");

> On Mar 11, 2:53 pm, Rob Bygrave <robin.bygr...@gmail.com> wrote:

> Hi Rob, thanks for working on this. I've updated and rebuilt from
> source.

> > NB: At this point a refresh on the many property ... will apply/preserve
> the
> > filter.

> > // the filter is remembered and applied on refresh
> > Ebean.refreshMany(customer, "orders");

> I don't see this behavior. Maybe I'm not understanding things. Here's
> my test. I have one user with 2 validRoles, role1 and role2.

> List<Integer> roleIds = new ArrayList<Integer>();
> roleIds.add(role1.getId());
> List<User> userResults =
> Ebean.find(User.class).join("validRoles").where().in("validRoles.id",
> roleIds).findList();
> assertEquals(1, userResults.size());
> User resultUser = userResults.get(0);
> assertEquals(user, resultUser);
> assertEquals(2, resultUser.getValidRoles().size()); // used to return
> filtered
> Ebean.refreshMany(resultUser, "validRoles");
> assertEquals(2, resultUser.getValidRoles().size());

> userResults = Ebean.find(User.class).join("validRoles")
>        .where().in("validRoles.id", roleIds) // roleIds contains only role1
> id
>        .filterMany("validRoles").eq("name", "role2")
>        .findList();
> assertEquals(1, userResults.size());
> resultUser = userResults.get(0);
> assertEquals(user, resultUser);
> assertEquals(1, resultUser.getValidRoles().size());
> assertEquals(role2, resultUser.getValidRoles().get(0));
> Ebean.refreshMany(resultUser, "validRoles");
> assertEquals(1, resultUser.getValidRoles().size()); // expected 1 but
> was 2

> It fails on the last line. So I'm restricting user by role1 and
> filtering validRoles by role2. It works until the refresh.

> /Daryl