Mongo的ORM框架的学习Morphia(十二) morphia的Query和Update
转自：http://topmanopensource.iyunv.com/blog/1449074一：
morphia的Update
... /** updates all entities found with the operations*/
<T> UpdateResults<T> update(Query<T> query, UpdateOperations<T> ops);
/** updates all entities found with the operations; if nothing is found insert the update as an entity if "createIfMissing" is true*/ <T> UpdateResults<T> update(Query<T> query, UpdateOperations<T> ops, boolean createIfMissing);
/** updates the first entity found with the operations*/
<T> UpdateResults<T> updateFirst(Query<T> query, UpdateOperations<T> ops);
/** updates the first entity found with the operations; if nothing is found insert the update as an entity if "createIfMissing" is true*/ <T> UpdateResults<T> updateFirst(Query<T> query, UpdateOperations<T> ops, boolean createIfMissing);
/** updates the first entity found with the operations; if nothing is found insert the update as an entity if "createIfMissing" is true*/ <T> UpdateResults<T> updateFirst(Query<T> query, T entity, boolean createIfMissing); }
public interface UpdateOperations<T> {
/** sets the field value */
UpdateOperations<T> set(String fieldExpr, Object value);
/** removes the field */
UpdateOperations<T> unset(String fieldExpr);
/** adds the value to an array field*/
UpdateOperations<T> add(String fieldExpr, Object value); UpdateOperations<T> add(String fieldExpr, Object value, boolean addDups);
/** adds the values to an array field*/ UpdateOperations<T> addAll(String fieldExpr, List<?> values, boolean addDups);
/** removes the first value from the array*/ UpdateOperations<T> removeFirst(String fieldExpr);
/** removes the last value from the array*/
UpdateOperations<T> removeLast(String fieldExpr);
/** removes the value from the array field*/
UpdateOperations<T> removeAll(String fieldExpr, Object value);
/** removes the values from the array field*/
UpdateOperations<T> removeAll(String fieldExpr, List<?> values);
/** decrements the numeric field by 1*/
UpdateOperations<T> dec(String fieldExpr);
/** increments the numeric field by 1*/
UpdateOperations<T> inc(String fieldExpr);
/** increments the numeric field by value (negatives are allowed)*/
UpdateOperations<T> inc(String fieldExpr, Number value); }The Field Expression
初始化：
Morphia morphia = new Morphia();
morphia.map(Hotel.class).map(Address.class);
Datastore datastore = morphia.createDatastore("MorphiaSampleDb");
Hotel hotel = new Hotel("Fairmont", 3, new Address("1 Rideau Street", "Ottawa", "K1N8S7", "Canada"));
datastore.save(hotel);
UpdateOperations<Hotel> ops;
// This query will be used in the samples to restrict the update operations to only the hotel we just created.
// If this was not supplied, by default the update() operates on all documents in the collection.
// We could use any field here but _id will be unique and mongodb by default puts an index on the _id field so this should be fast!
Query<Hotel> updateQuery = datastore.createQuery(Hotel.class).field("_id").equal(hotel.getId());
// The Mapper class also provides a public static of the default _id field name for us...
Query<Hotel> updateQuery = datastore.createQuery(Hotel.class).field(Mapper.ID_KEY).equal(hotel.getId());
set/unset
// change the name of the hotel
ops = datastore.createUpdateOperations(Hotel.class).set("name", "Fairmont Chateau Laurier");
datastore.update(updateQuery, ops);
// also works for embedded documents, change the name of the city in the address
ops = datastore.createUpdateOperations(Hotel.class).set("address.city", "Ottawa");
datastore.update(updateQuery, ops);
// remove the name property from the document
// causes the next load of the Hotel to have name = null
ops = datastore.createUpdateOperations(Hotel.class).unset("name");
datastore.update(updateQuery, ops);
inc/dec
// increment 'stars' by 1
ops = datastore.createUpdateOperations(Hotel.class).inc("stars");
datastore.update(updateQuery, ops);
// increment 'stars' by 4
ops = datastore.createUpdateOperations(Hotel.class).inc("stars", 4);
datastore.update(updateQuery, ops);
// decrement 'stars' by 1
ops = datastore.createUpdateOperations(Hotel.class).dec("stars");
// same as .inc("stars", -1)
datastore.update(updateQuery, ops);
// decrement 'stars' by 4
ops = datastore.createUpdateOperations(Hotel.class).inc("stars", -4);
datastore.update(updateQuery, ops);
add/All
// push a value onto an array() (+v 0.95)
// same as .add("roomNumbers", 11, false)
ops = datastore.createUpdateOperations(Hotel.class).add("roomNumbers", 11);
datastore.update(updateQuery, ops);// [ 11 ]
// Performing array operations on a non-array property causes mongodb to throw an error.
ops = datastore.createUpdateOperations(Hotel.class).set("roomNumbers", 11);
datastore.update(updateQuery, ops);
// causes error since 'roomNumbers' is not an array at this point
ops = datastore.createUpdateOperations(Hotel.class).add("roomNumbers", 11, false);
datastore.update(updateQuery, ops);// causes error
// delete the property
ops = datastore.createUpdateOperations(Hotel.class).unset("roomNumbers");
datastore.update(updateQuery, ops);
// use the 3rd parameter to add duplicates
// add to end of array, same as add()
ops = datastore.createUpdateOperations(Hotel.class).add("roomNumbers", 11, false);
datastore.update(updateQuery, ops);// [ 11 ]
// no change since its a duplicate... doesn't cause error
ops = datastore.createUpdateOperations(Hotel.class).add("roomNumbers", 11, false);
datastore.update(updateQuery, ops);// [ 11 ]
// push onto the end of the array
ops = datastore.createUpdateOperations(Hotel.class).add("roomNumbers", 12, false);
datastore.update(updateQuery, ops); // [ 11, 12 ]
// add even if its a duplicate
ops = datastore.createUpdateOperations(Hotel.class).add("roomNumbers", 11, true);
datastore.update(updateQuery, ops); // [ 11, 12, 11 ]
removeFirst/Last/All
//given roomNumbers = [ 1, 2, 3 ]
ops = datastore.createUpdateOperations(Hotel.class).removeFirst("roomNumbers");
datastore.update(updateQuery, ops);// [ 2, 3 ]
//given roomNumbers = [ 1, 2, 3 ]
ops = datastore.createUpdateOperations(Hotel.class).removeLast("roomNumbers");
datastore.update(updateQuery, ops);// [ 1, 2 ]
ops = datastore.createUpdateOperations(Hotel.class).removeLast("roomNumbers");
datastore.update(updateQuery, ops);// [ 1 ]
ops = datastore.createUpdateOperations(Hotel.class).removeLast("roomNumbers");
datastore.update(updateQuery, ops);// [] empty array
//given roomNumbers = [ 1, 2, 3, 3 ]
ops = datastore.createUpdateOperations(Hotel.class).removeAll("roomNumbers", 3);
datastore.update(updateQuery, ops);// [ 1, 2 ]
//given roomNumbers = [ 1, 2, 3, 3 ]
ops = datastore.createUpdateOperations(Hotel.class).removeAll("roomNumbers", Arrays.asList(2, 3));
datastore.update(updateQuery, ops);// [ 1 ]
Multiple Operations
//You can also perform multiple update operations within a single update.
//set city to Ottawa and increment stars by 1
ops = datastore.createUpdateOperations(Hotel.class).set("city", "Ottawa").inc("stars");
datastore.update(updateQuery, ops);
//if you perform multiple operations in one command on the same property, results will vary
ops = datastore.createUpdateOperations(Hotel.class).inc("stars", 50).inc("stars");//increments by 1
ops = datastore.createUpdateOperations(Hotel.class).inc("stars").inc("stars", 50);//increments by 50
//you can't apply conflicting operations to the same property
ops = datastore.createUpdateOperations(Hotel.class).set("stars", 1).inc("stars", 50); //causes error
updateFirst method
//In the default driver and shell this is the default behavior. In Morphia we feel like updating all the results of the query is a better default (see below).
//{ name: "Fairmont", stars: 5}, { name: "Last Chance", stars: 3 }
ops = datastore.createUpdateOperations(Hotel.class).inc("stars", 50);
// (+v 0.95 now takes into account the order())
// morphia exposes a specific updateFirst to update only the first hotel matching the query
datastore.updateFirst(datastore.find(Hotel.class).order("stars"), ops);// update only Last Chance
datastore.updateFirst(datastore.find(Hotel.class).order("-stars"), ops); // update only Fairmont
//default shell version is to match first
//shell version has a multi to indicate to update all matches, not just first
//to mimic morphia operation, set multi = false
db.collection.update( criteria, objNew, upsert, multi );
update method
ops = datastore.createUpdateOperations(Hotel.class).inc("stars", 50);
// morphia default update is to update all the hotelsdatastore.update(datastore.createQuery(Hotel.class), ops);//increments all hotels
//equivalent morphia shell version is... upsert = false, multi = true
db.collection.update( criteria, objNew, false, true );
createIfMissing (overload parameter)
//all of the update methods are overloaded and accept a "createIfMissing" parameter
ops = datastore.createUpdateOperations(Hotel.class).inc("stars", 50);
//update, if not found create it
datastore.updateFirst(datastore.createQuery(Hotel.class).field("stars").greaterThan(100), ops, true);
// creates { "_id" : ObjectId("4c60629d2f1200000000161d"), "stars" : 50 }
// equivalent morphia shell version is... upsert = true
db.collection.update( criteria, objNew, true, multi );
二：
morphia的Query
Introduction
The Query interface is pretty straight forward. It allows for certain filter criteria (based on fields), sorting, an offset, and limiting of the number of results.
The query implementation also implements the the
QueryResults
interface which allows access to the data from the query.
Filter
The generic
.filter(criteria, value)
syntax is supported. The criteria is a composite of the field name and the operator ("field >", or "field in"). All criteria are implicitly combined with a logical "and".
Datastore
ds
=
...
Query
q
=
ds
.
createQuery
(
MyEntity
.
class
).
filter
(
"foo >"
,
12
);
Finding entities where foo is between 12 and 30 would look like this:
Datastore
ds
=
...
Query
q
=
ds
.
createQuery
(
MyEntity
.
class
).
filter
(
"foo >"
,
12
).
filter
(
"foo <"
,
30
);
Operators
The operators used in
filter(...)
match the MongoDB query operators very closely.
operator
mongo op
=
$eq
!=, <>
$ne
>, <, >=,<=
$gt, $lt, $gte, $lte
in
$in
nin
$nin
elem
$elemMatch
exists
$exists
all
$all
size
$size
...
...
Fluent Interface
Along with the
.filter(...)
method there are fluent query methods as well. These provide a more readable (like in the english language sense) form.
The fluent interface works by starting with
field(name)
. Then any of the following methods can be added to form the filtering part of the criteria.
Query
q
=
ds
.
createQuery
(
MyEntity
.
class
).
field
(
"foo"
).
equal
(
1
);
q
.
field
(
"bar"
).
greaterThan
(
12
);
q
.
field
(
"bar"
).
lessThan
(
40
);
Methods
method
operation
comment
exists
$exists
doesNotExist
$exists
greaterThan, greaterThanOrEq, lessThan, lessThanOrEq
$gt, $gte, $lt, $lte
equal, notEqual
$eq, $ne
hasThisOne
$eq
hasAllOf
$all
hasAnyOf
$in
hasNoneOf
$nin
hasThisElement
$elemMatch
sizeEq
$size
Geo-spatial
All of the geo-spatial query methods break down into "near, and within". All of the
near
queries will produce results in order of distance, closest first. All of the methods below also accept a final parameter of
spherical
to indicate if they should use the new
$sphere
option.
method
operation
comment
near(x,y)
$near
near(x,y,r)
$near
(w/maxDistance of r)
within(x,y,r)
$within + $center
within(x1,y1,x2,y2)
$within + $box
@Entity
static
private
class
Place
{
@Id
protected
ObjectId
id
;
protected
String
name
=
""
;
@Indexed
(
IndexDirection
.
GEO2D
)
protected
double
[]
loc
=
null
;
public
Place
(
String
name
,
double
[]
loc
)
{
this
.
name
=
name
;
this
.
loc
=
loc
;
}
private
Place
()
{}
}
Place
place1
=
new
Place
(
"place1"
,
new
double
[]
{
1
,
1
});
ds
.
save
(
place1
);
Place
found
=
ds
.
find
(
Place
.
class
).
field
(
"loc"
).
near
(
0
,
0
).
get
();
Or
Using the fluent query interface you can also do "or" queries like this:
Query
<
Person
>
q
=
ad
.
createQuery
(
Person
.
class
);
q
.
or
(
q
.
criteria
(
"firstName"
).
equal
(
"scott"
),
q
.
criteria
(
"lastName"
).
equal
(
"scott"
)
);
Note
: In this example the method
criteria
is used. It you use
field}} as one of the {{{or
parameters then you will get a compiler error.
Fields
Field names can be used much like they can in
native mongodb queries
, with
"dot" notation
.
Query
q
=
ds
.
createQuery
(
Person
.
class
).
field
(
"addresses.city"
).
equal
(
"San Francisco"
);
//or with filter, or with this helper method
Query
q
=
ds
.
find
(
Person
.
class
,
"addresses.city"
,
"San Francisco"
);
Validation
Validation is done on the field names, and data types used. If a field name is not found on the java class specified in the query then an exception is thrown. If the field name is in "dot" notation then each part of the expression is checked against your java object graph (with the exception of a map, where the key name is skipped).
Problems in the data type (comparing the field type and parameter type) are logged as warnings since it is possible that the server can coerce the values, or that you meant to send something which didn't seem to make sense; The server uses the byte representation of the parameter so some values can match even if the data types are different (numbers for example).
Disabling Validation
Validation can be disabled by calling
disableValidation()
as the beginning of the query definition, or anywhere within you query.
Datastore
ds
=
...
Query
q
=
ds
.
createQuery
(
MyEntity
.
class
).
disableValidation
();
//or it can be disabled for just one filter
Query
q
=
ds
.
createQuery
(
MyEntity
.
class
).
disableValidation
().
filter
(
"someOldField"
,
value
).
enableValidation
().
filter
(
"realField"
,
otherVal
);
Sort
You can sort by a field, or multiple fields in ascending or descending order.
Datastore
ds
=
...
Query
q
=
ds
.
createQuery
(
MyEntity
.
class
).
filter
(
"foo >"
,
12
).
order
(
"dateAdded"
);
...
// desc order
Query
q
=
ds
.
createQuery
(
MyEntity
.
class
).
filter
(
"foo >"
,
12
).
order
(
"-dateAdded"
);
...
// asc dateAdded, desc foo
Query
q
=
ds
.
createQuery
(
MyEntity
.
class
).
filter
(
"foo >"
,
12
).
order
(
"dateAdded, -foo"
);
Limit
You can also limit for the number of elements.
Datastore
ds
=
...
Query
q
=
ds
.
createQuery
(
MyEntity
.
class
).
filter
(
"foo >"
,
12
).
limit
(
100
);
Offset (skip)
You can also ask the server to skip over a number of elements on the server by specifying an offset value for the query. This will less efficient than a range filter using some field, for pagination for example.
Datastore
ds
=
...
Query
q
=
ds
.
createQuery
(
MyEntity
.
class
).
filter
(
"foo >"
,
12
).
offset
(
1000
);
Ignoring Fields
MongoDB also supports only returning certain fields. This is a little strange in application but it is an important way to trim parts off of embedded graphs. This will lead to partial entities and should be used sparingly, if at all.
Datastore
ds
=
...
MyEntity
e
=
ds
.
createQuery
(
MyEntity
.
class
).
retrievedFields
(
true
,
"foo"
).
get
();
val
=
e
.
getFoo
();
// only field returned
...
MyEntity
e
=
ds
.
createQuery
(
MyEntity
.
class
).
retrievedFields
(
false
,
"foo"
).
get
();
val
=
e
.
getFoo
();
// only field not returned
The field name argument (the last arg) can be a list of strings or a string array:
MyEntity
e
=
ds
.
createQuery
(
MyEntity
.
class
).
retrievedFields
(
true
,
"foo"
,
"bar"
).
get
();
val
=
e
.
getFoo
();
// fields returned
vak
=
e
.
getBar
();
// fields returned
Returning Data
To return your data just call one of the
QueryResults
methods. None of these methods affect the Query. They will leave the Query alone so you can continue to use it to retrieve new results by calling these methods again.
method
does
get()
returns the first Entity -- using limit(1)
asList()
return all items in a List -- could be costly with large result sets
fetch()
explicit method to get Iterable instance
asKeyList()
return all items in a List of their
Key<T>
-- This only retrieves the
id field from the server.
fetchEmptyEntities()
Just like a
fetch()
but only retrieves, and fills in the id field.
Datastore
ds
=
...
Query
q
=
ds
.
createQuery
(
MyEntity
.
class
).
filter
(
"foo >"
,
12
);
//single entity
MyEntity
e
=
q
.
get
();
e
=
q
.
sort
(
"foo"
).
get
();
//for
for
(
MyEntity
e
:
q
)
(
e
);
//list
List
<
MyEntity
>
entities
=
q
.
asList
();
页:
[1]