db4o 7.4

com.db4o.query
Interface Constraint

All Known Subinterfaces:
Constraints

public interface Constraint

constraint to limit the objects returned upon query execution.

Constraints are constructed by calling Query.constrain(Object).

Constraints can be joined with the methods and(com.db4o.query.Constraint) and or(com.db4o.query.Constraint).

The methods to modify the constraint evaluation algorithm may be merged, to construct combined evaluation rules. Examples:


Method Summary
 Constraint and(Constraint with)
          links two Constraints for AND evaluation.
 Constraint byExample()
          set the evaluation mode to object comparison (query by example).
 Constraint contains()
          sets the evaluation mode to containment comparison.
 Constraint endsWith(boolean caseSensitive)
          sets the evaluation mode to string endsWith comparison.
 Constraint equal()
          Used in conjunction with smaller() or greater() to create constraints like "smaller or equal", "greater or equal".
 java.lang.Object getObject()
          returns the Object the query graph was constrained with to create this Constraint.
 Constraint greater()
          sets the evaluation mode to >.
 Constraint identity()
          sets the evaluation mode to identity comparison.
 Constraint like()
          sets the evaluation mode to "like" comparison.
 Constraint not()
          turns on not() comparison.
 Constraint or(Constraint with)
          links two Constraints for OR evaluation.
 Constraint smaller()
          sets the evaluation mode to <.
 Constraint startsWith(boolean caseSensitive)
          sets the evaluation mode to string startsWith comparison.
 

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() and or()

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() and or()

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("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();

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 Constraint to allow the chaining of method calls.

like

Constraint like()
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();

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

contains

Constraint contains()
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 like().

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

startsWith

Constraint startsWith(boolean caseSensitive)
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
Returns:
this Constraint 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.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
Returns:
this Constraint to allow the chaining of method calls.

not

Constraint not()
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();

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.

db4o 7.4

Copyright 2007 db4objects Inc. All rights reserved.