Merge branch 'master' of http://github.com/mongodb/mongo-python-driver

Author: Reed O'Brien

bson/_cbsonmodule.c

@@ -778,6 +778,12 @@ int write_dict(buffer_t buffer, PyObject* dict, unsigned char check_keys, unsign
     }
     while ((key = PyIter_Next(iter)) != NULL) {
         PyObject* value = PyDict_GetItem(dict, key);
+        if (!value) {
+            PyErr_SetObject(PyExc_KeyError, key);
+            Py_DECREF(key);
+            Py_DECREF(iter);
+            return 0;
+        }
         if (!decode_and_write_pair(buffer, key, value, check_keys, top_level)) {
             Py_DECREF(key);
             Py_DECREF(iter);

bson/son.py

@@ -18,6 +18,7 @@
 of keys is important. A SON object can be used just like a normal Python
 dictionary."""
 
+import copy
 
 class SON(dict):
     """SON data.
@@ -202,3 +203,9 @@ def transform_value(value):
             return value
 
         return transform_value(dict(self))
+
+    def __deepcopy__(self, memo):
+        out = SON()
+        for k, v in self.iteritems():
+            out[k] = copy.deepcopy(v, memo)
+        return out

pymongo/collection.py

@@ -634,11 +634,13 @@ def create_index(self, key_or_list, deprecated_unique=None,
 
         index.update(kwargs)
 
+        self.__database.system.indexes.insert(index, manipulate=False,
+                                              check_keys=False,
+                                              safe=True)
+
         self.__database.connection._cache_index(self.__database.name,
                                                 self.__name, name, ttl)
 
-        self.__database.system.indexes.insert(index, manipulate=False,
-                                              check_keys=False)
         return name
 
     def ensure_index(self, key_or_list, deprecated_unique=None,

pymongo/connection.py

@@ -81,20 +81,28 @@ def _str_to_node(string, default_port=27017):
     return (host, port)
 
 
-def _parse_uri(uri, default_port):
+def _parse_uri(uri, default_port=27017):
     """MongoDB URI parser.
     """
-    info = {}
 
     if uri.startswith("mongodb://"):
         uri = uri[len("mongodb://"):]
     elif "://" in uri:
         raise InvalidURI("Invalid uri scheme: %s" % _partition(uri, "://")[0])
 
-    (hosts, database) = _partition(uri, "/")
+    (hosts, namespace) = _partition(uri, "/")
 
-    if not database:
-        database = None
+    raw_options = None
+    if namespace:
+        (namespace, raw_options) = _partition(namespace, "?")
+        if namespace.find(".") < 0:
+            db = namespace
+            collection = None
+        else:
+            (db, collection) = namespace.split(".", 1)
+    else:
+        db = None
+        collection = None
 
     username = None
     password = None
@@ -112,7 +120,21 @@ def _parse_uri(uri, default_port):
             raise InvalidURI("empty host (or extra comma in host list)")
         host_list.append(_str_to_node(host, default_port))
 
-    return (host_list, database, username, password)
+    options = {}
+    if raw_options:
+        and_idx = raw_options.find("&")
+        semi_idx = raw_options.find(";")
+        if and_idx >= 0 and semi_idx >= 0:
+            raise InvalidURI("Cannot mix & and ; for option separators.")
+        elif and_idx >= 0:
+            options = dict([kv.split("=") for kv in raw_options.split("&")])
+        elif semi_idx >= 0:
+            options = dict([kv.split("=") for kv in raw_options.split(";")])
+        elif raw_options.find("="):
+            options = dict([raw_options.split("=")])
+
+
+    return (host_list, db, username, password, collection, options)
 
 
 def _closed(sock):
@@ -266,12 +288,16 @@ def __init__(self, host=None, port=None, pool_size=None,
         database = None
         username = None
         password = None
+        collection = None
+        options = {}
         for uri in host:
-            (n, db, u, p) = _parse_uri(uri, port)
+            (n, db, u, p, coll, opts) = _parse_uri(uri, port)
             nodes.update(n)
             database = db or database
             username = u or username
             password = p or password
+            collection = coll or collection
+            options = opts or options
         if not nodes:
             raise ConfigurationError("need to specify at least one host")
         self.__nodes = nodes
@@ -292,11 +318,20 @@ def __init__(self, host=None, port=None, pool_size=None,
         self.__host = None
         self.__port = None
 
-        self.__slave_okay = slave_okay
+        if options.has_key("slaveok"):
+            self.__slave_okay = options['slaveok'][0].upper()=='T'
+        else:
+            self.__slave_okay = slave_okay
+
         if slave_okay and len(self.__nodes) > 1:
             raise ConfigurationError("cannot specify slave_okay for a paired "
                                      "or replica set connection")
 
+        # TODO - Support using other options like w and fsync from URI
+        self.__options = options
+        # TODO - Support setting the collection from URI as the Java driver does
+        self.__collection = collection
+
         self.__cursor_manager = CursorManager(self)
 
         self.__pool = _Pool(self.__connect)
@@ -615,7 +650,7 @@ def __check_response_to_last_error(self, response):
             raise AutoReconnect("not master")
 
         if "code" in error:
-            if error["code"] in [11000, 11001]:
+            if error["code"] in [11000, 11001, 12582]:
                 raise DuplicateKeyError(error["err"])
             else:
                 raise OperationFailure(error["err"], error["code"])

test/test_collection.py

@@ -114,6 +114,12 @@ def test_create_index(self):
                      [a["name"] for a in db.system.indexes
                       .find({"ns": u"pymongo_test.test"})])
 
+        db.test.drop()
+        db.test.insert({'a':1})
+        db.test.insert({'a':1})
+        self.assertRaises(DuplicateKeyError, db.test.create_index,
+                                                    'a', unique=True)
+
     def test_ensure_index(self):
         db = self.db
 

test/test_connection.py

@@ -236,40 +236,53 @@ def test_disconnect(self):
         coll.count()
 
     def test_parse_uri(self):
-        self.assertEqual(([("localhost", 27017)], None, None, None),
+        self.assertEqual(([("localhost", 27017)], None, None, None, None, {}),
                          _parse_uri("localhost", 27017))
-        self.assertEqual(([("localhost", 27018)], None, None, None),
+        self.assertEqual(([("localhost", 27018)], None, None, None, None, {}),
                          _parse_uri("localhost", 27018))
         self.assertRaises(InvalidURI, _parse_uri,
                           "http://foobar.com", 27017)
         self.assertRaises(InvalidURI, _parse_uri,
                           "http://[email protected]", 27017)
 
-        self.assertEqual(([("localhost", 27017)], None, None, None),
+        self.assertEqual(([("localhost", 27017)], None, None, None, None, {}),
                          _parse_uri("mongodb://localhost", 27017))
-        self.assertEqual(([("localhost", 27017)], None, "fred", "foobar"),
+        self.assertEqual(([("localhost", 27017)], None, "fred", "foobar", None, {}),
                          _parse_uri("mongodb://fred:foobar@localhost",
                                                27017))
-        self.assertEqual(([("localhost", 27017)], "baz", "fred", "foobar"),
+        self.assertEqual(([("localhost", 27017)], "baz", "fred", "foobar", None, {}),
                          _parse_uri("mongodb://fred:foobar@localhost/baz",
                                                27017))
         self.assertEqual(([("example1.com", 27017), ("example2.com", 27017)],
-                          None, None, None),
+                          None, None, None, None, {}),
                          _parse_uri("mongodb://example1.com:27017,example2.com:27017",
                                                27018))
         self.assertEqual(([("localhost", 27017),
                            ("localhost", 27018),
-                           ("localhost", 27019)], None, None, None),
+                           ("localhost", 27019)], None, None, None, None, {}),
                          _parse_uri("mongodb://localhost,localhost:27018,localhost:27019",
                                                27017))
 
-        self.assertEqual(([("localhost", 27018)], None, None, None),
+        self.assertEqual(([("localhost", 27018)], None, None, None, None, {}),
                          _parse_uri("localhost:27018", 27017))
-        self.assertEqual(([("localhost", 27017)], "foo", None, None),
+        self.assertEqual(([("localhost", 27017)], "foo", None, None, None, {}),
                          _parse_uri("localhost/foo", 27017))
-        self.assertEqual(([("localhost", 27017)], None, None, None),
+        self.assertEqual(([("localhost", 27017)], None, None, None, None, {}),
                          _parse_uri("localhost/", 27017))
 
+        self.assertEqual(([("localhost", 27017)], "test", None, None, "yield_historical.in", {}),
+                         _parse_uri("mongodb://localhost/test.yield_historical.in", 27017))
+        self.assertEqual(([("localhost", 27017)], "test", "fred", "foobar", "yield_historical.in", {}),
+                         _parse_uri("mongodb://fred:foobar@localhost/test.yield_historical.in",
+                                               27017))
+        self.assertEqual(([("example1.com", 27017), ("example2.com", 27017)],
+                          "test", None, None, "yield_historical.in", {}),
+                         _parse_uri("mongodb://example1.com:27017,example2.com:27017/test.yield_historical.in",
+                                                27017))
+        self.assertEqual(([("localhost", 27017)], "test", "fred", "foobar", "yield_historical.in", {'slaveok': 'true'}),
+                         _parse_uri("mongodb://fred:foobar@localhost/test.yield_historical.in?slaveok=true",
+                                               27017))
+
     def test_from_uri(self):
         c = Connection(self.host, self.port)
 
@@ -304,6 +317,8 @@ def test_from_uri(self):
         self.assert_(Connection("mongodb://%s:%s" %
                                 (self.host, self.port),
                                 slave_okay=True).slave_okay)
+        self.assert_(Connection("mongodb://%s:%s/?slaveok=true;w=2" %
+                                (self.host, self.port)).slave_okay)
 
     def test_fork(self):
         """Test using a connection before and after a fork.