def insert(self, doc_or_docs, manipulate=True, safe=False, check_keys=True, **kwargs): """Insert a document(s) into this collection. If `manipulate` is set, the document(s) are manipulated using any :class:`~pymongo.son_manipulator.SONManipulator` instances that have been added to this :class:`~pymongo.database.Database`. Returns the ``"_id"`` of the inserted document or a list of ``"_id"`` values of the inserted documents. If the document(s) does not already contain an ``"_id"`` one will be added. If `safe` is ``True`` then the insert will be checked for errors, raising :class:`~pymongo.errors.OperationFailure` if one occurred. Safe inserts wait for a response from the database, while normal inserts do not. Any additional keyword arguments imply ``safe=True``, and will be used as options for the resultant `getLastError` command. For example, to wait for replication to 3 nodes, pass ``w=3``. :Parameters: - `doc_or_docs`: a document or list of documents to be inserted - `manipulate` (optional): manipulate the documents before inserting? - `safe` (optional): check that the insert succeeded? - `check_keys` (optional): check if keys start with '$' or contain '.', raising :class:`~pymongo.errors.InvalidName` in either case - `**kwargs` (optional): any additional arguments imply ``safe=True``, and will be used as options for the `getLastError` command .. versionadded:: 1.8 Support for passing `getLastError` options as keyword arguments. .. versionchanged:: 1.1 Bulk insert works with any iterable .. mongodoc:: insert """ docs = doc_or_docs return_one = False if isinstance(docs, dict): return_one = True docs = [docs] if manipulate: docs = [self.__database._fix_incoming(doc, self) for doc in docs] if kwargs: safe = True self.__database.connection._send_message( message.insert(self.__full_name, docs, check_keys, safe, kwargs), safe) ids = [doc.get("_id", None) for doc in docs] return return_one and ids[0] or ids
def insert(self, doc_or_docs, manipulate=True, safe=False, check_keys=True): """Insert a document(s) into this collection. If manipulate is set the document(s) are manipulated using any SONManipulators that have been added to this database. Returns the _id of the inserted document or a list of _ids of the inserted documents. If the document(s) does not already contain an '_id' one will be added. If `safe` is True then the insert will be checked for errors, raising OperationFailure if one occurred. Safe inserts wait for a response from the database, while normal inserts do not. :Parameters: - `doc_or_docs`: a SON object or list of SON objects to be inserted - `manipulate` (optional): manipulate the documents before inserting? - `safe` (optional): check that the insert succeeded? - `check_keys` (optional): check if keys start with '$' or contain '.', raising `pymongo.errors.InvalidName` in either case .. versionchanged:: 1.1 Bulk insert works with any iterable """ docs = doc_or_docs if isinstance(docs, dict): docs = [docs] if manipulate: docs = [self.__database._fix_incoming(doc, self) for doc in docs] self.__database.connection._send_message( message.insert(self.__full_name, docs, check_keys, safe), safe) ids = [doc.get("_id", None) for doc in docs] return len(ids) == 1 and ids[0] or ids
def legacy_insert(self, operation, write_concern): """Do a legacy insert and return the result. """ # We have to do this here since Collection.insert # throws away results and we need to check for jnote. client = self.collection.database.connection uuid_subtype = self.collection.uuid_subtype return client._send_message( insert(self.name, [operation], True, True, write_concern, False, uuid_subtype), True)
def test_pymongo(): response = b"%s%s%s%s%s" % (struct.pack("<i", 4), struct.pack( "<q", 1), struct.pack("<i", 1), struct.pack( "<i", 1), bson.BSON.encode({"hello": "world"})) assert asynmongo._unpack_response(response, 1) == { 'starting_from': 1, 'number_returned': 1, 'cursor_id': 1, 'data': [{ 'hello': 'world' }] } payload = bson.BSON.encode({"hello": "world"}) response = b"%s%s%s" % (struct.pack( "<B", 0), struct.pack("<i", len(payload)), payload) assert asynmongo._unpack_response(response, 2013) == { 'first_payload_type': 0, 'data': [{ 'hello': 'world' }], 'first_payload_size': 22 } opts = CodecOptions(SON) assert auth._auth_key(1, "a", "b") == "90b38d5dbfabd0b883e17ae67847220a" assert message.query(0, "%s.$cmd" % "mydb", 0, 1, SON({ 'getnonce': 1 }), SON({}), opts) == ( 1804289383, b'>\x00\x00\x00gE\x8bk\x00\x00\x00\x00\xd4\x07\x00\x00\x00\x00\x00\x00mydb.$cmd\x00\x00\x00\x00\x00\x01\x00\x00\x00\x13\x00\x00\x00\x10getnonce\x00\x01\x00\x00\x00\x00\x05\x00\x00\x00\x00', 19) assert message.query(0, "col.a", 0, 1, {"_id": 1}, None, opts) == ( 846930886, b'0\x00\x00\x00\xc6#{2\x00\x00\x00\x00\xd4\x07\x00\x00\x00\x00\x00\x00col.a\x00\x00\x00\x00\x00\x01\x00\x00\x00\x0e\x00\x00\x00\x10_id\x00\x01\x00\x00\x00\x00', 14) assert message.update("col.a", 0, 0, {"_id": 1}, { "a": 1 }, 1, (), False, opts) == ( 1681692777, b'8\x00\x00\x00i\x98<d\x00\x00\x00\x00\xd1\x07\x00\x00\x00\x00\x00\x00col.a\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x10_id\x00\x01\x00\x00\x00\x00\x0c\x00\x00\x00\x10a\x00\x01\x00\x00\x00\x00<\x00\x00\x00i\x98<d\x00\x00\x00\x00\xd4\x07\x00\x00\x00\x00\x00\x00col.$cmd\x00\x00\x00\x00\x00\xff\xff\xff\xff\x17\x00\x00\x00\x10getlasterror\x00\x01\x00\x00\x00\x00', 14) msg = message.delete("col.a", {"_id": 1}, 1, (), opts, 0) assert len(msg) == 3 and msg[0] == 1714636915 and msg[-1] == 14 msg = message.insert("col.a", [{"a": 1}], False, 1, (), 0, opts) assert len(msg) == 3 and msg[0] == 1957747793 and msg[-1] == 12
def insert(self, doc_or_docs, manipulate=True, safe=False, check_keys=True): """Insert a document(s) into this collection. If manipulate is set the document(s) are manipulated using any SONManipulators that have been added to this database. Returns the _id of the inserted document or a list of _ids of the inserted documents. If the document(s) does not already contain an '_id' one will be added. If `safe` is True then the insert will be checked for errors, raising OperationFailure if one occurred. Safe inserts wait for a response from the database, while normal inserts do not. :Parameters: - `doc_or_docs`: a SON object or list of SON objects to be inserted - `manipulate` (optional): manipulate the documents before inserting? - `safe` (optional): check that the insert succeeded? - `check_keys` (optional): check if keys start with '$' or contain '.', raising `pymongo.errors.InvalidName` in either case .. versionchanged:: 1.1 Bulk insert works with any iterable .. mongodoc:: insert """ docs = doc_or_docs return_one = False if isinstance(docs, dict): return_one = True docs = [docs] if manipulate: docs = [self.__database._fix_incoming(doc, self) for doc in docs] self.__database.connection._send_message( message.insert(self.__full_name, docs, check_keys, safe), safe) ids = [doc.get("_id", None) for doc in docs] return return_one and ids[0] or ids
def insert(self, doc_or_docs, manipulate=True, safe=False, check_keys=True, continue_on_error=False, **kwargs): """Insert a document(s) into this collection. If `manipulate` is ``True``, the document(s) are manipulated using any :class:`~pymongo.son_manipulator.SONManipulator` instances that have been added to this :class:`~pymongo.database.Database`. In this case an ``"_id"`` will be added if the document(s) does not already contain one and the ``"id"`` (or list of ``"_id"`` values for more than one document) will be returned. If `manipulate` is ``False`` and the document(s) does not include an ``"_id"`` one will be added by the server. The server does not return the ``"_id"`` it created so ``None`` is returned. If `safe` is ``True`` then the insert will be checked for errors, raising :class:`~pymongo.errors.OperationFailure` if one occurred. Safe inserts wait for a response from the database, while normal inserts do not. Any additional keyword arguments imply ``safe=True``, and will be used as options for the resultant `getLastError` command. For example, to wait for replication to 3 nodes, pass ``w=3``. :Parameters: - `doc_or_docs`: a document or list of documents to be inserted - `manipulate` (optional): manipulate the documents before inserting? - `safe` (optional): check that the insert succeeded? - `check_keys` (optional): check if keys start with '$' or contain '.', raising :class:`~pymongo.errors.InvalidName` in either case - `continue_on_error` (optional): If True, the database will not stop processing a bulk insert if one fails (e.g. due to duplicate IDs). This makes bulk insert behave similarly to a series of single inserts, except lastError will be set if any insert fails, not just the last one. If multiple errors occur, only the most recent will be reported by :meth:`~pymongo.database.Database.error`. - `**kwargs` (optional): any additional arguments imply ``safe=True``, and will be used as options for the `getLastError` command .. note:: `continue_on_error` requires server version **>= 1.9.1** .. versionadded:: 2.0.1+ Support for continue_on_error. .. versionadded:: 1.8 Support for passing `getLastError` options as keyword arguments. .. versionchanged:: 1.1 Bulk insert works with any iterable .. mongodoc:: insert """ docs = doc_or_docs return_one = False if isinstance(docs, dict): return_one = True docs = [docs] if manipulate: docs = [self.__database._fix_incoming(doc, self) for doc in docs] if self.safe or kwargs: safe = True if not kwargs: kwargs.update(self.get_lasterror_options()) self.__database.connection._send_message( message.insert(self.__full_name, docs, check_keys, safe, continue_on_error, kwargs), safe ) ids = [doc.get("_id", None) for doc in docs] return return_one and ids[0] or ids
def insert(self, doc_or_docs, manipulate=True, safe=False, check_keys=True, continue_on_error=False, **kwargs): """Insert a document(s) into this collection. If `manipulate` is ``True``, the document(s) are manipulated using any :class:`~pymongo.son_manipulator.SONManipulator` instances that have been added to this :class:`~pymongo.database.Database`. In this case an ``"_id"`` will be added if the document(s) does not already contain one and the ``"id"`` (or list of ``"_id"`` values for more than one document) will be returned. If `manipulate` is ``False`` and the document(s) does not include an ``"_id"`` one will be added by the server. The server does not return the ``"_id"`` it created so ``None`` is returned. If `safe` is ``True`` then the insert will be checked for errors, raising :class:`~pymongo.errors.OperationFailure` if one occurred. Safe inserts wait for a response from the database, while normal inserts do not. Any additional keyword arguments imply ``safe=True``, and will be used as options for the resultant `getLastError` command. For example, to wait for replication to 3 nodes, pass ``w=3``. :Parameters: - `doc_or_docs`: a document or list of documents to be inserted - `manipulate` (optional): manipulate the documents before inserting? - `safe` (optional): check that the insert succeeded? - `check_keys` (optional): check if keys start with '$' or contain '.', raising :class:`~pymongo.errors.InvalidName` in either case - `continue_on_error` (optional): If True, the database will not stop processing a bulk insert if one fails (e.g. due to duplicate IDs). This makes bulk insert behave similarly to a series of single inserts, except lastError will be set if any insert fails, not just the last one. If multiple errors occur, only the most recent will be reported by :meth:`~pymongo.database.Database.error`. - `**kwargs` (optional): any additional arguments imply ``safe=True``, and will be used as options for the `getLastError` command .. note:: `continue_on_error` requires server version **>= 1.9.1** .. versionadded:: 2.1 Support for continue_on_error. .. versionadded:: 1.8 Support for passing `getLastError` options as keyword arguments. .. versionchanged:: 1.1 Bulk insert works with any iterable .. mongodoc:: insert """ docs = doc_or_docs return_one = False if isinstance(docs, dict): return_one = True docs = [docs] if manipulate: docs = [self.__database._fix_incoming(doc, self) for doc in docs] if self.safe or kwargs: safe = True if not kwargs: kwargs.update(self.get_lasterror_options()) self.__database.connection._send_message( message.insert(self.__full_name, docs, check_keys, safe, kwargs, continue_on_error, self.__uuid_subtype), safe) ids = [doc.get("_id", None) for doc in docs] return return_one and ids[0] or ids