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 hotels  datastore.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
)
    

print
(
e
);
    

//list
  

List
<
MyEntity
>
 
entities 

=
 
q
.
asList
();