Java operations on mongodb

 

To use mongoDB, You need to import the following classes, not all of which are required.

Import com. mongodb. Mongo;

Import com. mongodb. DB;

Import com. mongodb. DBCollection;

Import com. mongodb. BasicDBObject;

Import com. mongodb. DBObject;

Import com. mongodb. DBCursor;

Import com. mongodb. ObjectId;

 

Class Conversion

After a class object is saved to mongoDB, use setObjectClass () to convert it back to the original class when it is retrieved from mongoDB.

Public class Tweet implements DBObject {

/*...*/

}

Tweet myTweet = new Tweet ();

MyTweet. put ("user", "bruce ");

MyTweet. put ("message", "fun ");

MyTweet. put ("date", new Date ());

Collection. insert (myTweet );

// Conversion

Collection. setObjectClass (Tweet );

Tweet myTweet = (Tweet) collection. findOne ();

 

Default ID

When no ID is set for the saved object, mongoDB sets an ID ("_ id") for the record by default ").

Of course, you can also set your own specified ID, such as: (execute db. users. save ({_ id: 1, name: 'Bruce '}) in mongoDB '});)

BasicDBObject bo = new BasicDBObject ();

Bo. put ('_ id', 1 );

Bo. put ('name', 'Bruce ');

Collection. insert (bo );

 

Permission

If you have mongoDB access permissions, true is returned. Otherwise, false is returned.

Boolean auth = db. authenticate (myUserName, myPassword );

 

View mongoDB database list

Mongo m = new Mongo ();

For (String s: m. getDatabaseNames ()){

System. out. println (s );

}

 

 

View all the table names in the current database. It is equivalent to executing show tables in mongoDB;

Set <String> colls = db. getCollectionNames ();

For (String s: colls ){

System. out. println (s );

}

 

View the index of a table

List <DBObject> list = coll. getIndexInfo ();

For (DBObject o: list ){

System. out. println (o );

}

 

Delete A Database

Mongo m = new Mongo ();

M. dropDatabase ("myDatabaseName ");

 

Create a mongoDB connection

Mongo m = new Mongo ("localhost", 27017 );

DB db = m. getDB ("myDatabaseName"); // The Database Name

DBCollection coll = db. getCollection ("myUsersTable"); // table name

 

# Querying data

Query the first record

DBObject firstDoc = coll. findOne ();

FindOne () returns a record, while find () returns the DBCursor cursor object.

 

Query all data

DBCursor cur = coll. find ();

While (cur. hasNext ()){

System. out. println (cur. next ());

}

 

Query the number of records

Coll. find (). count ();

Coll. find (new BasicDBObject ("age", 26). count ();

 

Set conditional Query

BasicDBObject condition = new BasicDBObject ();

Condition. put ("name", "bruce ");

Condition. put ("age", 26 );

Coll. find (condition );

 

Query part of data blocks

DBCursor cursor = coll. find (). skip (0). limit (10 );

While (cursor. hasNext ()){

System. out. println (cursor. next ());

}

 

Comparison query (age> 50)

BasicDBObject condition = new BasicDBObject ();

Condition. put ("age", new BasicDBObject ("$ gt", 50 ));

Coll. find (condition );

Comparison operator

"$ Gt": greater

"$ Gte": greater than or equal

"$ Lt": less

"$ Lte": less than or equal

"$ In": Contains

// The following conditions query 20 <age <= 30

Condition. put ("age", new BasicDBObject ("$ gt", 20). append ("$ lte", 30 ));

 

# Insert data

Batch insert

List datas = new ArrayList ();

For (int I = 0; I <100; I ++ ){

BasicDBObject bo = new BasicDBObject ();

Bo. put ("name", "bruce ");

Bo. append ("age", I );

Datas. add (bo );

}

Coll. insert (datas );

 

Regular Expression

Query all name matches/joh? N/I records

Pattern pattern = Pattern. compile ("joh? N ", CASE_INSENSITIVE );

BasicDBObject query = new BasicDBObject ("name", pattern );

DBCursor cursor = coll. find (query );

 

 

How to Use mongoDb update

The key is in $ set, there are a lot of tests, addresses: http://www.mongodb.org/display/DOCS/Updating#Updating-%24inc

?

Update (BasicDBobject, BasicDBobject)

The first parameter is the search condition, the object to be modified, and the second parameter is the modification content. If the set parameter is not used, the original object is updated to the current object.

If $ set exists, the attribute is updated. If the attribute does not exist, the attribute is added. Other parameters are used in the same way.

?

?

 

DBCollection coll2 = db. getCollection (Config. SENDER_EMAIL_MESSAGE );

 

?

 

Coll2.update (

New BasicDBObject ("key", sender. get ("key ")),

New BasicDBObject ("$ set", new BasicDBObject (

"FinallyUseTime", Math. floor (System

. CurrentTimeMillis ()

/Config. SEND_FREQUENCY ))));

 

 

?

 

------------------------------------------------

 

To make it easier to reference the completed content here

 

MongoDB supports atomic, in-place updates as well as more traditional updates for replacing an entire document.

 

* Update ()

* Save () in the mongo shell

* Modifier Operations

+ $ Inc

+ $ Set

+ $ Unset

+ $ Push

+ $ PushAll

+ $ AddToSet

+ $ Pop

+ $ Pull

+ $ PullAll

+ $ Rename

O The $ positional operator

O Upserts with Modifiers

O Pushing a Unique Value

* Checking the Outcome of an Update Request

* Notes

O Object Padding

O Blocking

* See Also

 

Update ()

 

Update () replaces the document matching criteria entirely with objNew. If you only want to modify some fields, you shocould use the atomic modifiers below.

 

Here's the MongoDB shell syntax for update ():

 

Db. collection. update (criteria, objNew, upsert, multi)

 

Arguments:

 

* Criteria-query which selects the record to update;

* ObjNew-updated object or $ operators (e.g., $ inc) which manipulate the object

* Upsert-if this shoshould be an "upsert"; that is, if the record does not exist, insert it

* Multi-if all variables ents matching criteria shoshould be updated

 

 

If you are coming from SQL, be aware that by default, update () only modifies the first matched object. If you want to modify all matched objects you need to use the multi flag

Save () in the mongo shell

 

The save () command in the mongo shell provides a shorthand syntax to perform a single object update with upsert:

 

// X is some JSON style object

Db. mycollection. save (x); // updates if exists; inserts if new

 

Save () does an upsert if x has an _ id field and an insert if it does not. Thus, normally, you will not need to explicitly request upserts, just use save ().

 

Upsert means "update if present; insert if missing ".

 

MyColl. update ({_ id: X}, {_ id: X, name: "Joe", age: 20}, true );

 

Modifier Operations

 

Modifier operations are highly-efficient and useful when updating existing values; for instance, they're great for incrementing a number.

 

So, while a conventional implementation does work:

 

Var j = myColl. findOne ({name: "Joe "});

J. n ++;

MyColl. save (j );

 

A modifier update has the advantages of avoiding the latency involved in querying and returning the object. The modifier update also features operation atomicity and very little network data transfer.

 

To perform an atomic update, simply specify any of the special update operators (which always start with a' $ 'character) with a relevant update document: