def test_eval(self): db = self.connection.pymongo_test db.test.remove({}) self.assertRaises(TypeError, db.eval, None) self.assertRaises(TypeError, db.eval, 5) self.assertRaises(TypeError, db.eval, []) self.assertEqual(3, db.eval("function (x) {return x;}", 3)) self.assertEqual(3, db.eval(u"function (x) {return x;}", 3)) self.assertEqual(None, db.eval("function (x) {db.test.save({y:x});}", 5)) self.assertEqual(db.test.find_one()["y"], 5) self.assertEqual(5, db.eval("function (x, y) {return x + y;}", 2, 3)) self.assertEqual(5, db.eval("function () {return 5;}")) self.assertEqual(5, db.eval("2 + 3;")) self.assertEqual(5, db.eval(Code("2 + 3;"))) self.assertRaises(OperationFailure, db.eval, Code("return i;")) self.assertEqual(2, db.eval(Code("return i;", {"i": 2}))) self.assertEqual(5, db.eval(Code("i + 3;", {"i": 2}))) self.assertRaises(OperationFailure, db.eval, "5 ++ 5;")
def GET(self): map = Code(""" function() { emit(this.project, 1); } """) reduce = Code(""" function(key, values) { var total = 0; values.forEach(function(v) { total += v }); return total; } """) pattern = re.compile('^' + web.input().term + '.*') result = db.commits.map_reduce(map, reduce, query={'project': pattern}) results = [] for item in sorted(result.find(), key=lambda item: -item['value'])[:10]: results.append({ 'label': item['_id'], 'value': item['_id'], 'count': item['value'] }) return json.dumps(results)
def list_candidates(support_oppose=None): code = """ function () { %s emit(this['crp_id'], this['EXPENDITURE AMOUNT']); %s }; """ if support_oppose: code = code % ("if (this['SUPPORT/OPPOSE CODE'] === '%s') {" % support_oppose, "}") else: code = code % ("", "") map = Code(code) reduce = Code(""" function (key, values) { var sum = 0; for (var i in values) { sum += values[i]; } return sum; }; """) result = expenditures.map_reduce(map, reduce) candidates = [] for x in result.find(): candidate = expenditures.find_one({'crp_id': x['_id']}) candidate.update(x) candidates.append(candidate) return candidates
def committees_in_support_opposition(candidate_slug, support_oppose): """A list of committees that have supported/opposed the given candidate, and how much they've spent doing so. """ map = Code("""function () { if (this['SUPPORT/OPPOSE CODE'] === '%s' && this['candidate_slug'] === '%s') { emit(this['FILER COMMITTEE ID NUMBER'], this['EXPENDITURE AMOUNT']); } };""" % (support_oppose, candidate_slug)) reduce = Code("""function (key, values) { var sum = 0; for (var i in values) { sum += values[i]; } return sum; };""") committees = [] result = expenditures.map_reduce(map, reduce) for x in result.find(): committee = filers.find_one({'FILER FEC ID NUMBER': x['_id']}) committee['name'] = committee['ORGANIZATION NAME'] committee.update(x) committees.append(committee) committees.sort(key=itemgetter('value'), reverse=True) return committees
def test_types(self): self.assertRaises(TypeError, Code, 5) self.assertRaises(TypeError, Code, None) self.assertRaises(TypeError, Code, "aoeu", 5) self.assertRaises(TypeError, Code, u"aoeu", 5) self.assert_(Code("aoeu")) self.assert_(Code(u"aoeu")) self.assert_(Code("aoeu", {})) self.assert_(Code(u"aoeu", {}))
def basic_map_reduce_test(self): map = Code(open('./map.js', 'r').read()) reduce = Code(open('./reduce.js', 'r').read()) result = self.collection.map_reduce(map, reduce, {"query": {}}) # result = self.collection.map_reduce(map, reduce); print result collection = self.db[result["result"]] for item in collection.find(): print item
def test_repr(self): c = Code("hello world") self.assertEqual(repr(c), "Code('hello world', {})") c.scope["foo"] = "bar" self.assertEqual(repr(c), "Code('hello world', {'foo': 'bar'})") c = Code("hello world", {"blah": 3}) self.assertEqual(repr(c), "Code('hello world', {'blah': 3})") c = Code("\x08\xFF") self.assertEqual(repr(c), "Code('\\x08\\xff', {})")
def GetKeys(p): mr = Code("function() {for (var key in this) { emit(key, null);}}") r = Code("function(key, stuff) { return null;}") result = p.map_reduce(map=mr, reduce=r) keys = result.distinct("_id") return keys
def test_code(self): a_string = "hello world" a_code = Code("hello world") self.assert_(a_code.startswith("hello")) self.assert_(a_code.endswith("world")) self.assert_(isinstance(a_code, Code)) self.failIf(isinstance(a_string, Code)) self.assertEqual(a_code.scope, {}) a_code.scope["my_var"] = 5 self.assertEqual(a_code.scope, {"my_var": 5})
def test_code(self): a_string = "hello world" a_code = Code("hello world") self.assert_(a_code.startswith("hello")) self.assert_(a_code.endswith("world")) self.assert_(isinstance(a_code, Code)) self.assertFalse(isinstance(a_string, Code)) self.assertEqual(a_code.scope, {}) a_code.scope["my_var"] = 5 self.assertEqual(a_code.scope, {"my_var": 5})
def get_top_mapreduce(self): ''' 使用MongoDB中的mapreduce功能自动生成关于所有用户关注对象的频度统计写入top_rank集合中 ''' map = Code(open('gettopMap.js', 'r').read()) reduce = Code(open('gettopReduce.js', 'r').read()) print "INFO\t: Begin to MapReduce ..." results = self.friend_collection.map_reduce(map, reduce, "top_rank") print "INFO\t: Has been written to ", results.full_name
def group(self, key, condition, initial, reduce, finalize=None, command=True): """Perform a query similar to an SQL *group by* operation. Returns an array of grouped items. The `key` parameter can be: - ``None`` to use the entire document as a key. - A :class:`list` of keys (each a :class:`basestring`) to group by. - A :class:`basestring` or :class:`~pymongo.code.Code` instance containing a JavaScript function to be applied to each document, returning the key to group by. :Parameters: - `key`: fields to group by (see above description) - `condition`: specification of rows to be considered (as a :meth:`find` query specification) - `initial`: initial value of the aggregation counter object - `reduce`: aggregation function as a JavaScript string - `finalize`: function to be called on each object in output list. - `command` (optional): DEPRECATED if ``True``, run the group as a command instead of in an eval - this option is deprecated and will be removed in favor of running all groups as commands .. versionchanged:: 1.4 The `key` argument can now be ``None`` or a JavaScript function, in addition to a :class:`list` of keys. .. versionchanged:: 1.3 The `command` argument now defaults to ``True`` and is deprecated. """ if not command: warnings.warn( "eval-based groups are deprecated, and the " "command option will be removed.", DeprecationWarning) group = {} if isinstance(key, basestring): group["$keyf"] = Code(key) elif key is not None: group = {"key": self._fields_list_to_dict(key)} group["ns"] = self.__name group["$reduce"] = Code(reduce) group["cond"] = condition group["initial"] = initial if finalize is not None: group["finalize"] = Code(finalize) return self.__database.command({"group": group})["retval"]
def get_follower_mapreduce(self): ''' 不使用,意义不大 ''' map = Code(open('getfollowerMap.js', 'r').read()) reduce = Code(open('getfollowerReduce.js', 'r').read()) print "INFO\t: Begin to MapReduce ..." results = self.friend_collection.map_reduce( map, reduce, "top_follower", scope={'idList': self.top_hundred.keys()}) print "INFO\t: Has been written to ", results.full_name
def payee_list(request): map = Code("""function () { emit({'slug': this['payee_slug'], 'name': this['payee_name']}, this['EXPENDITURE AMOUNT']); };""") reduce = Code("""function (key, values) { var sum = 0; for (var i in values) { sum += values[i]; } return sum; };""") result = expenditures.map_reduce(map, reduce) return render_to_response('ie/payee_list.html', {'payees': [{'payee': x['_id'], 'amount': x['value']} for x in result.find().sort('_id')], } )
def where(self, code): """Adds a $where clause to this query. The `code` argument must be an instance of :class:`basestring` or :class:`~pymongo.code.Code` containing a JavaScript expression. This expression will be evaluated for each document scanned. Only those documents for which the expression evaluates to *true* will be returned as results. The keyword *this* refers to the object currently being scanned. Raises :class:`TypeError` if `code` is not an instance of :class:`basestring`. Raises :class:`~pymongo.errors.InvalidOperation` if this :class:`Cursor` has already been used. Only the last call to :meth:`where` applied to a :class:`Cursor` has any effect. :Parameters: - `code`: JavaScript expression to use as a filter """ self.__check_okay_to_chain() if not isinstance(code, Code): code = Code(code) self.__spec["$where"] = code return self
def __init__(self, measures, groupBy, condition, dbName, table, name="", maxSD=3, subject="s_id", count=False, level="subject"): if groupBy: if type(groupBy) == str: self.groupBy = [groupBy] else: self.groupBy = groupBy else: self.groupBy = [] if level == "trial": self.groupBy += ["trial"] self.level = level dbA = MongoAdmin(dbName) my_table = dbA.getTable(table) self.posts = my_table.posts self.condition = condition self.maxSD = maxSD self.name = "%s_%s" % (dbName, table) for g in self.groupBy: self.name = self.name + "_" + g for m in measures: self.name = self.name + "_" + m if name: self.name += "_%s" % name if type(measures) == str: self.measures = [measures] else: self.measures = measures self.subject = subject self.count = count #initialization and finalization for the groupBy query - note that the reduce functions are constructed at run time to correspond with the necessary subject SD screen self.initial = {"csum": 0, "ccount": 0, "ss": 0, "avg": 0, "std": 0} self.finalize = Code( "function(prev){ prev.avg = prev.csum / prev.ccount; prev.std = Math.sqrt(Math.abs(prev.ss - prev.avg * prev.csum) / prev.ccount);} " ) self.s_ids = self.posts.find(condition).distinct(subject) self.Compute()
def Trim(self): reduceFunc = Code( "function(obj,prev) { meas = obj.%s; prev.csum += meas; prev.ccount++; prev.ss += meas * meas;}" % self.measure) initial = {"csum": 0, "ccount": 0, "ss": 0, "avg": 0, "std": 0} finalize = Code( "function(prev){ prev.avg = prev.csum / prev.ccount; prev.std = Math.sqrt((prev.ss - (prev.csum * prev.csum/ prev.ccount)) / prev.ccount);}" ) mapFunc = Code("function () {emit(this.%s, 1);}" % self.measure) summary = self.posts.group({}, {}, initial, reduceFunc, finalize) if summary: self.avg = summary[0]['avg'] self.std = summary[0]['std'] self.count = summary[0]['ccount'] if str(self.count) == "NA" or str(self.count) == "nan": self.count = 0 if self.maxSD: mapFunc = Code("function() {" "emit(this.%s, 1);" "}" % (self.measure)) reduceFunc = Code("function(obj, prev) {" "zscore = Math.abs(obj - %s) / %s;" "return zscore; }" % (self.avg, self.std)) result = self.posts.map_reduce(map=mapFunc, reduce=reduceFunc) item = result.find().sort('value', -1)[0] if item['value'] > self.maxSD: self.posts.remove({self.measure: item['_id']}) self.Trim() else: self.avg = 0 self.std = 0 self.count = 0
def candidate_support_oppose(candidate_slug, support_oppose): map = Code("""function () { if (this['SUPPORT/OPPOSE CODE'] === '%s' && this['candidate_slug'] === '%s') { emit(this['CANDIDATE ID NUMBER'], this['EXPENDITURE AMOUNT']); } };""" % (support_oppose, candidate_slug)) reduce = Code("""function (key, values) { var sum = 0; for (var i in values) { sum += values[i]; } return sum; };""") result = expenditures.map_reduce(map, reduce) data = result.find_one() if data: return result.find_one()['value'] return 0
def committee_support_oppose(committee_slug, support_oppose): fec_id = filers.find_one({'committee_slug': committee_slug})['FILER FEC ID NUMBER'] map = Code("""function () { if (this['SUPPORT/OPPOSE CODE'] === '%s' && this['FILER COMMITTEE ID NUMBER'] === '%s') { emit(this['FILER COMMITTEE ID NUMBER'], this['EXPENDITURE AMOUNT']); } };""" % (support_oppose, fec_id)) reduce = Code("""function (key, values) { var sum = 0; for (var i in values) { sum += values[i]; } return sum; };""") candidates = [] result = expenditures.map_reduce(map, reduce).find_one() if result: return result['value'] return 0
def test_where(self): db = self.db db.test.remove({}) a = db.test.find() self.assertRaises(TypeError, a.where, 5) self.assertRaises(TypeError, a.where, None) self.assertRaises(TypeError, a.where, {}) for i in range(10): db.test.save({"x": i}) self.assertEqual(3, len(list(db.test.find().where('this.x < 3')))) self.assertEqual(3, len(list(db.test.find().where(Code('this.x < 3'))))) self.assertEqual( 3, len(list(db.test.find().where(Code('this.x < i', {"i": 3}))))) self.assertEqual(10, len(list(db.test.find()))) self.assertEqual(3, db.test.find().where('this.x < 3').count()) self.assertEqual(10, db.test.find().count()) self.assertEqual(3, db.test.find().where(u'this.x < 3').count()) self.assertEqual([0, 1, 2], [a["x"] for a in db.test.find().where('this.x < 3')]) self.assertEqual( [], [a["x"] for a in db.test.find({ "x": 5 }).where('this.x < 3')]) self.assertEqual( [5], [a["x"] for a in db.test.find({ "x": 5 }).where('this.x > 3')]) cursor = db.test.find().where('this.x < 3').where('this.x > 7') self.assertEqual([8, 9], [a["x"] for a in cursor]) a = db.test.find() b = a.where('this.x > 3') for _ in a: break self.assertRaises(InvalidOperation, a.where, 'this.x < 3')
def map_reduce_tags(): map = Code(""" function () { this.tags.forEach(function(z) { emit(z, 1); }); } """) reduce = Code(""" function (key, values) { var total = 0; for (var i = 0; i < values.length; i++) { total += values[i]; } return total; } """) db = Connection()['flask-test'] result = db.question.map_reduce(map, reduce, out='tags') return result.find()
def main(): wordmap = """ function wordMap(){ //find words in the document text var words = this.org_content.match(/\w+/g); if (words == null){ return; } for (var i = 0; i < words.length; i++){ //emit every word, with count of one emit(words[i], {count: 1}); } }""" wordreduce = """ function wordReduce(key,values){ var total = 0; for (var i = 0; i < values.length; i++){ total += values[i].count; } return {count: total}; }""" #Load map and reduce functions map = Code(wordmap) reduce = Code(wordreduce) db = getDB() coll = db.drops #Run the map-reduce query result = "wordcount" results = coll.map_reduce(map, reduce, result, query={"name": "Integron"}) #Print the results for result in results.find(): print(result['_id'], result['value']['count'])
def candidates_by_committee(committee_slug, support_oppose): fec_id = filers.find_one({'committee_slug': committee_slug})['FILER FEC ID NUMBER'] map = Code("""function () { if (this['SUPPORT/OPPOSE CODE'] === '%s' && this['FILER COMMITTEE ID NUMBER'] === '%s') { emit(this['crp_id'], this['EXPENDITURE AMOUNT']); } };""" % (support_oppose, fec_id)) reduce = Code("""function (key, values) { var sum = 0; for (var i in values) { sum += values[i]; } return sum; };""") candidates = [] result = expenditures.map_reduce(map, reduce) for x in result.find(): candidate = expenditures.find_one({'crp_id': x['_id']}) candidate.update(x) candidates.append(candidate) candidates.sort(key=itemgetter('value'), reverse=True) return candidates
def list_committees(): map = Code(""" function () { emit(this['FILER COMMITTEE ID NUMBER'], this['EXPENDITURE AMOUNT']); }; """) reduce = Code(""" function (key, values) { var sum = 0; for (var i in values) { sum += values[i]; } return sum; }; """) result = expenditures.map_reduce(map, reduce) committees = [] for x in result.find(): committee = filers.find_one({'FILER FEC ID NUMBER': x['_id']}) committee['name'] = committee['ORGANIZATION NAME'] committee.update(x) committees.append(committee) return committees
def eval(self, code, *args): """Evaluate a JavaScript expression on the Mongo server. Useful if you need to touch a lot of data lightly; in such a scenario the network transfer of the data could be a bottleneck. The `code` argument must be a JavaScript function. Additional positional arguments will be passed to that function when it is run on the server. Raises TypeError if `code` is not an instance of (str, unicode, `Code`). Raises OperationFailure if the eval fails. Returns the result of the evaluation. :Parameters: - `code`: string representation of JavaScript code to be evaluated - `args` (optional): additional positional arguments are passed to the `code` being evaluated """ if not isinstance(code, Code): code = Code(code) command = SON([("$eval", code), ("args", list(args))]) result = self.command(command) return result.get("retval", None)
def test_group_with_scope(self): db = self.db db.drop_collection("test") db.test.save({"a": 1}) db.test.save({"b": 1}) reduce_function = "function (obj, prev) { prev.count += inc_value; }" self.assertEqual( 2, db.test.group([], {}, {"count": 0}, Code(reduce_function, {"inc_value": 1}))[0]['count']) self.assertEqual( 4, db.test.group([], {}, {"count": 0}, Code(reduce_function, {"inc_value": 2}))[0]['count']) self.assertEqual( 1, db.test.group([], {}, {"count": 0}, Code(reduce_function, {"inc_value": 0.5}))[0]['count']) if version.at_least(db.connection(), (1, 1)): self.assertEqual( 2, db.test.group([], {}, {"count": 0}, Code(reduce_function, {"inc_value": 1}), command=True)[0]['count']) self.assertEqual( 4, db.test.group([], {}, {"count": 0}, Code(reduce_function, {"inc_value": 2}), command=True)[0]['count']) self.assertEqual( 1, db.test.group([], {}, {"count": 0}, Code(reduce_function, {"inc_value": 0.5}), command=True)[0]['count'])
def _get_code_w_scope(data): (_, data) = _get_int(data) (code, data) = _get_string(data) (scope, data) = _get_object(data) return (Code(code, scope), data)
def _unique_insert(self, message_dict, unique_key): return self.queue_database.eval( Code( "function(obj) { if ( db.%s.count({%s: obj.%s}) ) { return false; } db.%s.insert(obj); return true;}" % (self.queue, unique_key, unique_key, self.queue)), message_dict)
def test_basic_from_dict(self): self.assertRaises(TypeError, BSON.from_dict, 100) self.assertRaises(TypeError, BSON.from_dict, "hello") self.assertRaises(TypeError, BSON.from_dict, None) self.assertRaises(TypeError, BSON.from_dict, []) self.assertEqual(BSON.from_dict({}), BSON("\x05\x00\x00\x00\x00")) self.assertEqual( BSON.from_dict({"test": u"hello world"}), "\x1B\x00\x00\x00\x02\x74\x65\x73\x74\x00\x0C\x00\x00" "\x00\x68\x65\x6C\x6C\x6F\x20\x77\x6F\x72\x6C\x64\x00" "\x00") self.assertEqual( BSON.from_dict({u"mike": 100}), "\x0F\x00\x00\x00\x10\x6D\x69\x6B\x65\x00\x64\x00\x00" "\x00\x00") self.assertEqual( BSON.from_dict({"hello": 1.5}), "\x14\x00\x00\x00\x01\x68\x65\x6C\x6C\x6F\x00\x00\x00" "\x00\x00\x00\x00\xF8\x3F\x00") self.assertEqual(BSON.from_dict({"true": True}), "\x0C\x00\x00\x00\x08\x74\x72\x75\x65\x00\x01\x00") self.assertEqual( BSON.from_dict({"false": False}), "\x0D\x00\x00\x00\x08\x66\x61\x6C\x73\x65\x00\x00" "\x00") self.assertEqual( BSON.from_dict({"empty": []}), "\x11\x00\x00\x00\x04\x65\x6D\x70\x74\x79\x00\x05\x00" "\x00\x00\x00\x00") self.assertEqual( BSON.from_dict({"none": {}}), "\x10\x00\x00\x00\x03\x6E\x6F\x6E\x65\x00\x05\x00\x00" "\x00\x00\x00") self.assertEqual( BSON.from_dict({"test": Binary("test")}), "\x18\x00\x00\x00\x05\x74\x65\x73\x74\x00\x08\x00\x00" "\x00\x02\x04\x00\x00\x00\x74\x65\x73\x74\x00") self.assertEqual( BSON.from_dict({"test": Binary("test", 128)}), "\x14\x00\x00\x00\x05\x74\x65\x73\x74\x00\x04\x00\x00" "\x00\x80\x74\x65\x73\x74\x00") self.assertEqual(BSON.from_dict({"test": None}), "\x0B\x00\x00\x00\x0A\x74\x65\x73\x74\x00\x00") self.assertEqual( BSON.from_dict({"date": datetime.datetime(2007, 1, 8, 0, 30, 11)}), "\x13\x00\x00\x00\x09\x64\x61\x74\x65\x00\x38\xBE\x1C" "\xFF\x0F\x01\x00\x00\x00") self.assertEqual( BSON.from_dict({"regex": re.compile("a*b", re.IGNORECASE)}), "\x12\x00\x00\x00\x0B\x72\x65\x67\x65\x78\x00\x61\x2A" "\x62\x00\x69\x00\x00") self.assertEqual( BSON.from_dict({"$where": Code("test")}), "\x1F\x00\x00\x00\x0F\x24\x77\x68\x65\x72\x65\x00\x12" "\x00\x00\x00\x05\x00\x00\x00\x74\x65\x73\x74\x00\x05" "\x00\x00\x00\x00\x00") a = ObjectId("\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B") self.assertEqual( BSON.from_dict({"oid": a}), "\x16\x00\x00\x00\x07\x6F\x69\x64\x00\x00\x01\x02\x03" "\x04\x05\x06\x07\x08\x09\x0A\x0B\x00") self.assertEqual( BSON.from_dict({"ref": DBRef("coll", a)}), "\x2F\x00\x00\x00\x03ref\x00\x25\x00\x00\x00\x02$ref" "\x00\x05\x00\x00\x00coll\x00\x07$id\x00\x00\x01\x02" "\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x00\x00")
def generate_statistics(): """ Use mongo's map/reduce to output state-by-state (and total) counts of various Open State objects to the 'counts' collection. """ m = Code(""" function () { var val = {'bills': 1, 'introduced': 0, 'categorized': 0, 'voters': 0, 'idd_voters': 0, 'actions': this.actions.length, 'votes': this.votes.length, 'versions': this.versions.length}; if(this.hasOwnProperty('subjects')) { val['subjects'] = 1; } else { val['subjects'] = 0; } // count how many actions are categorized & introduced for(var i=0; i < this.actions.length; ++i) { if(this.actions[i]["type"] != "other") { val['categorized']++; } for(var j=0; j < this.actions[i]["type"].length; ++j) { if(this.actions[i]["type"][j] == "bill:introduced") { val['introduced'] = 1; } } } // check sponsor leg_ids val['sponsors'] = this.sponsors.length; val['idd_sponsors'] = 0; for(var i=0; i < this.sponsors.length; ++i) { if(this.sponsors[i]['leg_id']) { val['idd_sponsors'] += 1; } } // go through yes/no/other votes and count voter leg_ids for(var i=0; i < this.votes.length; ++i) { for(var j=0; j < this.votes[i]["yes_votes"].length; ++j) { val['voters'] += 1; if(this.votes[i]["yes_votes"][j]["leg_id"]) { val['idd_voters'] += 1; } } } for(var i=0; i < this.votes.length; ++i) { for(var j=0; j < this.votes[i]["no_votes"].length; ++j) { val['voters'] += 1; if(this.votes[i]["no_votes"][j]["leg_id"]) { val['idd_voters'] += 1; } } } for(var i=0; i < this.votes.length; ++i) { for(var j=0; j < this.votes[i]["other_votes"].length; ++j) { val['voters'] += 1; if(this.votes[i]["other_votes"][j]["leg_id"]) { val['idd_voters'] += 1; } } } emit(this['state'], val); emit('total', val); }""") r = Code(""" function (key, values) { sums = {'bills': 0, 'actions': 0, 'votes': 0, 'versions': 0, 'subjects': 0, 'introduced': 0, 'categorized': 0, 'voters': 0, 'idd_voters': 0, 'sponsors': 0, 'idd_sponsors': 0}; for (var i in values) { value = values[i]; for (var t in value) { sums[t] += value[t]; } } return sums; }""") # a finalizer to convert all counts from JS numbers (floats) to longs f = Code(""" function (key, value) { for (var t in value) { value[t] = new NumberLong(value[t]); } return value; }""") db.bills.map_reduce(m, r, finalize=f, out='counts')
def __setattr__(self, name, code): self._database.system.js.save({"_id": name, "value": Code(code)}, safe=True)
def map_reduce( self, map_func, reduce_func ): map_func = Code(map_func.replace('\n','')) reduce_func = Code(reduce_func.replace('\n','')) return self._monga._db[self._doctype._collection_name].map_reduce(map_func, reduce_func)