"""Check if a database name is valid.

if not name:

raise InvalidName("database name cannot be the empty string")

for invalid_char in [" ", ".", "$", "/", "\\", "\x00"]:

if invalid_char in name:

raise InvalidName("database names cannot contain the "

"""A Mongo database.

def __init__(self, connection, name):

"""Get a database by connection and name.

super(Database,

self).__init__(slave_okay=connection.slave_okay,

read_preference=connection.read_preference,

tag_sets=connection.tag_sets,

secondary_acceptable_latency_ms=(

connection.secondary_acceptable_latency_ms),

safe=connection.safe,

uuidrepresentation=connection.uuid_subtype,

**connection.write_concern)

if not isinstance(name, basestring):

raise TypeError("name must be an instance "

"of %s" % (basestring.__name__,))

if name != '$external':

_check_name(name)

self.__name = unicode(name)

self.__connection = connection

self.__incoming_manipulators = []

self.__incoming_copying_manipulators = []

self.__outgoing_manipulators = []

self.__outgoing_copying_manipulators = []

self.add_son_manipulator(ObjectIdInjector())

def add_son_manipulator(self, manipulator):

"""Add a new son manipulator to this database.

def method_overwritten(instance, method):

return getattr(instance, method) != \

getattr(super(instance.__class__, instance), method)

if manipulator.will_copy():

if method_overwritten(manipulator, "transform_incoming"):

self.__incoming_copying_manipulators.insert(0, manipulator)

if method_overwritten(manipulator, "transform_outgoing"):

self.__outgoing_copying_manipulators.insert(0, manipulator)

else:

if method_overwritten(manipulator, "transform_incoming"):

self.__incoming_manipulators.insert(0, manipulator)

if method_overwritten(manipulator, "transform_outgoing"):

self.__outgoing_manipulators.insert(0, manipulator)

@property

def system_js(self):

"""A :class:`SystemJS` helper for this :class:`Database`.

return SystemJS(self)

@property

def connection(self):

"""The client instance for this :class:`Database`.

return self.__connection

@property

def name(self):

"""The name of this :class:`Database`.

return self.__name

@property

def incoming_manipulators(self):

"""List all incoming SON manipulators

return [manipulator.__class__.__name__

for manipulator in self.__incoming_manipulators]

@property

def incoming_copying_manipulators(self):

"""List all incoming SON copying manipulators

return [manipulator.__class__.__name__

for manipulator in self.__incoming_copying_manipulators]

@property

def outgoing_manipulators(self):

"""List all outgoing SON manipulators

return [manipulator.__class__.__name__

for manipulator in self.__outgoing_manipulators]

@property

def outgoing_copying_manipulators(self):

"""List all outgoing SON copying manipulators

return [manipulator.__class__.__name__

for manipulator in self.__outgoing_copying_manipulators]

def __eq__(self, other):

if isinstance(other, Database):

us = (self.__connection, self.__name)

them = (other.__connection, other.__name)

return us == them

return NotImplemented

def __ne__(self, other):

return not self == other

def __repr__(self):

return "Database(%r, %r)" % (self.__connection, self.__name)

def __getattr__(self, name):

"""Get a collection of this database by name.

return Collection(self, name)

def __getitem__(self, name):

"""Get a collection of this database by name.

return self.__getattr__(name)

def create_collection(self, name, **kwargs):

"""Create a new :class:`~pymongo.collection.Collection` in this

opts = {"create": True}

opts.update(kwargs)

if name in self.collection_names():

raise CollectionInvalid("collection %s already exists" % name)

return Collection(self, name, **opts)

def _fix_incoming(self, son, collection):

"""Apply manipulators to an incoming SON object before it gets stored.

for manipulator in self.__incoming_manipulators:

son = manipulator.transform_incoming(son, collection)

for manipulator in self.__incoming_copying_manipulators:

son = manipulator.transform_incoming(son, collection)

return son

def _fix_outgoing(self, son, collection):

"""Apply manipulators to a SON object as it comes out of the database.

for manipulator in reversed(self.__outgoing_manipulators):

son = manipulator.transform_outgoing(son, collection)

for manipulator in reversed(self.__outgoing_copying_manipulators):

son = manipulator.transform_outgoing(son, collection)

return son

