| com.db4o.query.Constraint
All known Subclasses: com.db4o.internal.query.processor.QCon, com.db4o.internal.cluster.ClusterConstraint,
| Constraint | | public interface Constraint (Code) | | constraint to limit the objects returned upon
Query.execute query execution .
Constraints are constructed by calling
Query.constrain(Object) .
Constraints can be joined with the methods
Constraint.and and
Constraint.or .
The methods to modify the constraint evaluation algorithm may
be merged, to construct combined evaluation rules.
Examples:
-
Constraint#smaller().equal() for "smaller or equal"
-
Constraint#not().like() for "not like"
-
Constraint#not().greater().equal() for "not greater or equal"
|
| and | | public Constraint and(Constraint with)(Code) | | 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 a new Constraint, that can be used for further callsto Constraint.and and() and Constraint.or or() |
| contains | | public Constraint contains()(Code) | | sets the evaluation mode to containment comparison.
For example:
Pilot pilot1 = new Pilot("Test 1", 1);
list.add(pilot1);
Pilot pilot2 = new Pilot("Test 2", 2);
list.add(pilot2);
Team team = new Team("Ferrari", list);
container.set(team);
Query query = container.query();
query.constrain(Team.class);
query.descend("pilots").constrain(pilot2).contains();
will return the Team object as it contains pilot2.
If applied to a String object, this constrain will behave as
Constraint.like() .
this Constraint to allow the chaining of method calls. |
| endsWith | | public Constraint endsWith(boolean caseSensitive)(Code) | | sets the evaluation mode to string endsWith comparison.
For example:
Pilot pilot = new Pilot("Test Pilot0", 100);
container.set(pilot);
...
query.constrain(Pilot.class);
query.descend("name").constrain("T0").endsWith(false);
Parameters:
caseSensitive - comparison will be case sensitive if true, case insensitive otherwise this Constraint to allow the chaining of method calls. |
| equal | | public Constraint equal()(Code) | | Used in conjunction with
Constraint.smaller() or
Constraint.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.
this Constraint to allow the chaining of method calls. |
| getObject | | public Object getObject()(Code) | | returns the Object the query graph was constrained with to
create this
Constraint .
Object the constraining object. |
| greater | | public Constraint greater()(Code) | | sets the evaluation mode to >.
For example:
query.constrain(Pilot.class);
query.descend("points").constrain(101).greater()
will return all pilots with points > 101.
this Constraint to allow the chaining of method calls. |
| identity | | public Constraint identity()(Code) | | 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("BMW", pilot);
container.set(car);
// Change the name, the pilot instance stays the same
pilot.setName("Test Pilot2");
// create a new car
car = new Car("Ferrari", pilot);
container.set(car);
Query query = container.query();
query.constrain(Car.class);
// All cars having pilot with the same database identity
// will be retrieved. As we only created Pilot object once
// it should mean all car objects
query.descend("_pilot").constrain(pilot).identity();
this Constraint to allow the chaining of method calls. |
| like | | public Constraint like()(Code) | | sets the evaluation mode to "like" comparison. 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.set(pilot);
...
query.constrain(Pilot.class);
// All pilots with the name containing "est" will be retrieved
query.descend("name").constrain("est").like();
this Constraint to allow the chaining of method calls. |
| not | | public Constraint not()(Code) | | turns on not() comparison. All objects not fullfilling the constrain condition will be returned.
For example:
Pilot pilot = new Pilot("Test Pilot1", 100);
container.set(pilot);
...
query.constrain(Pilot.class);
query.descend("name").constrain("t0").endsWith(true).not();
this Constraint to allow the chaining of method calls. |
| or | | public Constraint or(Constraint with)(Code) | | 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 a new Constraint, that can be used for further callsto Constraint.and and() and Constraint.or or() |
| smaller | | public Constraint smaller()(Code) | | sets the evaluation mode to <.
For example:
query.constrain(Pilot.class);
query.descend("points").constrain(101).smaller()
will return all pilots with points < 101.
this Constraint to allow the chaining of method calls. |
| startsWith | | public Constraint startsWith(boolean caseSensitive)(Code) | | sets the evaluation mode to string startsWith comparison.
For example:
Pilot pilot = new Pilot("Test Pilot0", 100);
container.set(pilot);
...
query.constrain(Pilot.class);
query.descend("name").constrain("Test").startsWith(true);
Parameters:
caseSensitive - comparison will be case sensitive if true, case insensitive otherwise this Constraint to allow the chaining of method calls. |
|
|