Package com.db4o.query

Interface Constraint

    • Method Detail

      • and

        Constraint and​(Constraint with)
        Links two Constraints for AND evaluation. For example:
         query.constrain(Pilot.class);
 query.descend("points").constrain(101).smaller().and(query.descend("name").constrain("Test Pilot0"));

        will retrieve all pilots with points less than 101 and name as "Test Pilot0"
        Parameters:
        with - the other Constraint
        Returns:
        a new Constraint, that can be used for further calls to and(Constraint) and or(Constraint)

      • or

        Constraint or​(Constraint with)
        Links two Constraints for OR evaluation. For example:

         query.constrain(Pilot.class);
 query.descend("points").constrain(101).greater().or(query.descend("name").constrain("Test Pilot0"));

        will retrieve all pilots with points more than 101 or pilots with the name "Test Pilot0"
        Parameters:
        with - the other Constraint
        Returns:
        a new Constraint, that can be used for further calls to and(Constraint) and or(Constraint)

      • equal

        Constraint equal()
        Used in conjunction with smaller() or greater() to create constraints like "smaller or equal", "greater or equal". For example:
         query.constrain(Pilot.class);
 query.descend("points").constrain(101).smaller().equal();

        will return all pilots with points <= 101.
        Returns:
        this Constraint to allow the chaining of method calls.

      • greater

        Constraint greater()
        Sets the evaluation mode to >. For example:
         query.constrain(Pilot.class);
 query.descend("points").constrain(101).greater()

        will return all pilots with points > 101.
        Returns:
        this Constraint to allow the chaining of method calls.

      • smaller

        Constraint smaller()
        Sets the evaluation mode to <. For example:
         query.constrain(Pilot.class);
 query.descend("points").constrain(101).smaller()

        will return all pilots with points < 101.
        Returns:
        this Constraint to allow the chaining of method calls.

      • identity

        Constraint identity()
        Sets the evaluation mode to identity comparison. In this case only objects having the same database identity will be included in the result set. For example:
         Pilot pilot = new Pilot("Test Pilot1", 100);
 Car car = new Car("Ferrari", pilot);
 container.store(car);
 Car otherCar = new Car("Ferrari", pilot);
 container.store(otherCar);
 Query query = container.query();
 query.constrain(Car.class);
 // All cars having pilot with the same database identity
 // will be retrieved.
 query.descend("pilot").constrain(pilot).identity();


        Returns:
        this Constraint to allow the chaining of method calls.

      • byExample

        Constraint byExample()
        Set the evaluation mode to object comparison (query by example).
        Returns:
        this to allow the chaining of method calls.

      • like

        Constraint like()
        Sets the evaluation mode to "like" comparison. This is a contains comparison which is case insensitive. This only works on strings. This mode will include all objects having the constrain expression somewhere inside the string field. For example:
         Pilot pilot = new Pilot("Test Pilot1", 100);
 container.store(pilot);
  ...
 query.constrain(Pilot.class);
 // All pilots with the name containing "est" will be retrieved
 query.descend("name").constrain("est").like();

        Returns:
        this to allow the chaining of method calls.

      • contains

        Constraint contains()
        Sets the evaluation mode to string contains comparison. This only works on strings. The contains comparison is case sensitive. For example:
         Pilot pilot = new Pilot("Test Pilot1", 100);
 container.store(pilot);
  ...
 query.constrain(Pilot.class);
 // All pilots with the name containing "est" will be retrieved
 query.descend("name").constrain("est").contains();

        Returns:
        this to allow the chaining of method calls.
        See Also:
        like() for case insensitive string comparison

      • startsWith

        Constraint startsWith​(boolean caseSensitive)
        Sets the evaluation mode to string startsWith comparison. For example:
         Pilot pilot = new Pilot("Test Pilot0", 100);
 container.store(pilot);
  ...
 query.constrain(Pilot.class);
 query.descend("name").constrain("Test").startsWith(true);

        Parameters:
        caseSensitive - comparison will be case sensitive if true, case insensitive otherwise
        Returns:
        this to allow the chaining of method calls.

      • endsWith

        Constraint endsWith​(boolean caseSensitive)
        Sets the evaluation mode to string endsWith comparison. For example:
         Pilot pilot = new Pilot("Test Pilot0", 100);
 container.store(pilot);
  ...
        
 query.constrain(Pilot.class);
 query.descend("name").constrain("T0").endsWith(false);

        Parameters:
        caseSensitive - comparison will be case sensitive if true, case insensitive otherwise
        Returns:
        this to allow the chaining of method calls.

      • not

        Constraint not()
        Turns on not() comparison. All objects not full filling the constrain condition will be returned. For example:
         Pilot pilot = new Pilot("Test Pilot1", 100);
 container.store(pilot);
  ...
 query.constrain(Pilot.class);
 query.descend("name").constrain("t0").endsWith(true).not();

        Returns:
        this Constraint to allow the chaining of method calls.

      • getObject

        java.lang.Object getObject()
        Returns the Object the query graph was constrained with to create this Constraint.
        Returns:
        Object the constraining object.