def command(self, command, value=1,

check=True, allowable_errors=[],

uuid_subtype=OLD_UUID_SUBTYPE, **kwargs):

"""Issue a MongoDB command.

if isinstance(command, basestring):

command = SON([(command, value)])

command_name = command.keys()[0].lower()

must_use_master = kwargs.pop('_use_master', False)

if command_name not in rp.secondary_ok_commands:

must_use_master = True

# Special-case: mapreduce can go to secondaries only if inline

if command_name == 'mapreduce':

out = command.get('out') or kwargs.get('out')

if not isinstance(out, dict) or not out.get('inline'):

must_use_master = True

extra_opts = {

'as_class': kwargs.pop('as_class', None),

'slave_okay': kwargs.pop('slave_okay', self.slave_okay),

'_must_use_master': must_use_master,

'_uuid_subtype': uuid_subtype

}

extra_opts['read_preference'] = kwargs.pop(

'read_preference',

self.read_preference)

extra_opts['tag_sets'] = kwargs.pop(

'tag_sets',

self.tag_sets)

extra_opts['secondary_acceptable_latency_ms'] = kwargs.pop(

'secondary_acceptable_latency_ms',

self.secondary_acceptable_latency_ms)

fields = kwargs.get('fields')

if fields is not None and not isinstance(fields, dict):

kwargs['fields'] = helpers._fields_list_to_dict(fields)

command.update(kwargs)

result = self["$cmd"].find_one(command, **extra_opts)

if check:

msg = "command %s failed: %%s" % repr(command).replace("%", "%%")

helpers._check_command_response(result, self.connection.disconnect,

msg, allowable_errors)

return result

def collection_names(self, include_system_collections=True):

"""Get a list of all the collection names in this database.

results = self["system.namespaces"].find(_must_use_master=True)

names = [r["name"] for r in results]

names = [n[len(self.__name) + 1:] for n in names

if n.startswith(self.__name + ".") and "$" not in n]

if not include_system_collections:

names = [n for n in names if not n.startswith("system.")]

return names

def drop_collection(self, name_or_collection):

"""Drop a collection.

name = name_or_collection

if isinstance(name, Collection):

name = name.name

if not isinstance(name, basestring):

raise TypeError("name_or_collection must be an instance of "

"%s or Collection" % (basestring.__name__,))

self.__connection._purge_index(self.__name, name)

self.command("drop", unicode(name), allowable_errors=["ns not found"])

def validate_collection(self, name_or_collection,

scandata=False, full=False):

"""Validate a collection.

name = name_or_collection

if isinstance(name, Collection):

name = name.name

if not isinstance(name, basestring):

raise TypeError("name_or_collection must be an instance of "

"%s or Collection" % (basestring.__name__,))

result = self.command("validate", unicode(name),

scandata=scandata, full=full)

valid = True

# Pre 1.9 results

if "result" in result:

info = result["result"]

if info.find("exception") != -1 or info.find("corrupt") != -1:

raise CollectionInvalid("%s invalid: %s" % (name, info))

# Sharded results

elif "raw" in result:

for _, res in result["raw"].iteritems():

if "result" in res:

info = res["result"]

if (info.find("exception") != -1 or

info.find("corrupt") != -1):

raise CollectionInvalid("%s invalid: "

"%s" % (name, info))

elif not res.get("valid", False):

valid = False

break

# Post 1.9 non-sharded results.

elif not result.get("valid", False):

valid = False

if not valid:

raise CollectionInvalid("%s invalid: %r" % (name, result))

return result

def current_op(self, include_all=False):

"""Get information on operations currently running.

if include_all:

return self['$cmd.sys.inprog'].find_one({"$all": True})

else:

return self['$cmd.sys.inprog'].find_one()

def profiling_level(self):

"""Get the database's current profiling level.

result = self.command("profile", -1)

assert result["was"] >= 0 and result["was"] <= 2

return result["was"]

def set_profiling_level(self, level, slow_ms=None):

"""Set the database's profiling level.

if not isinstance(level, int) or level < 0 or level > 2:

raise ValueError("level must be one of (OFF, SLOW_ONLY, ALL)")

if slow_ms is not None and not isinstance(slow_ms, int):

raise TypeError("slow_ms must be an integer")

if slow_ms is not None:

self.command("profile", level, slowms=slow_ms)

else:

self.command("profile", level)

def profiling_info(self):

"""Returns a list containing current profiling information.

