mirror of
https://github.com/mongodb/mongo.git
synced 2024-11-30 17:10:48 +01:00
2007 lines
66 KiB
C++
2007 lines
66 KiB
C++
const char * jsconcatcode =
|
|
"if ( ( typeof DBCollection ) == \"undefined\" ){\n"
|
|
"DBCollection = function( mongo , db , shortName , fullName ){\n"
|
|
"this._mongo = mongo;\n"
|
|
"this._db = db;\n"
|
|
"this._shortName = shortName;\n"
|
|
"this._fullName = fullName;\n"
|
|
"this.verify();\n"
|
|
"}\n"
|
|
"}\n"
|
|
"DBCollection.prototype.verify = function(){\n"
|
|
"assert( this._fullName , \"no fullName\" );\n"
|
|
"assert( this._shortName , \"no shortName\" );\n"
|
|
"assert( this._db , \"no db\" );\n"
|
|
"assert.eq( this._fullName , this._db._name + \".\" + this._shortName , \"name mismatch\" );\n"
|
|
"assert( this._mongo , \"no mongo in DBCollection\" );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.getName = function(){\n"
|
|
"return this._shortName;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.help = function(){\n"
|
|
"print(\"DBCollection help\");\n"
|
|
"print(\"\\tdb.foo.getDB() get DB object associated with collection\");\n"
|
|
"print(\"\\tdb.foo.findOne([query])\");\n"
|
|
"print(\"\\tdb.foo.find( [query] , [fields]) - first parameter is an optional query filter. second parameter is optional set of fields to return.\");\n"
|
|
"print(\"\\t e.g. db.foo.find( { x : 77 } , { name : 1 , x : 1 } )\");\n"
|
|
"print(\"\\tdb.foo.find(...).sort(...)\");\n"
|
|
"print(\"\\tdb.foo.find(...).limit(n)\");\n"
|
|
"print(\"\\tdb.foo.find(...).skip(n)\");\n"
|
|
"print(\"\\tdb.foo.find(...).count()\");\n"
|
|
"print(\"\\tdb.foo.count()\");\n"
|
|
"print(\"\\tdb.foo.group( { key : ..., initial: ..., reduce : ...[, cond: ...] } )\");\n"
|
|
"print(\"\\tdb.foo.save(obj)\");\n"
|
|
"print(\"\\tdb.foo.update(query, object[, upsert_bool])\");\n"
|
|
"print(\"\\tdb.foo.remove(query)\" );\n"
|
|
"print(\"\\tdb.foo.ensureIndex(keypattern,options) - options should be an object with these possible fields: name, unique, dropDups\");\n"
|
|
"print(\"\\tdb.foo.dropIndexes()\");\n"
|
|
"print(\"\\tdb.foo.dropIndex(name)\");\n"
|
|
"print(\"\\tdb.foo.getIndexes()\");\n"
|
|
"print(\"\\tdb.foo.drop() drop the collection\");\n"
|
|
"print(\"\\tdb.foo.renameCollection( newName ) renames the collection\");\n"
|
|
"print(\"\\tdb.foo.validate() - SLOW\");\n"
|
|
"print(\"\\tdb.foo.stats()\");\n"
|
|
"print(\"\\tdb.foo.dataSize()\");\n"
|
|
"print(\"\\tdb.foo.storageSize() - includes free space allocated to this collection\");\n"
|
|
"print(\"\\tdb.foo.totalIndexSize() - size in bytes of all the indexes\");\n"
|
|
"print(\"\\tdb.foo.totalSize() - storage allocated for all data and indexes\");\n"
|
|
"}\n"
|
|
"DBCollection.prototype.getFullName = function(){\n"
|
|
"return this._fullName;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.getDB = function(){\n"
|
|
"return this._db;\n"
|
|
"}\n"
|
|
"DBCollection.prototype._dbCommand = function( cmd ){\n"
|
|
"return this._db._dbCommand( cmd );\n"
|
|
"}\n"
|
|
"DBCollection.prototype._massageObject = function( q ){\n"
|
|
"if ( ! q )\n"
|
|
"return {};\n"
|
|
"var type = typeof q;\n"
|
|
"if ( type == \"function\" )\n"
|
|
"return { $where : q };\n"
|
|
"if ( q.isObjectId )\n"
|
|
"return { _id : q };\n"
|
|
"if ( type == \"object\" )\n"
|
|
"return q;\n"
|
|
"if ( type == \"string\" ){\n"
|
|
"if ( q.length == 24 )\n"
|
|
"return { _id : q };\n"
|
|
"return { $where : q };\n"
|
|
"}\n"
|
|
"throw \"don't know how to massage : \" + type;\n"
|
|
"}\n"
|
|
"DBCollection.prototype._validateObject = function( o ){\n"
|
|
"if ( o._ensureSpecial && o._checkModify )\n"
|
|
"throw \"can't save a DBQuery object\";\n"
|
|
"}\n"
|
|
"DBCollection._allowedFields = { $id : 1 , $ref : 1 };\n"
|
|
"DBCollection.prototype._validateForStorage = function( o ){\n"
|
|
"this._validateObject( o );\n"
|
|
"for ( var k in o ){\n"
|
|
"if ( k.indexOf( \".\" ) >= 0 ) {\n"
|
|
"throw \"can't have . in field names [\" + k + \"]\" ;\n"
|
|
"}\n"
|
|
"if ( k.indexOf( \"$\" ) == 0 && ! DBCollection._allowedFields[k] ) {\n"
|
|
"throw \"field names cannot start with $ [\" + k + \"]\";\n"
|
|
"}\n"
|
|
"if ( o[k] !== null && typeof( o[k] ) === \"object\" ) {\n"
|
|
"this._validateForStorage( o[k] );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"};\n"
|
|
"DBCollection.prototype.find = function( query , fields , limit , skip ){\n"
|
|
"return new DBQuery( this._mongo , this._db , this ,\n"
|
|
"this._fullName , this._massageObject( query ) , fields , limit , skip );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.findOne = function( query , fields ){\n"
|
|
"var cursor = this._mongo.find( this._fullName , this._massageObject( query ) || {} , fields , -1 , 0 );\n"
|
|
"if ( ! cursor.hasNext() )\n"
|
|
"return null;\n"
|
|
"var ret = cursor.next();\n"
|
|
"if ( cursor.hasNext() ) throw \"findOne has more than 1 result!\";\n"
|
|
"if ( ret.$err )\n"
|
|
"throw \"error \" + tojson( ret );\n"
|
|
"return ret;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.insert = function( obj , _allow_dot ){\n"
|
|
"if ( ! obj )\n"
|
|
"throw \"no object!\";\n"
|
|
"if ( ! _allow_dot ) {\n"
|
|
"this._validateForStorage( obj );\n"
|
|
"}\n"
|
|
"return this._mongo.insert( this._fullName , obj );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.remove = function( t ){\n"
|
|
"this._mongo.remove( this._fullName , this._massageObject( t ) );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.update = function( query , obj , upsert ){\n"
|
|
"assert( query , \"need a query\" );\n"
|
|
"assert( obj , \"need an object\" );\n"
|
|
"this._validateObject( obj );\n"
|
|
"return this._mongo.update( this._fullName , query , obj , upsert ? true : false );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.save = function( obj ){\n"
|
|
"if ( obj == null || typeof( obj ) == \"undefined\" )\n"
|
|
"throw \"can't save a null\";\n"
|
|
"if ( typeof( obj._id ) == \"undefined\" ){\n"
|
|
"obj._id = new ObjectId();\n"
|
|
"return this.insert( obj );\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"return this.update( { _id : obj._id } , obj , true );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"DBCollection.prototype._genIndexName = function( keys ){\n"
|
|
"var name = \"\";\n"
|
|
"for ( var k in keys ){\n"
|
|
"if ( name.length > 0 )\n"
|
|
"name += \"_\";\n"
|
|
"name += k + \"_\";\n"
|
|
"var v = keys[k];\n"
|
|
"if ( typeof v == \"number\" )\n"
|
|
"name += v;\n"
|
|
"}\n"
|
|
"return name;\n"
|
|
"}\n"
|
|
"DBCollection.prototype._indexSpec = function( keys, options ) {\n"
|
|
"var ret = { ns : this._fullName , key : keys , name : this._genIndexName( keys ) };\n"
|
|
"if ( ! options ){\n"
|
|
"}\n"
|
|
"else if ( typeof ( options ) == \"string\" )\n"
|
|
"ret.name = options;\n"
|
|
"else if ( typeof ( options ) == \"boolean\" )\n"
|
|
"ret.unique = true;\n"
|
|
"else if ( typeof ( options ) == \"object\" ){\n"
|
|
"if ( options.length ){\n"
|
|
"var nb = 0;\n"
|
|
"for ( var i=0; i<options.length; i++ ){\n"
|
|
"if ( typeof ( options[i] ) == \"string\" )\n"
|
|
"ret.name = options[i];\n"
|
|
"else if ( typeof( options[i] ) == \"boolean\" ){\n"
|
|
"if ( options[i] ){\n"
|
|
"if ( nb == 0 )\n"
|
|
"ret.unique = true;\n"
|
|
"if ( nb == 1 )\n"
|
|
"ret.dropDups = true;\n"
|
|
"}\n"
|
|
"nb++;\n"
|
|
"}\n"
|
|
"}\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"Object.extend( ret , options );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"throw \"can't handle: \" + typeof( options );\n"
|
|
"}\n"
|
|
"/*\n"
|
|
"return ret;\n"
|
|
"var name;\n"
|
|
"var nTrue = 0;\n"
|
|
"if ( ! isObject( options ) ) {\n"
|
|
"options = [ options ];\n"
|
|
"}\n"
|
|
"if ( options.length ){\n"
|
|
"for( var i = 0; i < options.length; ++i ) {\n"
|
|
"var o = options[ i ];\n"
|
|
"if ( isString( o ) ) {\n"
|
|
"ret.name = o;\n"
|
|
"} else if ( typeof( o ) == \"boolean\" ) {\n"
|
|
"if ( o ) {\n"
|
|
"++nTrue;\n"
|
|
"}\n"
|
|
"}\n"
|
|
"}\n"
|
|
"if ( nTrue > 0 ) {\n"
|
|
"ret.unique = true;\n"
|
|
"}\n"
|
|
"if ( nTrue > 1 ) {\n"
|
|
"ret.dropDups = true;\n"
|
|
"}\n"
|
|
"}\n"
|
|
"*/\n"
|
|
"return ret;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.createIndex = function( keys , options ){\n"
|
|
"var o = this._indexSpec( keys, options );\n"
|
|
"this._db.getCollection( \"system.indexes\" ).insert( o , true );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.ensureIndex = function( keys , options ){\n"
|
|
"var name = this._indexSpec( keys, options ).name;\n"
|
|
"this._indexCache = this._indexCache || {};\n"
|
|
"if ( this._indexCache[ name ] ){\n"
|
|
"return false;\n"
|
|
"}\n"
|
|
"this.createIndex( keys , options );\n"
|
|
"if ( this.getDB().getLastError() == \"\" ) {\n"
|
|
"this._indexCache[name] = true;\n"
|
|
"}\n"
|
|
"return true;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.resetIndexCache = function(){\n"
|
|
"this._indexCache = {};\n"
|
|
"}\n"
|
|
"DBCollection.prototype.reIndex = function(){\n"
|
|
"var specs = this.getIndexSpecs();\n"
|
|
"this.dropIndexes();\n"
|
|
"for ( var i = 0; i < specs.length; ++i ){\n"
|
|
"this.ensureIndex( specs[i].key, [ specs[i].unique, specs[i].name ] );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"DBCollection.prototype.dropIndexes = function(){\n"
|
|
"this.resetIndexCache();\n"
|
|
"var res = this._db.runCommand( { deleteIndexes: this.getName(), index: \"*\" } );\n"
|
|
"assert( res , \"no result from dropIndex result\" );\n"
|
|
"if ( res.ok )\n"
|
|
"return res;\n"
|
|
"if ( res.errmsg.match( /not found/ ) )\n"
|
|
"return res;\n"
|
|
"throw \"error dropping indexes : \" + tojson( res );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.drop = function(){\n"
|
|
"this.resetIndexCache();\n"
|
|
"return this._db.runCommand( { drop: this.getName() } );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.renameCollection = function( newName ){\n"
|
|
"return this._db._adminCommand( { renameCollection : this._fullName , to : this._db._name + \".\" + newName } ).ok;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.validate = function() {\n"
|
|
"var res = this._db.runCommand( { validate: this.getName() } );\n"
|
|
"res.valid = false;\n"
|
|
"if ( res.result ){\n"
|
|
"var str = \"-\" + tojson( res.result );\n"
|
|
"res.valid = ! ( str.match( /exception/ ) || str.match( /corrupt/ ) );\n"
|
|
"var p = /lastExtentSize:(\\d+)/;\n"
|
|
"var r = p.exec( str );\n"
|
|
"if ( r ){\n"
|
|
"res.lastExtentSize = Number( r[1] );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"return res;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.getIndexes = function(){\n"
|
|
"return this.getDB().getCollection( \"system.indexes\" ).find( { ns : this.getFullName() } ).toArray();\n"
|
|
"}\n"
|
|
"DBCollection.prototype.getIndices = DBCollection.prototype.getIndexes;\n"
|
|
"DBCollection.prototype.getIndexSpecs = DBCollection.prototype.getIndexes;\n"
|
|
"DBCollection.prototype.getIndexKeys = function(){\n"
|
|
"return this.getIndexes().map(\n"
|
|
"function(i){\n"
|
|
"return i.key;\n"
|
|
"}\n"
|
|
");\n"
|
|
"}\n"
|
|
"DBCollection.prototype.count = function( x ){\n"
|
|
"return this.find( x ).count();\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"* Drop free lists. Normally not used.\n"
|
|
"* Note this only does the collection itself, not the namespaces of its indexes (see cleanAll).\n"
|
|
"*/\n"
|
|
"DBCollection.prototype.clean = function() {\n"
|
|
"return this._dbCommand( { clean: this.getName() } );\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"* <p>Drop a specified index.</p>\n"
|
|
"*\n"
|
|
"* <p>\n"
|
|
"* Name is the name of the index in the system.indexes name field. (Run db.system.indexes.find() to\n"
|
|
"* see example data.)\n"
|
|
"* </p>\n"
|
|
"*\n"
|
|
"* <p>Note : alpha: space is not reclaimed </p>\n"
|
|
"* @param {String} name of index to delete.\n"
|
|
"* @return A result object. result.ok will be true if successful.\n"
|
|
"*/\n"
|
|
"DBCollection.prototype.dropIndex = function(index) {\n"
|
|
"assert(index , \"need to specify index to dropIndex\" );\n"
|
|
"if ( ! isString( index ) && isObject( index ) )\n"
|
|
"index = this._genIndexName( index );\n"
|
|
"var res = this._dbCommand( { deleteIndexes: this.getName(), index: index } );\n"
|
|
"this.resetIndexCache();\n"
|
|
"return res;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.copyTo = function( newName ){\n"
|
|
"return this.getDB().eval(\n"
|
|
"function( collName , newName ){\n"
|
|
"var from = db[collName];\n"
|
|
"var to = db[newName];\n"
|
|
"to.ensureIndex( { _id : 1 } );\n"
|
|
"var count = 0;\n"
|
|
"var cursor = from.find();\n"
|
|
"while ( cursor.hasNext() ){\n"
|
|
"var o = cursor.next();\n"
|
|
"count++;\n"
|
|
"to.save( o );\n"
|
|
"}\n"
|
|
"return count;\n"
|
|
"} , this.getName() , newName\n"
|
|
");\n"
|
|
"}\n"
|
|
"DBCollection.prototype.getCollection = function( subName ){\n"
|
|
"return this._db.getCollection( this._shortName + \".\" + subName );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.stats = function(){\n"
|
|
"return this._db.runCommand( { collstats : this._shortName } );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.dataSize = function(){\n"
|
|
"return this.stats().size;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.storageSize = function(){\n"
|
|
"return this.stats().storageSize;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.totalIndexSize = function( verbose ){\n"
|
|
"var total = 0;\n"
|
|
"var mydb = this._db;\n"
|
|
"var shortName = this._shortName;\n"
|
|
"this.getIndexes().forEach(\n"
|
|
"function( spec ){\n"
|
|
"var coll = mydb.getCollection( shortName + \".$\" + spec.name );\n"
|
|
"var mysize = coll.dataSize();\n"
|
|
"total += coll.dataSize();\n"
|
|
"if ( verbose ) {\n"
|
|
"print( coll + \"\\t\" + mysize );\n"
|
|
"}\n"
|
|
"}\n"
|
|
");\n"
|
|
"return total;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.totalSize = function(){\n"
|
|
"var total = this.storageSize();\n"
|
|
"var mydb = this._db;\n"
|
|
"var shortName = this._shortName;\n"
|
|
"this.getIndexes().forEach(\n"
|
|
"function( spec ){\n"
|
|
"var coll = mydb.getCollection( shortName + \".$\" + spec.name );\n"
|
|
"var mysize = coll.storageSize();\n"
|
|
"total += coll.dataSize();\n"
|
|
"}\n"
|
|
");\n"
|
|
"return total;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.convertToCapped = function( bytes ){\n"
|
|
"if ( ! bytes )\n"
|
|
"throw \"have to specify # of bytes\";\n"
|
|
"return this._dbCommand( { convertToCapped : this._shortName , size : bytes } )\n"
|
|
"}\n"
|
|
"DBCollection.prototype.exists = function(){\n"
|
|
"return this._db.system.namespaces.findOne( { name : this._fullName } );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.isCapped = function(){\n"
|
|
"var e = this.exists();\n"
|
|
"return ( e && e.options && e.options.capped ) ? true : false;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.distinct = function( keyString ){\n"
|
|
"var res = this._dbCommand( { distinct : this._shortName , key : keyString } );\n"
|
|
"if ( ! res.ok )\n"
|
|
"throw \"distinct failed: \" + tojson( res );\n"
|
|
"return res.values;\n"
|
|
"}\n"
|
|
"DBCollection.prototype.group = function( params ){\n"
|
|
"params.ns = this._shortName;\n"
|
|
"return this._db.group( params );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.groupcmd = function( params ){\n"
|
|
"params.ns = this._shortName;\n"
|
|
"return this._db.groupcmd( params );\n"
|
|
"}\n"
|
|
"DBCollection.prototype.toString = function(){\n"
|
|
"return this.getFullName();\n"
|
|
"}\n"
|
|
"DBCollection.prototype.shellPrint = DBCollection.prototype.toString;\n"
|
|
"if ( typeof DB == \"undefined\" ){\n"
|
|
"DB = function( mongo , name ){\n"
|
|
"this._mongo = mongo;\n"
|
|
"this._name = name;\n"
|
|
"}\n"
|
|
"}\n"
|
|
"DB.prototype.getMongo = function(){\n"
|
|
"assert( this._mongo , \"why no mongo!\" );\n"
|
|
"return this._mongo;\n"
|
|
"}\n"
|
|
"DB.prototype.getSisterDB = function( name ){\n"
|
|
"return this.getMongo().getDB( name );\n"
|
|
"}\n"
|
|
"DB.prototype.getName = function(){\n"
|
|
"return this._name;\n"
|
|
"}\n"
|
|
"DB.prototype.getCollection = function( name ){\n"
|
|
"return new DBCollection( this._mongo , this , name , this._name + \".\" + name );\n"
|
|
"}\n"
|
|
"DB.prototype.commandHelp = function( name ){\n"
|
|
"var c = {};\n"
|
|
"c[name] = 1;\n"
|
|
"c.help = true;\n"
|
|
"return this.runCommand( c ).help;\n"
|
|
"}\n"
|
|
"DB.prototype.runCommand = function( obj ){\n"
|
|
"if ( typeof( obj ) == \"string\" ){\n"
|
|
"var n = {};\n"
|
|
"n[obj] = 1;\n"
|
|
"obj = n;\n"
|
|
"}\n"
|
|
"return this.getCollection( \"$cmd\" ).findOne( obj );\n"
|
|
"}\n"
|
|
"DB.prototype._dbCommand = DB.prototype.runCommand;\n"
|
|
"DB.prototype._adminCommand = function( obj ){\n"
|
|
"if ( this._name == \"admin\" )\n"
|
|
"return this.runCommand( obj );\n"
|
|
"return this.getSisterDB( \"admin\" ).runCommand( obj );\n"
|
|
"}\n"
|
|
"DB.prototype.addUser = function( username , pass ){\n"
|
|
"var c = this.getCollection( \"system.users\" );\n"
|
|
"var u = c.findOne( { user : username } ) || { user : username };\n"
|
|
"u.pwd = hex_md5( username + \":mongo:\" + pass );\n"
|
|
"print( tojson( u ) );\n"
|
|
"c.save( u );\n"
|
|
"}\n"
|
|
"DB.prototype.removeUser = function( username ){\n"
|
|
"this.getCollection( \"system.users\" ).remove( { user : username } );\n"
|
|
"}\n"
|
|
"DB.prototype.auth = function( username , pass ){\n"
|
|
"var n = this.runCommand( { getnonce : 1 } );\n"
|
|
"var a = this.runCommand(\n"
|
|
"{\n"
|
|
"authenticate : 1 ,\n"
|
|
"user : username ,\n"
|
|
"nonce : n.nonce ,\n"
|
|
"key : hex_md5( n.nonce + username + hex_md5( username + \":mongo:\" + pass ) )\n"
|
|
"}\n"
|
|
");\n"
|
|
"return a.ok;\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"Create a new collection in the database. Normally, collection creation is automatic. You would\n"
|
|
"use this function if you wish to specify special options on creation.\n"
|
|
"If the collection already exists, no action occurs.\n"
|
|
"<p>Options:</p>\n"
|
|
"<ul>\n"
|
|
"<li>\n"
|
|
"size: desired initial extent size for the collection. Must be <= 1000000000.\n"
|
|
"for fixed size (capped) collections, this size is the total/max size of the\n"
|
|
"collection.\n"
|
|
"</li>\n"
|
|
"<li>\n"
|
|
"capped: if true, this is a capped collection (where old data rolls out).\n"
|
|
"</li>\n"
|
|
"<li> max: maximum number of objects if capped (optional).</li>\n"
|
|
"</ul>\n"
|
|
"<p>Example: </p>\n"
|
|
"<code>db.createCollection(\"movies\", { size: 10 * 1024 * 1024, capped:true } );</code>\n"
|
|
"* @param {String} name Name of new collection to create\n"
|
|
"* @param {Object} options Object with options for call. Options are listed above.\n"
|
|
"* @return SOMETHING_FIXME\n"
|
|
"*/\n"
|
|
"DB.prototype.createCollection = function(name, opt) {\n"
|
|
"var options = opt || {};\n"
|
|
"var cmd = { create: name, capped: options.capped, size: options.size, max: options.max };\n"
|
|
"var res = this._dbCommand(cmd);\n"
|
|
"return res;\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"* Returns the current profiling level of this database\n"
|
|
"* @return SOMETHING_FIXME or null on error\n"
|
|
"*/\n"
|
|
"DB.prototype.getProfilingLevel = function() {\n"
|
|
"var res = this._dbCommand( { profile: -1 } );\n"
|
|
"return res ? res.was : null;\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"Erase the entire database. (!)\n"
|
|
"* @return Object returned has member ok set to true if operation succeeds, false otherwise.\n"
|
|
"*/\n"
|
|
"DB.prototype.dropDatabase = function() {\n"
|
|
"if ( arguments.length )\n"
|
|
"throw \"dropDatabase doesn't take arguments\";\n"
|
|
"return this._dbCommand( { dropDatabase: 1 } );\n"
|
|
"}\n"
|
|
"DB.prototype.shutdownServer = function() {\n"
|
|
"if( \"admin\" != this._name ){\n"
|
|
"return \"shutdown command only works with the admin database; try 'use admin'\";\n"
|
|
"}\n"
|
|
"try {\n"
|
|
"this._dbCommand(\"shutdown\");\n"
|
|
"throw \"shutdownServer failed\";\n"
|
|
"}\n"
|
|
"catch ( e ){\n"
|
|
"assert( tojson( e ).indexOf( \"error doing query: failed\" ) >= 0 , \"unexpected error: \" + tojson( e ) );\n"
|
|
"print( \"server should be down...\" );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"Clone database on another server to here.\n"
|
|
"<p>\n"
|
|
"Generally, you should dropDatabase() first as otherwise the cloned information will MERGE\n"
|
|
"into whatever data is already present in this database. (That is however a valid way to use\n"
|
|
"clone if you are trying to do something intentionally, such as union three non-overlapping\n"
|
|
"databases into one.)\n"
|
|
"<p>\n"
|
|
"This is a low level administrative function will is not typically used.\n"
|
|
"* @param {String} from Where to clone from (dbhostname[:port]). May not be this database\n"
|
|
"(self) as you cannot clone to yourself.\n"
|
|
"* @return Object returned has member ok set to true if operation succeeds, false otherwise.\n"
|
|
"* See also: db.copyDatabase()\n"
|
|
"*/\n"
|
|
"DB.prototype.cloneDatabase = function(from) {\n"
|
|
"assert( isString(from) && from.length );\n"
|
|
"return this._dbCommand( { clone: from } );\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"Clone collection on another server to here.\n"
|
|
"<p>\n"
|
|
"Generally, you should drop() first as otherwise the cloned information will MERGE\n"
|
|
"into whatever data is already present in this collection. (That is however a valid way to use\n"
|
|
"clone if you are trying to do something intentionally, such as union three non-overlapping\n"
|
|
"collections into one.)\n"
|
|
"<p>\n"
|
|
"This is a low level administrative function is not typically used.\n"
|
|
"* @param {String} from mongod instance from which to clnoe (dbhostname:port). May\n"
|
|
"not be this mongod instance, as clone from self is not allowed.\n"
|
|
"* @param {String} collection name of collection to clone.\n"
|
|
"* @param {Object} query query specifying which elements of collection are to be cloned.\n"
|
|
"* @return Object returned has member ok set to true if operation succeeds, false otherwise.\n"
|
|
"* See also: db.cloneDatabase()\n"
|
|
"*/\n"
|
|
"DB.prototype.cloneCollection = function(from, collection, query) {\n"
|
|
"assert( isString(from) && from.length );\n"
|
|
"assert( isString(collection) && collection.length );\n"
|
|
"collection = this._name + \".\" + collection;\n"
|
|
"query = query || {};\n"
|
|
"return this._dbCommand( { cloneCollection:collection, from:from, query:query } );\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"Copy database from one server or name to another server or name.\n"
|
|
"Generally, you should dropDatabase() first as otherwise the copied information will MERGE\n"
|
|
"into whatever data is already present in this database (and you will get duplicate objects\n"
|
|
"in collections potentially.)\n"
|
|
"For security reasons this function only works when executed on the \"admin\" db. However,\n"
|
|
"if you have access to said db, you can copy any database from one place to another.\n"
|
|
"This method provides a way to \"rename\" a database by copying it to a new db name and\n"
|
|
"location. Additionally, it effectively provides a repair facility.\n"
|
|
"* @param {String} fromdb database name from which to copy.\n"
|
|
"* @param {String} todb database name to copy to.\n"
|
|
"* @param {String} fromhost hostname of the database (and optionally, \":port\") from which to\n"
|
|
"copy the data. default if unspecified is to copy from self.\n"
|
|
"* @return Object returned has member ok set to true if operation succeeds, false otherwise.\n"
|
|
"* See also: db.clone()\n"
|
|
"*/\n"
|
|
"DB.prototype.copyDatabase = function(fromdb, todb, fromhost) {\n"
|
|
"assert( isString(fromdb) && fromdb.length );\n"
|
|
"assert( isString(todb) && todb.length );\n"
|
|
"fromhost = fromhost || \"\";\n"
|
|
"return this._adminCommand( { copydb:1, fromhost:fromhost, fromdb:fromdb, todb:todb } );\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"Repair database.\n"
|
|
"* @return Object returned has member ok set to true if operation succeeds, false otherwise.\n"
|
|
"*/\n"
|
|
"DB.prototype.repairDatabase = function() {\n"
|
|
"return this._dbCommand( { repairDatabase: 1 } );\n"
|
|
"}\n"
|
|
"DB.prototype.help = function() {\n"
|
|
"print(\"DB methods:\");\n"
|
|
"print(\"\\tdb.auth(username, password)\");\n"
|
|
"print(\"\\tdb.getMongo() get the server connection object\");\n"
|
|
"print(\"\\tdb.getMongo().setSlaveOk() allow this connection to read from the nonmaster member of a replica pair\");\n"
|
|
"print(\"\\tdb.getSisterDB(name) get the db at the same server as this onew\");\n"
|
|
"print(\"\\tdb.getName()\");\n"
|
|
"print(\"\\tdb.getCollection(cname) same as db['cname'] or db.cname\");\n"
|
|
"print(\"\\tdb.runCommand(cmdObj) run a database command. if cmdObj is a string, turns it into { cmdObj : 1 }\");\n"
|
|
"print(\"\\tdb.commandHelp(name) returns the help for the command\");\n"
|
|
"print(\"\\tdb.addUser(username, password)\");\n"
|
|
"print(\"\\tdb.removeUser(username)\");\n"
|
|
"print(\"\\tdb.createCollection(name, { size : ..., capped : ..., max : ... } )\");\n"
|
|
"print(\"\\tdb.getReplicationInfo()\");\n"
|
|
"print(\"\\tdb.printReplicationInfo()\");\n"
|
|
"print(\"\\tdb.printSlaveReplicationInfo()\");\n"
|
|
"print(\"\\tdb.getProfilingLevel()\");\n"
|
|
"print(\"\\tdb.setProfilingLevel(level) 0=off 1=slow 2=all\");\n"
|
|
"print(\"\\tdb.cloneDatabase(fromhost)\");\n"
|
|
"print(\"\\tdb.copyDatabase(fromdb, todb, fromhost)\");\n"
|
|
"print(\"\\tdb.shutdownServer()\");\n"
|
|
"print(\"\\tdb.dropDatabase()\");\n"
|
|
"print(\"\\tdb.repairDatabase()\");\n"
|
|
"print(\"\\tdb.eval(func, args) run code server-side\");\n"
|
|
"print(\"\\tdb.getLastError() - just returns the err msg string\");\n"
|
|
"print(\"\\tdb.getLastErrorObj() - return full status object\");\n"
|
|
"print(\"\\tdb.getPrevError()\");\n"
|
|
"print(\"\\tdb.resetError()\");\n"
|
|
"print(\"\\tdb.getCollectionNames()\");\n"
|
|
"print(\"\\tdb.currentOp() displays the current operation in the db\" );\n"
|
|
"print(\"\\tdb.killOp() kills the current operation in the db\" );\n"
|
|
"print(\"\\tdb.printCollectionStats()\" );\n"
|
|
"print(\"\\tdb.version() current version of the server\" );\n"
|
|
"}\n"
|
|
"DB.prototype.printCollectionStats = function(){\n"
|
|
"this.getCollectionNames().forEach(\n"
|
|
"function(z){\n"
|
|
"print( z );\n"
|
|
"printjson( db[z].stats() );\n"
|
|
"print( \"---\" );\n"
|
|
"}\n"
|
|
");\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"* <p> Set profiling level for your db. Profiling gathers stats on query performance. </p>\n"
|
|
"*\n"
|
|
"* <p>Default is off, and resets to off on a database restart -- so if you want it on,\n"
|
|
"* turn it on periodically. </p>\n"
|
|
"*\n"
|
|
"* <p>Levels :</p>\n"
|
|
"* <ul>\n"
|
|
"* <li>0=off</li>\n"
|
|
"* <li>1=log very slow (>100ms) operations</li>\n"
|
|
"* <li>2=log all</li>\n"
|
|
"* @param {String} level Desired level of profiling\n"
|
|
"* @return SOMETHING_FIXME or null on error\n"
|
|
"*/\n"
|
|
"DB.prototype.setProfilingLevel = function(level) {\n"
|
|
"if (level < 0 || level > 2) {\n"
|
|
"throw { dbSetProfilingException : \"input level \" + level + \" is out of range [0..2]\" };\n"
|
|
"}\n"
|
|
"if (level) {\n"
|
|
"this.createCollection(\"system.profile\", { capped: true, size: 128 * 1024 } );\n"
|
|
"}\n"
|
|
"return this._dbCommand( { profile: level } );\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"* <p> Evaluate a js expression at the database server.</p>\n"
|
|
"*\n"
|
|
"* <p>Useful if you need to touch a lot of data lightly; in such a scenario\n"
|
|
"* the network transfer of the data could be a bottleneck. A good example\n"
|
|
"* is \"select count(*)\" -- can be done server side via this mechanism.\n"
|
|
"* </p>\n"
|
|
"*\n"
|
|
"* <p>\n"
|
|
"* If the eval fails, an exception is thrown of the form:\n"
|
|
"* </p>\n"
|
|
"* <code>{ dbEvalException: { retval: functionReturnValue, ok: num [, errno: num] [, errmsg: str] } }</code>\n"
|
|
"*\n"
|
|
"* <p>Example: </p>\n"
|
|
"* <code>print( \"mycount: \" + db.eval( function(){db.mycoll.find({},{_id:ObjId()}).length();} );</code>\n"
|
|
"*\n"
|
|
"* @param {Function} jsfunction Javascript function to run on server. Note this it not a closure, but rather just \"code\".\n"
|
|
"* @return result of your function, or null if error\n"
|
|
"*\n"
|
|
"*/\n"
|
|
"DB.prototype.eval = function(jsfunction) {\n"
|
|
"var cmd = { $eval : jsfunction };\n"
|
|
"if ( arguments.length > 1 ) {\n"
|
|
"cmd.args = argumentsToArray( arguments ).slice(1);\n"
|
|
"}\n"
|
|
"var res = this._dbCommand( cmd );\n"
|
|
"if (!res.ok)\n"
|
|
"throw tojson( res );\n"
|
|
"return res.retval;\n"
|
|
"}\n"
|
|
"DB.prototype.dbEval = DB.prototype.eval;\n"
|
|
"/**\n"
|
|
"*\n"
|
|
"* <p>\n"
|
|
"* Similar to SQL group by. For example: </p>\n"
|
|
"*\n"
|
|
"* <code>select a,b,sum(c) csum from coll where active=1 group by a,b</code>\n"
|
|
"*\n"
|
|
"* <p>\n"
|
|
"* corresponds to the following in 10gen:\n"
|
|
"* </p>\n"
|
|
"*\n"
|
|
"* <code>\n"
|
|
"db.group(\n"
|
|
"{\n"
|
|
"ns: \"coll\",\n"
|
|
"key: { a:true, b:true },\n"
|
|
"cond: { active:1 },\n"
|
|
"reduce: function(obj,prev) { prev.csum += obj.c; } ,\n"
|
|
"initial: { csum: 0 }\n"
|
|
"});\n"
|
|
"</code>\n"
|
|
"*\n"
|
|
"*\n"
|
|
"* <p>\n"
|
|
"* An array of grouped items is returned. The array must fit in RAM, thus this function is not\n"
|
|
"* suitable when the return set is extremely large.\n"
|
|
"* </p>\n"
|
|
"* <p>\n"
|
|
"* To order the grouped data, simply sort it client side upon return.\n"
|
|
"* <p>\n"
|
|
"Defaults\n"
|
|
"cond may be null if you want to run against all rows in the collection\n"
|
|
"keyf is a function which takes an object and returns the desired key. set either key or keyf (not both).\n"
|
|
"* </p>\n"
|
|
"*/\n"
|
|
"DB.prototype.groupeval = function(parmsObj) {\n"
|
|
"var groupFunction = function() {\n"
|
|
"var parms = args[0];\n"
|
|
"var c = db[parms.ns].find(parms.cond||{});\n"
|
|
"var map = new Map();\n"
|
|
"var pks = parms.key ? parms.key.keySet() : null;\n"
|
|
"var pkl = pks ? pks.length : 0;\n"
|
|
"var key = {};\n"
|
|
"while( c.hasNext() ) {\n"
|
|
"var obj = c.next();\n"
|
|
"if ( pks ) {\n"
|
|
"for( var i=0; i<pkl; i++ ){\n"
|
|
"var k = pks[i];\n"
|
|
"key[k] = obj[k];\n"
|
|
"}\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"key = parms.$keyf(obj);\n"
|
|
"}\n"
|
|
"var aggObj = map.get(key);\n"
|
|
"if( aggObj == null ) {\n"
|
|
"var newObj = Object.extend({}, key);\n"
|
|
"aggObj = Object.extend(newObj, parms.initial)\n"
|
|
"map.put( key , aggObj );\n"
|
|
"}\n"
|
|
"parms.$reduce(obj, aggObj);\n"
|
|
"}\n"
|
|
"return map.values();\n"
|
|
"}\n"
|
|
"return this.eval(groupFunction, this._groupFixParms( parmsObj ));\n"
|
|
"}\n"
|
|
"DB.prototype.groupcmd = function( parmsObj ){\n"
|
|
"var ret = this.runCommand( { \"group\" : this._groupFixParms( parmsObj ) } );\n"
|
|
"if ( ! ret.ok ){\n"
|
|
"throw \"group command failed: \" + tojson( ret );\n"
|
|
"}\n"
|
|
"return ret.retval;\n"
|
|
"}\n"
|
|
"DB.prototype.group = DB.prototype.groupcmd;\n"
|
|
"DB.prototype._groupFixParms = function( parmsObj ){\n"
|
|
"var parms = Object.extend({}, parmsObj);\n"
|
|
"if( parms.reduce ) {\n"
|
|
"parms.$reduce = parms.reduce;\n"
|
|
"delete parms.reduce;\n"
|
|
"}\n"
|
|
"if( parms.keyf ) {\n"
|
|
"parms.$keyf = parms.keyf;\n"
|
|
"delete parms.keyf;\n"
|
|
"}\n"
|
|
"return parms;\n"
|
|
"}\n"
|
|
"DB.prototype.resetError = function(){\n"
|
|
"return this.runCommand( { reseterror : 1 } );\n"
|
|
"}\n"
|
|
"DB.prototype.forceError = function(){\n"
|
|
"return this.runCommand( { forceerror : 1 } );\n"
|
|
"}\n"
|
|
"DB.prototype.getLastError = function(){\n"
|
|
"var res = this.runCommand( { getlasterror : 1 } );\n"
|
|
"if ( ! res.ok )\n"
|
|
"throw \"getlasterror failed: \" + tojson( res );\n"
|
|
"return res.err;\n"
|
|
"}\n"
|
|
"DB.prototype.getLastErrorObj = function(){\n"
|
|
"var res = this.runCommand( { getlasterror : 1 } );\n"
|
|
"if ( ! res.ok )\n"
|
|
"throw \"getlasterror failed: \" + tojson( res );\n"
|
|
"return res;\n"
|
|
"}\n"
|
|
"/* Return the last error which has occurred, even if not the very last error.\n"
|
|
"Returns:\n"
|
|
"{ err : <error message>, nPrev : <how_many_ops_back_occurred>, ok : 1 }\n"
|
|
"result.err will be null if no error has occurred.\n"
|
|
"*/\n"
|
|
"DB.prototype.getPrevError = function(){\n"
|
|
"return this.runCommand( { getpreverror : 1 } );\n"
|
|
"}\n"
|
|
"DB.prototype.getCollectionNames = function(){\n"
|
|
"var all = [];\n"
|
|
"var nsLength = this._name.length + 1;\n"
|
|
"this.getCollection( \"system.namespaces\" ).find().sort({name:1}).forEach(\n"
|
|
"function(z){\n"
|
|
"var name = z.name;\n"
|
|
"if ( name.indexOf( \"$\" ) >= 0 )\n"
|
|
"return;\n"
|
|
"all.push( name.substring( nsLength ) );\n"
|
|
"}\n"
|
|
");\n"
|
|
"return all;\n"
|
|
"}\n"
|
|
"DB.prototype.tojson = function(){\n"
|
|
"return this._name;\n"
|
|
"}\n"
|
|
"DB.prototype.toString = function(){\n"
|
|
"return this._name;\n"
|
|
"}\n"
|
|
"DB.prototype.currentOp = function(){\n"
|
|
"return db.$cmd.sys.inprog.findOne();\n"
|
|
"}\n"
|
|
"DB.prototype.currentOP = DB.prototype.currentOp;\n"
|
|
"DB.prototype.killOp = function(){\n"
|
|
"return db.$cmd.sys.killop.findOne();\n"
|
|
"}\n"
|
|
"DB.prototype.killOP = DB.prototype.killOp;\n"
|
|
"/**\n"
|
|
"Get a replication log information summary.\n"
|
|
"<p>\n"
|
|
"This command is for the database/cloud administer and not applicable to most databases.\n"
|
|
"It is only used with the local database. One might invoke from the JS shell:\n"
|
|
"<pre>\n"
|
|
"use local\n"
|
|
"db.getReplicationInfo();\n"
|
|
"</pre>\n"
|
|
"It is assumed that this database is a replication master -- the information returned is\n"
|
|
"about the operation log stored at local.oplog.$main on the replication master. (It also\n"
|
|
"works on a machine in a replica pair: for replica pairs, both machines are \"masters\" from\n"
|
|
"an internal database perspective.\n"
|
|
"<p>\n"
|
|
"* @return Object timeSpan: time span of the oplog from start to end if slave is more out\n"
|
|
"* of date than that, it can't recover without a complete resync\n"
|
|
"*/\n"
|
|
"DB.prototype.getReplicationInfo = function() {\n"
|
|
"var db = this.getSisterDB(\"local\");\n"
|
|
"var result = { };\n"
|
|
"var ol = db.system.namespaces.findOne({name:\"local.oplog.$main\"});\n"
|
|
"if( ol && ol.options ) {\n"
|
|
"result.logSizeMB = ol.options.size / 1000 / 1000;\n"
|
|
"} else {\n"
|
|
"result.errmsg = \"local.oplog.$main, or its options, not found in system.namespaces collection (not --master?)\";\n"
|
|
"return result;\n"
|
|
"}\n"
|
|
"var firstc = db.oplog.$main.find().sort({$natural:1}).limit(1);\n"
|
|
"var lastc = db.oplog.$main.find().sort({$natural:-1}).limit(1);\n"
|
|
"if( !firstc.hasNext() || !lastc.hasNext() ) {\n"
|
|
"result.errmsg = \"objects not found in local.oplog.$main -- is this a new and empty db instance?\";\n"
|
|
"result.oplogMainRowCount = db.oplog.$main.count();\n"
|
|
"return result;\n"
|
|
"}\n"
|
|
"var first = firstc.next();\n"
|
|
"var last = lastc.next();\n"
|
|
"{\n"
|
|
"var tfirst = first.ts;\n"
|
|
"var tlast = last.ts;\n"
|
|
"if( tfirst && tlast ) {\n"
|
|
"tfirst = tfirst / 4294967296;\n"
|
|
"tlast = tlast / 4294967296;\n"
|
|
"result.timeDiff = tlast - tfirst;\n"
|
|
"result.timeDiffHours = Math.round(result.timeDiff / 36)/100;\n"
|
|
"result.tFirst = (new Date(tfirst*1000)).toString();\n"
|
|
"result.tLast = (new Date(tlast*1000)).toString();\n"
|
|
"result.now = Date();\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"result.errmsg = \"ts element not found in oplog objects\";\n"
|
|
"}\n"
|
|
"}\n"
|
|
"return result;\n"
|
|
"}\n"
|
|
"DB.prototype.printReplicationInfo = function() {\n"
|
|
"var result = this.getReplicationInfo();\n"
|
|
"if( result.errmsg ) {\n"
|
|
"print(tojson(result));\n"
|
|
"return;\n"
|
|
"}\n"
|
|
"print(\"configured oplog size: \" + result.logSizeMB + \"MB\");\n"
|
|
"print(\"log length start to end: \" + result.timeDiff + \"secs (\" + result.timeDiffHours + \"hrs)\");\n"
|
|
"print(\"oplog first event time: \" + result.tFirst);\n"
|
|
"print(\"oplog last event time: \" + result.tLast);\n"
|
|
"print(\"now: \" + result.now);\n"
|
|
"}\n"
|
|
"DB.prototype.printSlaveReplicationInfo = function() {\n"
|
|
"function g(x) {\n"
|
|
"print(\"source: \" + x.host);\n"
|
|
"var st = new Date(x.syncedTo/4294967296*1000);\n"
|
|
"var now = new Date();\n"
|
|
"print(\"syncedTo: \" + st.toString() );\n"
|
|
"var ago = (now-st)/1000;\n"
|
|
"var hrs = Math.round(ago/36)/100;\n"
|
|
"print(\" = \" + Math.round(ago) + \"secs ago (\" + hrs + \"hrs)\");\n"
|
|
"}\n"
|
|
"var L = this.getSisterDB(\"local\");\n"
|
|
"if( L.sources.count() == 0 ) {\n"
|
|
"print(\"local.sources is empty; is this db a --slave?\");\n"
|
|
"return;\n"
|
|
"}\n"
|
|
"L.sources.find().forEach(g);\n"
|
|
"}\n"
|
|
"DB.prototype.serverBuildInfo = function(){\n"
|
|
"return this._adminCommand( \"buildinfo\" );\n"
|
|
"}\n"
|
|
"DB.prototype.serverStatus = function(){\n"
|
|
"return this._adminCommand( \"serverStatus\" );\n"
|
|
"}\n"
|
|
"DB.prototype.version = function(){\n"
|
|
"return this.serverBuildInfo().version;\n"
|
|
"}\n"
|
|
"if ( typeof Mongo == \"undefined\" ){\n"
|
|
"Mongo = function( host ){\n"
|
|
"this.init( host );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"if ( ! Mongo.prototype ){\n"
|
|
"throw \"Mongo.prototype not defined\";\n"
|
|
"}\n"
|
|
"if ( ! Mongo.prototype.find )\n"
|
|
"Mongo.prototype.find = function( ns , query , fields , limit , skip ){ throw \"find not implemented\"; }\n"
|
|
"if ( ! Mongo.prototype.insert )\n"
|
|
"Mongo.prototype.insert = function( ns , obj ){ throw \"insert not implemented\"; }\n"
|
|
"if ( ! Mongo.prototype.remove )\n"
|
|
"Mongo.prototype.remove = function( ns , pattern ){ throw \"remove not implemented;\" }\n"
|
|
"if ( ! Mongo.prototype.update )\n"
|
|
"Mongo.prototype.update = function( ns , query , obj , upsert ){ throw \"update not implemented;\" }\n"
|
|
"if ( typeof mongoInject == \"function\" ){\n"
|
|
"mongoInject( Mongo.prototype );\n"
|
|
"}\n"
|
|
"Mongo.prototype.setSlaveOk = function() {\n"
|
|
"this.slaveOk = true;\n"
|
|
"}\n"
|
|
"Mongo.prototype.getDB = function( name ){\n"
|
|
"return new DB( this , name );\n"
|
|
"}\n"
|
|
"Mongo.prototype.getDBs = function(){\n"
|
|
"var res = this.getDB( \"admin\" ).runCommand( { \"listDatabases\" : 1 } );\n"
|
|
"assert( res.ok == 1 , \"listDatabases failed\" );\n"
|
|
"return res;\n"
|
|
"}\n"
|
|
"Mongo.prototype.getDBNames = function(){\n"
|
|
"return this.getDBs().databases.map(\n"
|
|
"function(z){\n"
|
|
"return z.name;\n"
|
|
"}\n"
|
|
");\n"
|
|
"}\n"
|
|
"Mongo.prototype.toString = function(){\n"
|
|
"return \"mongo connection to \" + this.host;\n"
|
|
"}\n"
|
|
"connect = function( url , user , pass ){\n"
|
|
"print( \"connecting to: \" + url )\n"
|
|
"if ( user && ! pass )\n"
|
|
"throw \"you specified a user and not a password. either you need a password, or you're using the old connect api\";\n"
|
|
"var idx = url.indexOf( \"/\" );\n"
|
|
"var db;\n"
|
|
"if ( idx < 0 )\n"
|
|
"db = new Mongo().getDB( url );\n"
|
|
"else\n"
|
|
"db = new Mongo( url.substring( 0 , idx ) ).getDB( url.substring( idx + 1 ) );\n"
|
|
"if ( user && pass ){\n"
|
|
"if ( ! db.auth( user , pass ) ){\n"
|
|
"throw \"couldn't login\";\n"
|
|
"}\n"
|
|
"}\n"
|
|
"return db;\n"
|
|
"}\n"
|
|
"MR = {};\n"
|
|
"MR.init = function(){\n"
|
|
"$max = 0;\n"
|
|
"$arr = [];\n"
|
|
"emit = MR.emit;\n"
|
|
"gc();\n"
|
|
"}\n"
|
|
"MR.cleanup = function(){\n"
|
|
"MR.init();\n"
|
|
"gc();\n"
|
|
"}\n"
|
|
"MR.emit = function(k,v){\n"
|
|
"var num = get_num( k );\n"
|
|
"var data = $arr[num];\n"
|
|
"if ( ! data ){\n"
|
|
"data = { key : k , values : [] };\n"
|
|
"$arr[num] = data;\n"
|
|
"}\n"
|
|
"data.values.push( v );\n"
|
|
"$max = Math.max( $max , data.values.length );\n"
|
|
"}\n"
|
|
"MR.doReduce = function( useDB ){\n"
|
|
"$max = 0;\n"
|
|
"for ( var i=0; i<$arr.length; i++){\n"
|
|
"var data = $arr[i];\n"
|
|
"if ( ! data )\n"
|
|
"continue;\n"
|
|
"if ( useDB ){\n"
|
|
"var x = tempcoll.findOne( { _id : data.key } );\n"
|
|
"if ( x ){\n"
|
|
"data.values.push( x.value );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"var r = $reduce( data.key , data.values );\n"
|
|
"if ( r.length && r[0] ){\n"
|
|
"data.values = r;\n"
|
|
"}\n"
|
|
"else{\n"
|
|
"data.values = [ r ];\n"
|
|
"}\n"
|
|
"$max = Math.max( $max , data.values.length );\n"
|
|
"if ( useDB ){\n"
|
|
"if ( data.values.length == 1 ){\n"
|
|
"tempcoll.save( { _id : data.key , value : data.values[0] } );\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"tempcoll.save( { _id : data.key , value : data.values } );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"}\n"
|
|
"}\n"
|
|
"MR.check = function(){\n"
|
|
"if ( $max < 2000 && $arr.length < 1000 ){\n"
|
|
"return 0;\n"
|
|
"}\n"
|
|
"MR.doReduce();\n"
|
|
"if ( $max < 2000 && $arr.length < 1000 ){\n"
|
|
"return 1;\n"
|
|
"}\n"
|
|
"MR.doReduce( true );\n"
|
|
"$arr = [];\n"
|
|
"$max = 0;\n"
|
|
"reset_num();\n"
|
|
"gc();\n"
|
|
"return 2;\n"
|
|
"}\n"
|
|
"if ( typeof DBQuery == \"undefined\" ){\n"
|
|
"DBQuery = function( mongo , db , collection , ns , query , fields , limit , skip ){\n"
|
|
"this._mongo = mongo;\n"
|
|
"this._db = db;\n"
|
|
"this._collection = collection;\n"
|
|
"this._ns = ns;\n"
|
|
"this._query = query || {};\n"
|
|
"this._fields = fields;\n"
|
|
"this._limit = limit || 0;\n"
|
|
"this._skip = skip || 0;\n"
|
|
"this._cursor = null;\n"
|
|
"this._numReturned = 0;\n"
|
|
"this._special = false;\n"
|
|
"}\n"
|
|
"print( \"DBQuery probably won't have array access \" );\n"
|
|
"}\n"
|
|
"DBQuery.prototype.help = function(){\n"
|
|
"print( \"DBQuery help\" );\n"
|
|
"print( \"\\t.sort( {...} )\" )\n"
|
|
"print( \"\\t.limit( n )\" )\n"
|
|
"print( \"\\t.skip( n )\" )\n"
|
|
"print( \"\\t.count()\" )\n"
|
|
"print( \"\\t.explain()\" )\n"
|
|
"print( \"\\t.forEach( func )\" )\n"
|
|
"print( \"\\t.map( func )\" )\n"
|
|
"}\n"
|
|
"DBQuery.prototype.clone = function(){\n"
|
|
"var q = new DBQuery( this._mongo , this._db , this._collection , this._ns ,\n"
|
|
"this._query , this._fields ,\n"
|
|
"this._limit , this._skip );\n"
|
|
"q._special = this._special;\n"
|
|
"return q;\n"
|
|
"}\n"
|
|
"DBQuery.prototype._ensureSpecial = function(){\n"
|
|
"if ( this._special )\n"
|
|
"return;\n"
|
|
"var n = { query : this._query };\n"
|
|
"this._query = n;\n"
|
|
"this._special = true;\n"
|
|
"}\n"
|
|
"DBQuery.prototype._checkModify = function(){\n"
|
|
"if ( this._cursor )\n"
|
|
"throw \"query already executed\";\n"
|
|
"}\n"
|
|
"DBQuery.prototype._exec = function(){\n"
|
|
"if ( ! this._cursor ){\n"
|
|
"assert.eq( 0 , this._numReturned );\n"
|
|
"this._cursor = this._mongo.find( this._ns , this._query , this._fields , this._limit , this._skip );\n"
|
|
"this._cursorSeen = 0;\n"
|
|
"}\n"
|
|
"return this._cursor;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.limit = function( limit ){\n"
|
|
"this._checkModify();\n"
|
|
"this._limit = limit;\n"
|
|
"return this;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.skip = function( skip ){\n"
|
|
"this._checkModify();\n"
|
|
"this._skip = skip;\n"
|
|
"return this;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.hasNext = function(){\n"
|
|
"this._exec();\n"
|
|
"if ( this._limit > 0 && this._cursorSeen >= this._limit )\n"
|
|
"return false;\n"
|
|
"var o = this._cursor.hasNext();\n"
|
|
"return o;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.next = function(){\n"
|
|
"this._exec();\n"
|
|
"var o = this._cursor.hasNext();\n"
|
|
"if ( o )\n"
|
|
"this._cursorSeen++;\n"
|
|
"else\n"
|
|
"throw \"error hasNext: \" + o;\n"
|
|
"var ret = this._cursor.next();\n"
|
|
"if ( ret.$err && this._numReturned == 0 && ! this.hasNext() )\n"
|
|
"throw \"error: \" + tojson( ret );\n"
|
|
"this._numReturned++;\n"
|
|
"return ret;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.toArray = function(){\n"
|
|
"if ( this._arr )\n"
|
|
"return this._arr;\n"
|
|
"var a = [];\n"
|
|
"while ( this.hasNext() )\n"
|
|
"a.push( this.next() );\n"
|
|
"this._arr = a;\n"
|
|
"return a;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.count = function(){\n"
|
|
"var cmd = { count: this._collection.getName() };\n"
|
|
"if ( this._query ){\n"
|
|
"if ( this._special )\n"
|
|
"cmd.query = this._query.query;\n"
|
|
"else\n"
|
|
"cmd.query = this._query;\n"
|
|
"}\n"
|
|
"cmd.fields = this._fields || {};\n"
|
|
"var res = this._db.runCommand( cmd );\n"
|
|
"if( res && res.n != null ) return res.n;\n"
|
|
"throw \"count failed: \" + tojson( res );\n"
|
|
"}\n"
|
|
"DBQuery.prototype.countReturn = function(){\n"
|
|
"var c = this.count();\n"
|
|
"if ( this._skip )\n"
|
|
"c = c - this._skip;\n"
|
|
"if ( this._limit > 0 && this._limit < c )\n"
|
|
"return this._limit;\n"
|
|
"return c;\n"
|
|
"}\n"
|
|
"/**\n"
|
|
"* iterative count - only for testing\n"
|
|
"*/\n"
|
|
"DBQuery.prototype.itcount = function(){\n"
|
|
"var num = 0;\n"
|
|
"while ( this.hasNext() ){\n"
|
|
"num++;\n"
|
|
"this.next();\n"
|
|
"}\n"
|
|
"return num;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.length = function(){\n"
|
|
"return this.toArray().length;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.sort = function( sortBy ){\n"
|
|
"this._ensureSpecial();\n"
|
|
"this._query.orderby = sortBy;\n"
|
|
"return this;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.hint = function( hint ){\n"
|
|
"this._ensureSpecial();\n"
|
|
"this._query[\"$hint\"] = hint;\n"
|
|
"return this;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.min = function( min ) {\n"
|
|
"this._ensureSpecial();\n"
|
|
"this._query[\"$min\"] = min;\n"
|
|
"return this;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.max = function( max ) {\n"
|
|
"this._ensureSpecial();\n"
|
|
"this._query[\"$max\"] = max;\n"
|
|
"return this;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.forEach = function( func ){\n"
|
|
"while ( this.hasNext() )\n"
|
|
"func( this.next() );\n"
|
|
"}\n"
|
|
"DBQuery.prototype.map = function( func ){\n"
|
|
"var a = [];\n"
|
|
"while ( this.hasNext() )\n"
|
|
"a.push( func( this.next() ) );\n"
|
|
"return a;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.arrayAccess = function( idx ){\n"
|
|
"return this.toArray()[idx];\n"
|
|
"}\n"
|
|
"DBQuery.prototype.explain = function(){\n"
|
|
"var n = this.clone();\n"
|
|
"n._ensureSpecial();\n"
|
|
"n._query.$explain = true;\n"
|
|
"n._limit = n._limit * -1;\n"
|
|
"return n.next();\n"
|
|
"}\n"
|
|
"DBQuery.prototype.snapshot = function(){\n"
|
|
"this._ensureSpecial();\n"
|
|
"this._query.$snapshot = true;\n"
|
|
"return this;\n"
|
|
"}\n"
|
|
"DBQuery.prototype.shellPrint = function(){\n"
|
|
"try {\n"
|
|
"var n = 0;\n"
|
|
"while ( this.hasNext() && n < 20 ){\n"
|
|
"var s = tojson( this.next() );\n"
|
|
"print( s );\n"
|
|
"n++;\n"
|
|
"}\n"
|
|
"if ( this.hasNext() ){\n"
|
|
"print( \"has more\" );\n"
|
|
"___it___ = this;\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"___it___ = null;\n"
|
|
"}\n"
|
|
"}\n"
|
|
"catch ( e ){\n"
|
|
"print( e );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"DBQuery.prototype.toString = function(){\n"
|
|
"return \"DBQuery: \" + this._ns + \" -> \" + tojson( this.query );\n"
|
|
"}\n"
|
|
"_parsePath = function() {\n"
|
|
"var dbpath = \"\";\n"
|
|
"for( var i = 0; i < arguments.length; ++i )\n"
|
|
"if ( arguments[ i ] == \"--dbpath\" )\n"
|
|
"dbpath = arguments[ i + 1 ];\n"
|
|
"if ( dbpath == \"\" )\n"
|
|
"throw \"No dbpath specified\";\n"
|
|
"return dbpath;\n"
|
|
"}\n"
|
|
"_parsePort = function() {\n"
|
|
"var port = \"\";\n"
|
|
"for( var i = 0; i < arguments.length; ++i )\n"
|
|
"if ( arguments[ i ] == \"--port\" )\n"
|
|
"port = arguments[ i + 1 ];\n"
|
|
"if ( port == \"\" )\n"
|
|
"throw \"No port specified\";\n"
|
|
"return port;\n"
|
|
"}\n"
|
|
"createMongoArgs = function( binaryName , args ){\n"
|
|
"var fullArgs = [ binaryName ];\n"
|
|
"if ( args.length == 1 && isObject( args[0] ) ){\n"
|
|
"var o = args[0];\n"
|
|
"for ( var k in o ){\n"
|
|
"if ( k == \"v\" && isNumber( o[k] ) ){\n"
|
|
"var n = o[k];\n"
|
|
"if ( n > 0 ){\n"
|
|
"var temp = \"-\";\n"
|
|
"while ( n-- > 0 ) temp += \"v\";\n"
|
|
"fullArgs.push( temp );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"fullArgs.push( \"--\" + k );\n"
|
|
"if ( o[k] != \"\" )\n"
|
|
"fullArgs.push( \"\" + o[k] );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"for ( var i=0; i<args.length; i++ )\n"
|
|
"fullArgs.push( args[i] )\n"
|
|
"}\n"
|
|
"return fullArgs;\n"
|
|
"}\n"
|
|
"startMongod = function(){\n"
|
|
"var args = createMongoArgs( \"mongod\" , arguments );\n"
|
|
"var dbpath = _parsePath.apply( null, args );\n"
|
|
"resetDbpath( dbpath );\n"
|
|
"return startMongoProgram.apply( null, args );\n"
|
|
"}\n"
|
|
"startMongos = function(){\n"
|
|
"return startMongoProgram.apply( null, createMongoArgs( \"mongos\" , arguments ) );\n"
|
|
"}\n"
|
|
"startMongoProgram = function(){\n"
|
|
"var port = _parsePort.apply( null, arguments );\n"
|
|
"_startMongoProgram.apply( null, arguments );\n"
|
|
"var m;\n"
|
|
"assert.soon\n"
|
|
"( function() {\n"
|
|
"try {\n"
|
|
"m = new Mongo( \"127.0.0.1:\" + port );\n"
|
|
"return true;\n"
|
|
"} catch( e ) {\n"
|
|
"}\n"
|
|
"return false;\n"
|
|
"}, \"unable to connect to mongo program on port \" + port, 30000 );\n"
|
|
"return m;\n"
|
|
"}\n"
|
|
"startMongoProgramNoConnect = function() {\n"
|
|
"return _startMongoProgram.apply( null, arguments );\n"
|
|
"}\n"
|
|
"myPort = function() {\n"
|
|
"var m = db.getMongo();\n"
|
|
"if ( m.host.match( /:/ ) )\n"
|
|
"return m.host.match( /:(.*)/ )[ 1 ];\n"
|
|
"else\n"
|
|
"return 27017;\n"
|
|
"}\n"
|
|
"ShardingTest = function( testName , numServers , verboseLevel , numMongos ){\n"
|
|
"this._connections = [];\n"
|
|
"this._serverNames = [];\n"
|
|
"for ( var i=0; i<numServers; i++){\n"
|
|
"var conn = startMongod( { port : 30000 + i , dbpath : \"/data/db/\" + testName + i , noprealloc : \"\" } );\n"
|
|
"conn.name = \"localhost:\" + ( 30000 + i );\n"
|
|
"this._connections.push( conn );\n"
|
|
"this._serverNames.push( conn.name );\n"
|
|
"}\n"
|
|
"this._configDB = \"localhost:30000\";\n"
|
|
"this._mongos = [];\n"
|
|
"var startMongosPort = 39999;\n"
|
|
"for ( var i=0; i<(numMongos||1); i++ ){\n"
|
|
"var myPort = startMongosPort - i;\n"
|
|
"var conn = startMongos( { port : startMongosPort - i , v : verboseLevel || 0 , configdb : this._configDB } );\n"
|
|
"conn.name = \"localhost:\" + myPort;\n"
|
|
"this._mongos.push( conn );\n"
|
|
"if ( i == 0 )\n"
|
|
"this.s = conn;\n"
|
|
"}\n"
|
|
"var admin = this.admin = this.s.getDB( \"admin\" );\n"
|
|
"this.config = this.s.getDB( \"config\" );\n"
|
|
"this._serverNames.forEach(\n"
|
|
"function(z){\n"
|
|
"admin.runCommand( { addshard : z } );\n"
|
|
"}\n"
|
|
");\n"
|
|
"}\n"
|
|
"ShardingTest.prototype.getDB = function( name ){\n"
|
|
"return this.s.getDB( name );\n"
|
|
"}\n"
|
|
"ShardingTest.prototype.getServerName = function( dbname ){\n"
|
|
"return this.config.databases.findOne( { name : dbname } ).primary;\n"
|
|
"}\n"
|
|
"ShardingTest.prototype.getServer = function( dbname ){\n"
|
|
"var name = this.getServerName( dbname );\n"
|
|
"for ( var i=0; i<this._serverNames.length; i++ ){\n"
|
|
"if ( name == this._serverNames[i] )\n"
|
|
"return this._connections[i];\n"
|
|
"}\n"
|
|
"throw \"can't find server for: \" + dbname + \" name:\" + name;\n"
|
|
"}\n"
|
|
"ShardingTest.prototype.getOther = function( one ){\n"
|
|
"if ( this._connections.length != 2 )\n"
|
|
"throw \"getOther only works with 2 servers\";\n"
|
|
"if ( this._connections[0] == one )\n"
|
|
"return this._connections[1];\n"
|
|
"return this._connections[0];\n"
|
|
"}\n"
|
|
"ShardingTest.prototype.stop = function(){\n"
|
|
"for ( var i=0; i<this._mongos.length; i++ ){\n"
|
|
"stopMongoProgram( 39999 - i );\n"
|
|
"}\n"
|
|
"for ( var i=0; i<this._connections.length; i++){\n"
|
|
"stopMongod( 30000 + i );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"ShardingTest.prototype.adminCommand = function(cmd){\n"
|
|
"var res = this.admin.runCommand( cmd );\n"
|
|
"if ( res && res.ok == 1 )\n"
|
|
"return true;\n"
|
|
"throw \"command \" + tojson( cmd ) + \" failed: \" + tojson( res );\n"
|
|
"}\n"
|
|
"ShardingTest.prototype.getChunksString = function( ns ){\n"
|
|
"var q = {}\n"
|
|
"if ( ns )\n"
|
|
"q.ns = ns;\n"
|
|
"return Array.tojson( this.config.chunks.find( q ).toArray() , \"\\n\" );\n"
|
|
"}\n"
|
|
"ShardingTest.prototype.printChunks = function( ns ){\n"
|
|
"print( this.getChunksString( ns ) );\n"
|
|
"}\n"
|
|
"ShardingTest.prototype.sync = function(){\n"
|
|
"this.adminCommand( \"connpoolsync\" );\n"
|
|
"}\n"
|
|
"MongodRunner = function( port, dbpath, peer, arbiter, extraArgs ) {\n"
|
|
"this.port_ = port;\n"
|
|
"this.dbpath_ = dbpath;\n"
|
|
"this.peer_ = peer;\n"
|
|
"this.arbiter_ = arbiter;\n"
|
|
"this.extraArgs_ = extraArgs;\n"
|
|
"}\n"
|
|
"MongodRunner.prototype.start = function( reuseData ) {\n"
|
|
"var args = [];\n"
|
|
"if ( reuseData ) {\n"
|
|
"args.push( \"mongod\" );\n"
|
|
"}\n"
|
|
"args.push( \"--port\" );\n"
|
|
"args.push( this.port_ );\n"
|
|
"args.push( \"--dbpath\" );\n"
|
|
"args.push( this.dbpath_ );\n"
|
|
"if ( this.peer_ && this.arbiter_ ) {\n"
|
|
"args.push( \"--pairwith\" );\n"
|
|
"args.push( this.peer_ );\n"
|
|
"args.push( \"--arbiter\" );\n"
|
|
"args.push( this.arbiter_ );\n"
|
|
"args.push( \"--oplogSize\" );\n"
|
|
"args.push( \"1\" );\n"
|
|
"}\n"
|
|
"args.push( \"--nohttpinterface\" );\n"
|
|
"args.push( \"--noprealloc\" );\n"
|
|
"args.push( \"--bind_ip\" );\n"
|
|
"args.push( \"127.0.0.1\" );\n"
|
|
"if ( this.extraArgs_ ) {\n"
|
|
"args = args.concat( this.extraArgs_ );\n"
|
|
"}\n"
|
|
"if ( reuseData ) {\n"
|
|
"return startMongoProgram.apply( null, args );\n"
|
|
"} else {\n"
|
|
"return startMongod.apply( null, args );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"MongodRunner.prototype.port = function() { return this.port_; }\n"
|
|
"MongodRunner.prototype.toString = function() { return [ this.port_, this.dbpath_, this.peer_, this.arbiter_ ].toString(); }\n"
|
|
"ReplPair = function( left, right, arbiter ) {\n"
|
|
"this.left_ = left;\n"
|
|
"this.leftC_ = null;\n"
|
|
"this.right_ = right;\n"
|
|
"this.rightC_ = null;\n"
|
|
"this.arbiter_ = arbiter;\n"
|
|
"this.arbiterC_ = null;\n"
|
|
"this.master_ = null;\n"
|
|
"this.slave_ = null;\n"
|
|
"}\n"
|
|
"ReplPair.prototype.start = function( reuseData ) {\n"
|
|
"if ( this.arbiterC_ == null ) {\n"
|
|
"this.arbiterC_ = this.arbiter_.start();\n"
|
|
"}\n"
|
|
"if ( this.leftC_ == null ) {\n"
|
|
"this.leftC_ = this.left_.start( reuseData );\n"
|
|
"}\n"
|
|
"if ( this.rightC_ == null ) {\n"
|
|
"this.rightC_ = this.right_.start( reuseData );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"ReplPair.prototype.isMaster = function( mongo, debug ) {\n"
|
|
"var im = mongo.getDB( \"admin\" ).runCommand( { ismaster : 1 } );\n"
|
|
"assert( im && im.ok, \"command ismaster failed\" );\n"
|
|
"if ( debug ) {\n"
|
|
"printjson( im );\n"
|
|
"}\n"
|
|
"return im.ismaster;\n"
|
|
"}\n"
|
|
"ReplPair.prototype.isInitialSyncComplete = function( mongo, debug ) {\n"
|
|
"var isc = mongo.getDB( \"admin\" ).runCommand( { isinitialsynccomplete : 1 } );\n"
|
|
"assert( isc && isc.ok, \"command isinitialsynccomplete failed\" );\n"
|
|
"if ( debug ) {\n"
|
|
"printjson( isc );\n"
|
|
"}\n"
|
|
"return isc.initialsynccomplete;\n"
|
|
"}\n"
|
|
"ReplPair.prototype.checkSteadyState = function( state, expectedMasterHost, twoMasterOk, leftValues, rightValues, debug ) {\n"
|
|
"leftValues = leftValues || {};\n"
|
|
"rightValues = rightValues || {};\n"
|
|
"var lm = null;\n"
|
|
"var lisc = null;\n"
|
|
"if ( this.leftC_ != null ) {\n"
|
|
"lm = this.isMaster( this.leftC_, debug );\n"
|
|
"leftValues[ lm ] = true;\n"
|
|
"lisc = this.isInitialSyncComplete( this.leftC_, debug );\n"
|
|
"}\n"
|
|
"var rm = null;\n"
|
|
"var risc = null;\n"
|
|
"if ( this.rightC_ != null ) {\n"
|
|
"rm = this.isMaster( this.rightC_, debug );\n"
|
|
"rightValues[ rm ] = true;\n"
|
|
"risc = this.isInitialSyncComplete( this.rightC_, debug );\n"
|
|
"}\n"
|
|
"var stateSet = {}\n"
|
|
"state.forEach( function( i ) { stateSet[ i ] = true; } );\n"
|
|
"if ( !( 1 in stateSet ) || ( ( risc || risc == null ) && ( lisc || lisc == null ) ) ) {\n"
|
|
"if ( rm == 1 && lm != 1 ) {\n"
|
|
"assert( twoMasterOk || !( 1 in leftValues ) );\n"
|
|
"this.master_ = this.rightC_;\n"
|
|
"this.slave_ = this.leftC_;\n"
|
|
"} else if ( lm == 1 && rm != 1 ) {\n"
|
|
"assert( twoMasterOk || !( 1 in rightValues ) );\n"
|
|
"this.master_ = this.leftC_;\n"
|
|
"this.slave_ = this.rightC_;\n"
|
|
"}\n"
|
|
"if ( !twoMasterOk ) {\n"
|
|
"assert( lm != 1 || rm != 1, \"two masters\" );\n"
|
|
"}\n"
|
|
"if ( state.sort().toString() == [ lm, rm ].sort().toString() ) {\n"
|
|
"if ( expectedMasterHost != null ) {\n"
|
|
"if( expectedMasterHost == this.master_.host ) {\n"
|
|
"return true;\n"
|
|
"}\n"
|
|
"} else {\n"
|
|
"return true;\n"
|
|
"}\n"
|
|
"}\n"
|
|
"}\n"
|
|
"this.master_ = null;\n"
|
|
"this.slave_ = null;\n"
|
|
"return false;\n"
|
|
"}\n"
|
|
"ReplPair.prototype.waitForSteadyState = function( state, expectedMasterHost, twoMasterOk, debug ) {\n"
|
|
"state = state || [ 1, 0 ];\n"
|
|
"twoMasterOk = twoMasterOk || false;\n"
|
|
"var rp = this;\n"
|
|
"var leftValues = {};\n"
|
|
"var rightValues = {};\n"
|
|
"assert.soon( function() { return rp.checkSteadyState( state, expectedMasterHost, twoMasterOk, leftValues, rightValues, debug ); },\n"
|
|
"\"rp (\" + rp + \") failed to reach expected steady state (\" + state + \")\" );\n"
|
|
"}\n"
|
|
"ReplPair.prototype.master = function() { return this.master_; }\n"
|
|
"ReplPair.prototype.slave = function() { return this.slave_; }\n"
|
|
"ReplPair.prototype.right = function() { return this.rightC_; }\n"
|
|
"ReplPair.prototype.left = function() { return this.leftC_; }\n"
|
|
"ReplPair.prototype.killNode = function( mongo, signal ) {\n"
|
|
"signal = signal || 15;\n"
|
|
"if ( this.leftC_ != null && this.leftC_.host == mongo.host ) {\n"
|
|
"stopMongod( this.left_.port_ );\n"
|
|
"this.leftC_ = null;\n"
|
|
"}\n"
|
|
"if ( this.rightC_ != null && this.rightC_.host == mongo.host ) {\n"
|
|
"stopMongod( this.right_.port_ );\n"
|
|
"this.rightC_ = null;\n"
|
|
"}\n"
|
|
"}\n"
|
|
"ReplPair.prototype._annotatedNode = function( mongo ) {\n"
|
|
"var ret = \"\";\n"
|
|
"if ( mongo != null ) {\n"
|
|
"ret += \" (connected)\";\n"
|
|
"if ( this.master_ != null && mongo.host == this.master_.host ) {\n"
|
|
"ret += \"(master)\";\n"
|
|
"}\n"
|
|
"if ( this.slave_ != null && mongo.host == this.slave_.host ) {\n"
|
|
"ret += \"(slave)\";\n"
|
|
"}\n"
|
|
"}\n"
|
|
"return ret;\n"
|
|
"}\n"
|
|
"ReplPair.prototype.toString = function() {\n"
|
|
"var ret = \"\";\n"
|
|
"ret += \"left: \" + this.left_;\n"
|
|
"ret += \" \" + this._annotatedNode( this.leftC_ );\n"
|
|
"ret += \" right: \" + this.right_;\n"
|
|
"ret += \" \" + this._annotatedNode( this.rightC_ );\n"
|
|
"return ret;\n"
|
|
"}\n"
|
|
"friendlyEqual = function( a , b ){\n"
|
|
"if ( a == b )\n"
|
|
"return true;\n"
|
|
"if ( tojson( a ) == tojson( b ) )\n"
|
|
"return true;\n"
|
|
"return false;\n"
|
|
"}\n"
|
|
"doassert = function( msg ){\n"
|
|
"print( \"assert: \" + msg );\n"
|
|
"throw msg;\n"
|
|
"}\n"
|
|
"assert = function( b , msg ){\n"
|
|
"if ( assert._debug && msg ) print( \"in assert for: \" + msg );\n"
|
|
"if ( b )\n"
|
|
"return;\n"
|
|
"doassert( \"assert failed : \" + msg );\n"
|
|
"}\n"
|
|
"assert._debug = false;\n"
|
|
"assert.eq = function( a , b , msg ){\n"
|
|
"if ( assert._debug && msg ) print( \"in assert for: \" + msg );\n"
|
|
"if ( a == b )\n"
|
|
"return;\n"
|
|
"if ( ( a != null && b != null ) && friendlyEqual( a , b ) )\n"
|
|
"return;\n"
|
|
"doassert( \"[\" + tojson( a ) + \"] != [\" + tojson( b ) + \"] are not equal : \" + msg );\n"
|
|
"}\n"
|
|
"assert.neq = function( a , b , msg ){\n"
|
|
"if ( assert._debug && msg ) print( \"in assert for: \" + msg );\n"
|
|
"if ( a != b )\n"
|
|
"return;\n"
|
|
"doassert( \"[\" + a + \"] != [\" + b + \"] are equal : \" + msg );\n"
|
|
"}\n"
|
|
"assert.soon = function( f, msg, timeout, interval ) {\n"
|
|
"if ( assert._debug && msg ) print( \"in assert for: \" + msg );\n"
|
|
"var start = new Date();\n"
|
|
"timeout = timeout || 30000;\n"
|
|
"interval = interval || 200;\n"
|
|
"var last;\n"
|
|
"while( 1 ) {\n"
|
|
"if ( typeof( f ) == \"string\" ){\n"
|
|
"if ( eval( f ) )\n"
|
|
"return;\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"if ( f() )\n"
|
|
"return;\n"
|
|
"}\n"
|
|
"if ( ( new Date() ).getTime() - start.getTime() > timeout )\n"
|
|
"doassert( \"assert.soon failed: \" + f + \", msg:\" + msg );\n"
|
|
"sleep( interval );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"assert.throws = function( func , params , msg ){\n"
|
|
"if ( assert._debug && msg ) print( \"in assert for: \" + msg );\n"
|
|
"try {\n"
|
|
"func.apply( null , params );\n"
|
|
"}\n"
|
|
"catch ( e ){\n"
|
|
"return e;\n"
|
|
"}\n"
|
|
"doassert( \"did not throw exception: \" + msg );\n"
|
|
"}\n"
|
|
"assert.commandWorked = function( res , msg ){\n"
|
|
"if ( assert._debug && msg ) print( \"in assert for: \" + msg );\n"
|
|
"if ( res.ok == 1 )\n"
|
|
"return;\n"
|
|
"doassert( \"command failed: \" + tojson( res ) + \" : \" + msg );\n"
|
|
"}\n"
|
|
"assert.commandFailed = function( res , msg ){\n"
|
|
"if ( assert._debug && msg ) print( \"in assert for: \" + msg );\n"
|
|
"if ( res.ok == 0 )\n"
|
|
"return;\n"
|
|
"doassert( \"command worked when it should have failed: \" + tojson( res ) + \" : \" + msg );\n"
|
|
"}\n"
|
|
"assert.isnull = function( what , msg ){\n"
|
|
"if ( assert._debug && msg ) print( \"in assert for: \" + msg );\n"
|
|
"if ( what == null )\n"
|
|
"return;\n"
|
|
"doassert( \"supposed to null (\" + ( msg || \"\" ) + \") was: \" + tojson( what ) );\n"
|
|
"}\n"
|
|
"assert.lt = function( a , b , msg ){\n"
|
|
"if ( assert._debug && msg ) print( \"in assert for: \" + msg );\n"
|
|
"if ( a < b )\n"
|
|
"return;\n"
|
|
"doassert( a + \" is not less than \" + b + \" : \" + msg );\n"
|
|
"}\n"
|
|
"assert.gt = function( a , b , msg ){\n"
|
|
"if ( assert._debug && msg ) print( \"in assert for: \" + msg );\n"
|
|
"if ( a > b )\n"
|
|
"return;\n"
|
|
"doassert( a + \" is not greater than \" + b + \" : \" + msg );\n"
|
|
"}\n"
|
|
"Object.extend = function( dst , src ){\n"
|
|
"for ( var k in src ){\n"
|
|
"dst[k] = src[k];\n"
|
|
"}\n"
|
|
"return dst;\n"
|
|
"}\n"
|
|
"argumentsToArray = function( a ){\n"
|
|
"var arr = [];\n"
|
|
"for ( var i=0; i<a.length; i++ )\n"
|
|
"arr[i] = a[i];\n"
|
|
"return arr;\n"
|
|
"}\n"
|
|
"isString = function( x ){\n"
|
|
"return typeof( x ) == \"string\";\n"
|
|
"}\n"
|
|
"isNumber = function(x){\n"
|
|
"return typeof( x ) == \"number\";\n"
|
|
"}\n"
|
|
"isObject = function( x ){\n"
|
|
"return typeof( x ) == \"object\";\n"
|
|
"}\n"
|
|
"String.prototype.trim = function() {\n"
|
|
"return this.replace(/^\\s+|\\s+$/g,\"\");\n"
|
|
"}\n"
|
|
"String.prototype.ltrim = function() {\n"
|
|
"return this.replace(/^\\s+/,\"\");\n"
|
|
"}\n"
|
|
"String.prototype.rtrim = function() {\n"
|
|
"return this.replace(/\\s+$/,\"\");\n"
|
|
"}\n"
|
|
"Date.timeFunc = function( theFunc , numTimes ){\n"
|
|
"var start = new Date();\n"
|
|
"numTimes = numTimes || 1;\n"
|
|
"for ( var i=0; i<numTimes; i++ ){\n"
|
|
"theFunc.apply( null , argumentsToArray( arguments ).slice( 2 ) );\n"
|
|
"}\n"
|
|
"return (new Date()).getTime() - start.getTime();\n"
|
|
"}\n"
|
|
"Date.prototype.tojson = function(){\n"
|
|
"return \"\\\"\" + this.toString() + \"\\\"\";\n"
|
|
"}\n"
|
|
"RegExp.prototype.tojson = RegExp.prototype.toString;\n"
|
|
"Array.contains = function( a , x ){\n"
|
|
"for ( var i=0; i<a.length; i++ ){\n"
|
|
"if ( a[i] == x )\n"
|
|
"return true;\n"
|
|
"}\n"
|
|
"return false;\n"
|
|
"}\n"
|
|
"Array.unique = function( a ){\n"
|
|
"var u = [];\n"
|
|
"for ( var i=0; i<a.length; i++){\n"
|
|
"var o = a[i];\n"
|
|
"if ( ! Array.contains( u , o ) ){\n"
|
|
"u.push( o );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"return u;\n"
|
|
"}\n"
|
|
"Array.shuffle = function( arr ){\n"
|
|
"for ( var i=0; i<arr.length-1; i++ ){\n"
|
|
"var pos = i+Math.floor(Math.random()*(arr.length-i));\n"
|
|
"var save = arr[i];\n"
|
|
"arr[i] = arr[pos];\n"
|
|
"arr[pos] = save;\n"
|
|
"}\n"
|
|
"return arr;\n"
|
|
"}\n"
|
|
"Array.tojson = function( a , sepLines ){\n"
|
|
"var s = \"[\";\n"
|
|
"if ( sepLines ) s += \"\\n\";\n"
|
|
"for ( var i=0; i<a.length; i++){\n"
|
|
"if ( i > 0 ){\n"
|
|
"s += \",\";\n"
|
|
"if ( sepLines ) s += \"\\n\";\n"
|
|
"}\n"
|
|
"s += tojson( a[i] );\n"
|
|
"}\n"
|
|
"s += \"]\";\n"
|
|
"if ( sepLines ) s += \"\\n\";\n"
|
|
"return s;\n"
|
|
"}\n"
|
|
"Array.fetchRefs = function( arr , coll ){\n"
|
|
"var n = [];\n"
|
|
"for ( var i=0; i<arr.length; i ++){\n"
|
|
"var z = arr[i];\n"
|
|
"if ( coll && coll != z.getCollection() )\n"
|
|
"continue;\n"
|
|
"n.push( z.fetch() );\n"
|
|
"}\n"
|
|
"return n;\n"
|
|
"}\n"
|
|
"if ( ! ObjectId.prototype )\n"
|
|
"ObjectId.prototype = {}\n"
|
|
"ObjectId.prototype.toString = function(){\n"
|
|
"return this.str;\n"
|
|
"}\n"
|
|
"ObjectId.prototype.tojson = function(){\n"
|
|
"return \" ObjectId( \\\"\" + this.str + \"\\\") \";\n"
|
|
"}\n"
|
|
"ObjectId.prototype.isObjectId = true;\n"
|
|
"if ( typeof( DBPointer ) != \"undefined\" ){\n"
|
|
"DBPointer.prototype.fetch = function(){\n"
|
|
"assert( this.ns , \"need a ns\" );\n"
|
|
"assert( this.id , \"need an id\" );\n"
|
|
"return db[ this.ns ].findOne( { _id : this.id } );\n"
|
|
"}\n"
|
|
"DBPointer.prototype.tojson = function(){\n"
|
|
"return \"{ 'ns' : \\\"\" + this.ns + \"\\\" , 'id' : \\\"\" + this.id + \"\\\" } \";\n"
|
|
"}\n"
|
|
"DBPointer.prototype.getCollection = function(){\n"
|
|
"return this.ns;\n"
|
|
"}\n"
|
|
"DBPointer.prototype.toString = function(){\n"
|
|
"return \"DBPointer \" + this.ns + \":\" + this.id;\n"
|
|
"}\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"print( \"warning: no DBPointer\" );\n"
|
|
"}\n"
|
|
"if ( typeof( DBRef ) != \"undefined\" ){\n"
|
|
"DBRef.prototype.fetch = function(){\n"
|
|
"assert( this.$ref , \"need a ns\" );\n"
|
|
"assert( this.$id , \"need an id\" );\n"
|
|
"return db[ this.$ref ].findOne( { _id : this.$id } );\n"
|
|
"}\n"
|
|
"DBRef.prototype.tojson = function(){\n"
|
|
"return \"{ '$ref' : \\\"\" + this.$ref + \"\\\" , '$id' : \\\"\" + this.$id + \"\\\" } \";\n"
|
|
"}\n"
|
|
"DBRef.prototype.getCollection = function(){\n"
|
|
"return this.$ref;\n"
|
|
"}\n"
|
|
"DBRef.prototype.toString = function(){\n"
|
|
"return this.tojson();\n"
|
|
"}\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"print( \"warning: no DBRef\" );\n"
|
|
"}\n"
|
|
"if ( typeof( BinData ) != \"undefined\" ){\n"
|
|
"BinData.prototype.tojson = function(){\n"
|
|
"return \"BinData type: \" + this.type + \" len: \" + this.len;\n"
|
|
"}\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"print( \"warning: no BinData\" );\n"
|
|
"}\n"
|
|
"tojson = function( x ){\n"
|
|
"if ( x == null )\n"
|
|
"return \"null\";\n"
|
|
"if ( x == undefined )\n"
|
|
"return \"\";\n"
|
|
"switch ( typeof x ){\n"
|
|
"case \"string\": {\n"
|
|
"var s = \"\\\"\";\n"
|
|
"for ( var i=0; i<x.length; i++ ){\n"
|
|
"if ( x[i] == '\"' ){\n"
|
|
"s += \"\\\\\\\"\";\n"
|
|
"}\n"
|
|
"else\n"
|
|
"s += x[i];\n"
|
|
"}\n"
|
|
"return s + \"\\\"\";\n"
|
|
"}\n"
|
|
"case \"number\":\n"
|
|
"case \"boolean\":\n"
|
|
"return \"\" + x;\n"
|
|
"case \"object\":\n"
|
|
"return tojsonObject( x );\n"
|
|
"case \"function\":\n"
|
|
"return x.toString();\n"
|
|
"default:\n"
|
|
"throw \"tojson can't handle type \" + ( typeof x );\n"
|
|
"}\n"
|
|
"}\n"
|
|
"tojsonObject = function( x ){\n"
|
|
"assert.eq( ( typeof x ) , \"object\" , \"tojsonObject needs object, not [\" + ( typeof x ) + \"]\" );\n"
|
|
"if ( typeof( x.tojson ) == \"function\" && x.tojson != tojson )\n"
|
|
"return x.tojson();\n"
|
|
"if ( typeof( x.constructor.tojson ) == \"function\" && x.constructor.tojson != tojson )\n"
|
|
"return x.constructor.tojson( x );\n"
|
|
"if ( x.toString() == \"[object MaxKey]\" )\n"
|
|
"return \"{ $maxKey : 1 }\";\n"
|
|
"if ( x.toString() == \"[object MinKey]\" )\n"
|
|
"return \"{ $minKey : 1 }\";\n"
|
|
"var s = \"{\";\n"
|
|
"var first = true;\n"
|
|
"for ( var k in x ){\n"
|
|
"var val = x[k];\n"
|
|
"if ( val == DB.prototype || val == DBCollection.prototype )\n"
|
|
"continue;\n"
|
|
"if ( first ) first = false;\n"
|
|
"else s += \" , \";\n"
|
|
"s += \"\\\"\" + k + \"\\\" : \" + tojson( val );\n"
|
|
"}\n"
|
|
"return s + \"}\";\n"
|
|
"}\n"
|
|
"shellPrint = function( x ){\n"
|
|
"it = x;\n"
|
|
"if ( x != undefined )\n"
|
|
"shellPrintHelper( x );\n"
|
|
"if ( db ){\n"
|
|
"var e = db.getPrevError();\n"
|
|
"if ( e.err ) {\n"
|
|
"if( e.nPrev <= 1 )\n"
|
|
"print( \"error on last call: \" + tojson( e.err ) );\n"
|
|
"else\n"
|
|
"print( \"an error \" + tojson(e.err) + \" occurred \" + e.nPrev + \" operations back in the command invocation\" );\n"
|
|
"}\n"
|
|
"db.resetError();\n"
|
|
"}\n"
|
|
"}\n"
|
|
"printjson = function(x){\n"
|
|
"print( tojson( x ) );\n"
|
|
"}\n"
|
|
"shellPrintHelper = function( x ){\n"
|
|
"if ( typeof( x ) == \"undefined\" ){\n"
|
|
"if ( typeof( db ) != \"undefined\" && db.getLastError ){\n"
|
|
"var e = db.getLastError();\n"
|
|
"if ( e != null )\n"
|
|
"print( e );\n"
|
|
"}\n"
|
|
"return;\n"
|
|
"}\n"
|
|
"if ( x == null ){\n"
|
|
"print( \"null\" );\n"
|
|
"return;\n"
|
|
"}\n"
|
|
"if ( typeof x != \"object\" )\n"
|
|
"return print( x );\n"
|
|
"var p = x.shellPrint;\n"
|
|
"if ( typeof p == \"function\" )\n"
|
|
"return x.shellPrint();\n"
|
|
"var p = x.tojson;\n"
|
|
"if ( typeof p == \"function\" )\n"
|
|
"print( x.tojson() );\n"
|
|
"else\n"
|
|
"print( tojson( x ) );\n"
|
|
"}\n"
|
|
"shellHelper = function( command , rest , shouldPrint ){\n"
|
|
"command = command.trim();\n"
|
|
"var args = rest.trim().replace(/;$/,\"\").split( \"\\s+\" );\n"
|
|
"if ( ! shellHelper[command] )\n"
|
|
"throw \"no command [\" + command + \"]\";\n"
|
|
"var res = shellHelper[command].apply( null , args );\n"
|
|
"if ( shouldPrint ){\n"
|
|
"shellPrintHelper( res );\n"
|
|
"}\n"
|
|
"return res;\n"
|
|
"}\n"
|
|
"help = shellHelper.help = function(){\n"
|
|
"print( \"HELP\" );\n"
|
|
"print( \"\\t\" + \"show dbs show database names\");\n"
|
|
"print( \"\\t\" + \"show collections show collections in current database\");\n"
|
|
"print( \"\\t\" + \"show users show users in current database\");\n"
|
|
"print( \"\\t\" + \"show profile show most recent system.profile entries with time >= 1ms\");\n"
|
|
"print( \"\\t\" + \"use <db name> set curent database to <db name>\" );\n"
|
|
"print( \"\\t\" + \"db.help() help on DB methods\");\n"
|
|
"print( \"\\t\" + \"db.foo.help() help on collection methods\");\n"
|
|
"print( \"\\t\" + \"db.foo.find() list objects in collection foo\" );\n"
|
|
"print( \"\\t\" + \"db.foo.find( { a : 1 } ) list objects in foo where a == 1\" );\n"
|
|
"print( \"\\t\" + \"it result of the last line evaluated; use to further iterate\");\n"
|
|
"}\n"
|
|
"shellHelper.use = function( dbname ){\n"
|
|
"db = db.getMongo().getDB( dbname );\n"
|
|
"print( \"switched to db \" + db.getName() );\n"
|
|
"}\n"
|
|
"shellHelper.it = function(){\n"
|
|
"if ( typeof( ___it___ ) == \"undefined\" || ___it___ == null ){\n"
|
|
"print( \"no cursor\" );\n"
|
|
"return;\n"
|
|
"}\n"
|
|
"shellPrintHelper( ___it___ );\n"
|
|
"}\n"
|
|
"shellHelper.show = function( what ){\n"
|
|
"assert( typeof what == \"string\" );\n"
|
|
"if( what == \"profile\" ) {\n"
|
|
"if( db.system.profile.count() == 0 ) {\n"
|
|
"print(\"db.system.profile is empty\");\n"
|
|
"print(\"Use db.setProfilingLevel(2) will enable profiling\");\n"
|
|
"print(\"Use db.system.profile.find() to show raw profile entries\");\n"
|
|
"}\n"
|
|
"else {\n"
|
|
"print();\n"
|
|
"db.system.profile.find({ millis : { $gt : 0 } }).sort({$natural:-1}).limit(5).forEach( function(x){print(\"\"+x.millis+\"ms \" + String(x.ts).substring(0,24)); print(x.info); print(\"\\n\");} )\n"
|
|
"}\n"
|
|
"return \"\";\n"
|
|
"}\n"
|
|
"if ( what == \"users\" ){\n"
|
|
"db.system.users.find().forEach( printjson );\n"
|
|
"return \"\";\n"
|
|
"}\n"
|
|
"if ( what == \"collections\" || what == \"tables\" ) {\n"
|
|
"db.getCollectionNames().forEach( function(x){print(x)} );\n"
|
|
"return \"\";\n"
|
|
"}\n"
|
|
"if ( what == \"dbs\" ) {\n"
|
|
"db.getMongo().getDBNames().sort().forEach( function(x){print(x)} );\n"
|
|
"return \"\";\n"
|
|
"}\n"
|
|
"throw \"don't know how to show [\" + what + \"]\";\n"
|
|
"}\n"
|
|
"if ( typeof( Map ) == \"undefined\" ){\n"
|
|
"Map = function(){\n"
|
|
"this._data = {};\n"
|
|
"}\n"
|
|
"}\n"
|
|
"Map.hash = function( val ){\n"
|
|
"if ( ! val )\n"
|
|
"return val;\n"
|
|
"switch ( typeof( val ) ){\n"
|
|
"case 'string':\n"
|
|
"case 'number':\n"
|
|
"case 'date':\n"
|
|
"return val.toString();\n"
|
|
"case 'object':\n"
|
|
"case 'array':\n"
|
|
"var s = \"\";\n"
|
|
"for ( var k in val ){\n"
|
|
"s += k + val[k];\n"
|
|
"}\n"
|
|
"return s;\n"
|
|
"}\n"
|
|
"throw \"can't hash : \" + typeof( val );\n"
|
|
"}\n"
|
|
"Map.prototype.put = function( key , value ){\n"
|
|
"var o = this._get( key );\n"
|
|
"var old = o.value;\n"
|
|
"o.value = value;\n"
|
|
"return old;\n"
|
|
"}\n"
|
|
"Map.prototype.get = function( key ){\n"
|
|
"return this._get( key ).value;\n"
|
|
"}\n"
|
|
"Map.prototype._get = function( key ){\n"
|
|
"var h = Map.hash( key );\n"
|
|
"var a = this._data[h];\n"
|
|
"if ( ! a ){\n"
|
|
"a = [];\n"
|
|
"this._data[h] = a;\n"
|
|
"}\n"
|
|
"for ( var i=0; i<a.length; i++ ){\n"
|
|
"if ( friendlyEqual( key , a[i].key ) ){\n"
|
|
"return a[i];\n"
|
|
"}\n"
|
|
"}\n"
|
|
"var o = { key : key , value : null };\n"
|
|
"a.push( o );\n"
|
|
"return o;\n"
|
|
"}\n"
|
|
"Map.prototype.values = function(){\n"
|
|
"var all = [];\n"
|
|
"for ( var k in this._data ){\n"
|
|
"this._data[k].forEach( function(z){ all.push( z.value ); } );\n"
|
|
"}\n"
|
|
"return all;\n"
|
|
"}\n"
|
|
"Math.sigFig = function( x , N ){\n"
|
|
"if ( ! N ){\n"
|
|
"N = 3;\n"
|
|
"}\n"
|
|
"var p = Math.pow( 10, N - Math.ceil( Math.log( Math.abs(x) ) / Math.log( 10 )) );\n"
|
|
"return Math.round(x*p)/p;\n"
|
|
"}\n"
|
|
;
|
|
|