return list(self["system.profile"].find())

def error(self):

"""Get a database error if one occured on the last operation.

error = self.command("getlasterror")

error_msg = error.get("err", "")

if error_msg is None:

return None

if error_msg.startswith("not master"):

self.__connection.disconnect()

return error

def last_status(self):

"""Get status information from the last operation.

return self.command("getlasterror")

def previous_error(self):

"""Get the most recent error to have occurred on this database.

error = self.command("getpreverror")

if error.get("err", 0) is None:

return None

return error

def reset_error_history(self):

"""Reset the error history of this database.

self.command("reseterror")

def __iter__(self):

return self

def next(self):

raise TypeError("'Database' object is not iterable")

def add_user(self, name, password=None, read_only=None, **kwargs):

"""Create user `name` with password `password`.

user = self.system.users.find_one({"user": name}) or {"user": name}

if password is not None:

user["pwd"] = auth._password_digest(name, password)

if read_only is not None:

user["readOnly"] = common.validate_boolean('read_only', read_only)

user.update(kwargs)

try:

self.system.users.save(user, **self._get_wc_override())

except OperationFailure, e:

# First admin user add fails gle in MongoDB >= 2.1.2

# See SERVER-4225 for more information.

if 'login' in str(e):

pass

else:

raise

def remove_user(self, name):

"""Remove user `name` from this :class:`Database`.

self.system.users.remove({"user": name}, **self._get_wc_override())

def authenticate(self, name, password=None,

source=None, mechanism='MONGODB-CR', **kwargs):

"""Authenticate to use this database.

if not isinstance(name, basestring):

raise TypeError("name must be an instance "

"of %s" % (basestring.__name__,))

if password is not None and not isinstance(password, basestring):

raise TypeError("password must be an instance "

"of %s" % (basestring.__name__,))

if source is not None and not isinstance(source, basestring):

raise TypeError("source must be an instance "

"of %s" % (basestring.__name__,))

common.validate_auth_mechanism('mechanism', mechanism)

validated_options = {}

for option, value in kwargs.iteritems():

normalized, val = common.validate_auth_option(option, value)

validated_options[normalized] = val

credentials = auth._build_credentials_tuple(mechanism,

source or self.name, unicode(name),

password and unicode(password) or None,

validated_options)

self.connection._cache_credentials(self.name, credentials)

return True

def logout(self):

"""Deauthorize use of this database for this client instance.

# Sockets will be deauthenticated as they are used.

self.connection._purge_credentials(self.name)

def dereference(self, dbref):

"""Dereference a :class:`~bson.dbref.DBRef`, getting the

if not isinstance(dbref, DBRef):

raise TypeError("cannot dereference a %s" % type(dbref))

if dbref.database is not None and dbref.database != self.__name:

raise ValueError("trying to dereference a DBRef that points to "

"another database (%r not %r)" % (dbref.database,

self.__name))

return self[dbref.collection].find_one({"_id": dbref.id})

def eval(self, code, *args):

"""Evaluate a JavaScript expression in MongoDB.

if not isinstance(code, Code):

code = Code(code)

result = self.command("$eval", code, args=args)

return result.get("retval", None)

def __call__(self, *args, **kwargs):

"""This is only here so that some API misusages are easier to debug.

raise TypeError("'Database' object is not callable. If you meant to "

"call the '%s' method on a '%s' object it is "

"failing because no such method exists." % (

"""Helper class for dealing with stored JavaScript.

def __init__(self, database):

"""Get a system js helper for the database `database`.

# can't just assign it since we've overridden __setattr__

object.__setattr__(self, "_db", database)

def __setattr__(self, name, code):

self._db.system.js.save({"_id": name, "value": Code(code)},

**self._db._get_wc_override())

def __setitem__(self, name, code):

self.__setattr__(name, code)

def __delattr__(self, name):

self._db.system.js.remove({"_id": name}, **self._db._get_wc_override())

def __delitem__(self, name):

self.__delattr__(name)

def __getattr__(self, name):

return lambda *args: self._db.eval(Code("function() { "

"return this[name].apply("

"this, arguments); }",

scope={'name': name}), *args)

def __getitem__(self, name):

return self.__getattr__(name)

def list(self):

"""Get a list of the names of the functions stored in this database.