diff --git a/Doc/includes/sqlite3/blob.py b/Doc/includes/sqlite3/blob.py
new file mode 100644
index 00000000000000..afd7812a8b3af9
--- /dev/null
+++ b/Doc/includes/sqlite3/blob.py
@@ -0,0 +1,13 @@
+import sqlite3
+
+con = sqlite3.connect(":memory:")
+# creating the table
+con.execute("create table test(id integer primary key, blob_col blob)")
+con.execute("insert into test(blob_col) values (zeroblob(10))")
+# opening blob handle
+blob = con.open_blob("test", "blob_col", 1)
+blob.write(b"Hello")
+blob.write(b"World")
+blob.seek(0)
+print(blob.read()) # will print b"HelloWorld"
+blob.close()
diff --git a/Doc/includes/sqlite3/blob_with.py b/Doc/includes/sqlite3/blob_with.py
new file mode 100644
index 00000000000000..fdca9fbc638ea2
--- /dev/null
+++ b/Doc/includes/sqlite3/blob_with.py
@@ -0,0 +1,12 @@
+import sqlite3
+
+con = sqlite3.connect(":memory:")
+# creating the table
+con.execute("create table test(id integer primary key, blob_col blob)")
+con.execute("insert into test(blob_col) values (zeroblob(10))")
+# opening blob handle
+with con.open_blob("test", "blob_col", 1) as blob:
+ blob.write(b"Hello")
+ blob.write(b"World")
+ blob.seek(0)
+ print(blob.read()) # will print b"HelloWorld"
diff --git a/Doc/library/sqlite3.rst b/Doc/library/sqlite3.rst
index ccb82278bdaa13..827c2e0588611a 100644
--- a/Doc/library/sqlite3.rst
+++ b/Doc/library/sqlite3.rst
@@ -301,6 +301,21 @@ Connection Objects
supplied, this must be a callable returning an instance of :class:`Cursor`
or its subclasses.
+ .. method:: open_blob(table, column, row, *, readonly=False, dbname="main")
+
+ On success a :class:`Blob` handle to the
+ :abbr:`BLOB (Binary Large OBject)` located in row *row*,
+ column *column*, table *table* in database *dbname* will be returned.
+ When *readonly* is :const:`True` the BLOB is opened with read
+ permissions. Otherwise the BLOB has read and write permissions.
+
+ .. note::
+
+ The BLOB size cannot be changed using the :class:`Blob` class. Use
+ ``zeroblob`` to create the blob in the wanted size in advance.
+
+ .. versionadded:: 3.10
+
.. method:: commit()
This method commits the current transaction. If you don't call this method,
@@ -853,6 +868,66 @@ Exceptions
transactions turned off. It is a subclass of :exc:`DatabaseError`.
+.. _sqlite3-blob-objects:
+
+Blob Objects
+------------
+
+.. versionadded:: 3.10
+
+.. class:: Blob
+
+ A :class:`Blob` instance can read and write the data in the
+ :abbr:`BLOB (Binary Large OBject)`. The :class:`Blob` object implement both
+ the file and sequence protocol. For example, you can read data from the
+ :class:`Blob` by doing ``obj.read(5)`` or by doing ``obj[:5]``.
+ You can call ``len(obj)`` to get size of the BLOB.
+
+ .. method:: Blob.close()
+
+ Close the BLOB now (rather than whenever __del__ is called).
+
+ The BLOB will be unusable from this point forward; an
+ :class:`~sqlite3.Error` (or subclass) exception will be
+ raised if any operation is attempted with the BLOB.
+
+ .. method:: Blob.__len__()
+
+ Return the BLOB size.
+
+ .. method:: Blob.read([size])
+
+ Read *size* bytes of data from the BLOB at the current offset position.
+ If the end of the BLOB is reached we will return the data up to end of
+ file. When *size* is not specified or negative we will read up to end
+ of BLOB.
+
+ .. method:: Blob.write(data)
+
+ Write *data* to the BLOB at the current offset. This function cannot
+ changed BLOB length. If data write will result in writing to more
+ then BLOB current size an error will be raised.
+
+ .. method:: Blob.tell()
+
+ Return the current offset of the BLOB.
+
+ .. method:: Blob.seek(offset, whence=os.SEEK_SET)
+
+ Set the BLOB offset. The *whence* argument is optional and defaults to
+ :data:`os.SEEK_SET` or 0 (absolute BLOB positioning); other values
+ are :data:`os.SEEK_CUR` or 1 (seek relative to the current position) and
+ :data:`os.SEEK_END` or 2 (seek relative to the BLOB’s end).
+
+ :class:`Blob` example:
+
+ .. literalinclude:: ../includes/sqlite3/blob.py
+
+ A :class:`Blob` can also be used with :term:`context manager`:
+
+ .. literalinclude:: ../includes/sqlite3/blob_with.py
+
+
.. _sqlite3-types:
SQLite and Python types
diff --git a/Lib/sqlite3/test/dbapi.py b/Lib/sqlite3/test/dbapi.py
index be11337154bdd2..fd88faa7765e02 100644
--- a/Lib/sqlite3/test/dbapi.py
+++ b/Lib/sqlite3/test/dbapi.py
@@ -511,6 +511,177 @@ def CheckLastRowIDInsertOR(self):
self.assertEqual(results, expected)
+class BlobTests(unittest.TestCase):
+ def setUp(self):
+ self.cx = sqlite.connect(":memory:")
+ self.cx.execute("create table test(id integer primary key, blob_col blob)")
+ self.blob_data = b"a" * 100
+ self.cx.execute("insert into test(blob_col) values (?)", (self.blob_data, ))
+ self.blob = self.cx.open_blob("test", "blob_col", 1)
+ self.second_data = b"b" * 100
+
+ def tearDown(self):
+ self.blob.close()
+ self.cx.close()
+
+ def CheckLength(self):
+ self.assertEqual(len(self.blob), 100)
+
+ def CheckTell(self):
+ self.assertEqual(self.blob.tell(), 0)
+
+ def CheckSeekFromBlobStart(self):
+ self.blob.seek(10)
+ self.assertEqual(self.blob.tell(), 10)
+ self.blob.seek(10, 0)
+ self.assertEqual(self.blob.tell(), 10)
+
+ def CheckSeekFromCurrentPosition(self):
+ self.blob.seek(10, 1)
+ self.blob.seek(10, 1)
+ self.assertEqual(self.blob.tell(), 20)
+
+ def CheckSeekFromBlobEnd(self):
+ self.blob.seek(-10, 2)
+ self.assertEqual(self.blob.tell(), 90)
+
+ def CheckBlobSeekOverBlobSize(self):
+ with self.assertRaises(ValueError):
+ self.blob.seek(1000)
+
+ def CheckBlobSeekUnderBlobSize(self):
+ with self.assertRaises(ValueError):
+ self.blob.seek(-10)
+
+ def CheckBlobRead(self):
+ self.assertEqual(self.blob.read(), self.blob_data)
+
+ def CheckBlobReadSize(self):
+ self.assertEqual(len(self.blob.read(10)), 10)
+
+ def CheckBlobReadAdvanceOffset(self):
+ self.blob.read(10)
+ self.assertEqual(self.blob.tell(), 10)
+
+ def CheckBlobReadStartAtOffset(self):
+ self.blob.seek(10)
+ self.blob.write(self.second_data[:10])
+ self.blob.seek(10)
+ self.assertEqual(self.blob.read(10), self.second_data[:10])
+
+ def CheckBlobWrite(self):
+ self.blob.write(self.second_data)
+ self.assertEqual(self.cx.execute("select blob_col from test").fetchone()[0], self.second_data)
+
+ def CheckBlobWriteAtOffset(self):
+ self.blob.seek(50)
+ self.blob.write(self.second_data[:50])
+ self.assertEqual(self.cx.execute("select blob_col from test").fetchone()[0],
+ self.blob_data[:50] + self.second_data[:50])
+
+ def CheckBlobWriteAdvanceOffset(self):
+ self.blob.write(self.second_data[:50])
+ self.assertEqual(self.blob.tell(), 50)
+
+ def CheckBlobWriteMoreThenBlobSize(self):
+ with self.assertRaises(ValueError):
+ self.blob.write(b"a" * 1000)
+
+ def CheckBlobReadAfterRowChange(self):
+ self.cx.execute("UPDATE test SET blob_col='aaaa' where id=1")
+ with self.assertRaises(sqlite.OperationalError):
+ self.blob.read()
+
+ def CheckBlobWriteAfterRowChange(self):
+ self.cx.execute("UPDATE test SET blob_col='aaaa' where id=1")
+ with self.assertRaises(sqlite.OperationalError):
+ self.blob.write(b"aaa")
+
+ def CheckBlobWriteWhenReadOnly(self):
+ read_only_blob = \
+ self.cx.open_blob("test", "blob_col", 1, readonly=True)
+ with self.assertRaises(sqlite.OperationalError):
+ read_only_blob.write(b"aaa")
+ read_only_blob.close()
+
+ def CheckBlobOpenWithBadDb(self):
+ with self.assertRaises(sqlite.OperationalError):
+ self.cx.open_blob("test", "blob_col", 1, dbname="notexisintg")
+
+ def CheckBlobOpenWithBadTable(self):
+ with self.assertRaises(sqlite.OperationalError):
+ self.cx.open_blob("notexisintg", "blob_col", 1)
+
+ def CheckBlobOpenWithBadColumn(self):
+ with self.assertRaises(sqlite.OperationalError):
+ self.cx.open_blob("test", "notexisting", 1)
+
+ def CheckBlobOpenWithBadRow(self):
+ with self.assertRaises(sqlite.OperationalError):
+ self.cx.open_blob("test", "blob_col", 2)
+
+ def CheckBlobGetItem(self):
+ self.assertEqual(self.blob[5], b"a")
+
+ def CheckBlobGetItemIndexOutOfRange(self):
+ with self.assertRaises(IndexError):
+ self.blob[105]
+ with self.assertRaises(IndexError):
+ self.blob[-105]
+
+ def CheckBlobGetItemNegativeIndex(self):
+ self.assertEqual(self.blob[-5], b"a")
+
+ def CheckBlobGetItemInvalidIndex(self):
+ with self.assertRaises(TypeError):
+ self.blob[b"a"]
+
+ def CheckBlobGetSlice(self):
+ self.assertEqual(self.blob[5:10], b"aaaaa")
+
+ def CheckBlobGetSliceNegativeIndex(self):
+ self.assertEqual(self.blob[5:-5], self.blob_data[5:-5])
+
+ def CheckBlobGetSliceInvalidIndex(self):
+ with self.assertRaises(TypeError):
+ self.blob[5:b"a"]
+
+ def CheckBlobGetSliceWithSkip(self):
+ self.blob.write(b"abcdefghij")
+ self.assertEqual(self.blob[0:10:2], b"acegi")
+
+ def CheckBlobSetItem(self):
+ self.blob[0] = b"b"
+ self.assertEqual(self.cx.execute("select blob_col from test").fetchone()[0], b"b" + self.blob_data[1:])
+
+ def CheckBlobSetSlice(self):
+ self.blob[0:5] = b"bbbbb"
+ self.assertEqual(self.cx.execute("select blob_col from test").fetchone()[0], b"bbbbb" + self.blob_data[5:])
+
+ def CheckBlobSetSliceWithSkip(self):
+ self.blob[0:10:2] = b"bbbbb"
+ self.assertEqual(self.cx.execute("select blob_col from test").fetchone()[0], b"bababababa" + self.blob_data[10:])
+
+ def CheckBlobGetEmptySlice(self):
+ self.assertEqual(self.blob[5:5], b"")
+
+ def CheckBlobSetSliceWrongLength(self):
+ with self.assertRaises(IndexError):
+ self.blob[5:10] = b"a"
+
+ def CheckBlobConcatNotSupported(self):
+ with self.assertRaises(SystemError):
+ self.blob + self.blob
+
+ def CheckBlobRepeateNotSupported(self):
+ with self.assertRaises(SystemError):
+ self.blob * 5
+
+ def CheckBlobContainsNotSupported(self):
+ with self.assertRaises(SystemError):
+ b"aaaaa" in self.blob
+
+@unittest.skipUnless(threading, 'This test requires threading.')
class ThreadTests(unittest.TestCase):
def setUp(self):
self.con = sqlite.connect(":memory:")
@@ -768,6 +939,15 @@ def CheckClosedCurExecute(self):
with self.assertRaises(sqlite.ProgrammingError):
cur.execute("select 4")
+ def CheckClosedBlobRead(self):
+ con = sqlite.connect(":memory:")
+ con.execute("create table test(id integer primary key, blob_col blob)")
+ con.execute("insert into test(blob_col) values (zeroblob(100))")
+ blob = con.open_blob("test", "blob_col", 1)
+ con.close()
+ with self.assertRaises(sqlite.ProgrammingError):
+ blob.read()
+
def CheckClosedCreateFunction(self):
con = sqlite.connect(":memory:")
con.close()
@@ -921,6 +1101,69 @@ def CheckOnConflictReplace(self):
self.assertEqual(self.cu.fetchall(), [('Very different data!', 'foo')])
+
+class ClosedBlobTests(unittest.TestCase):
+ def setUp(self):
+ self.cx = sqlite.connect(":memory:")
+ self.cx.execute("create table test(id integer primary key, blob_col blob)")
+ self.cx.execute("insert into test(blob_col) values (zeroblob(100))")
+
+ def tearDown(self):
+ self.cx.close()
+
+ def CheckClosedRead(self):
+ self.blob = self.cx.open_blob("test", "blob_col", 1)
+ self.blob.close()
+ with self.assertRaises(sqlite.ProgrammingError):
+ self.blob.read()
+
+ def CheckClosedWrite(self):
+ self.blob = self.cx.open_blob("test", "blob_col", 1)
+ self.blob.close()
+ with self.assertRaises(sqlite.ProgrammingError):
+ self.blob.write(b"aaaaaaaaa")
+
+ def CheckClosedSeek(self):
+ self.blob = self.cx.open_blob("test", "blob_col", 1)
+ self.blob.close()
+ with self.assertRaises(sqlite.ProgrammingError):
+ self.blob.seek(10)
+
+ def CheckClosedTell(self):
+ self.blob = self.cx.open_blob("test", "blob_col", 1)
+ self.blob.close()
+ with self.assertRaises(sqlite.ProgrammingError):
+ self.blob.tell()
+
+ def CheckClosedClose(self):
+ self.blob = self.cx.open_blob("test", "blob_col", 1)
+ self.blob.close()
+ with self.assertRaises(sqlite.ProgrammingError):
+ self.blob.close()
+
+
+class BlobContextManagerTests(unittest.TestCase):
+ def setUp(self):
+ self.cx = sqlite.connect(":memory:")
+ self.cx.execute("create table test(id integer primary key, blob_col blob)")
+ self.cx.execute("insert into test(blob_col) values (zeroblob(100))")
+
+ def tearDown(self):
+ self.cx.close()
+
+ def CheckContextExecute(self):
+ data = b"a" * 100
+ with self.cx.open_blob("test", "blob_col", 1) as blob:
+ blob.write(data)
+ self.assertEqual(self.cx.execute("select blob_col from test").fetchone()[0], data)
+
+ def CheckContextCloseBlob(self):
+ with self.cx.open_blob("test", "blob_col", 1) as blob:
+ blob.seek(10)
+ with self.assertRaises(sqlite.ProgrammingError):
+ blob.close()
+
+
def suite():
module_suite = unittest.makeSuite(ModuleTests, "Check")
connection_suite = unittest.makeSuite(ConnectionTests, "Check")
@@ -931,11 +1174,14 @@ def suite():
closed_con_suite = unittest.makeSuite(ClosedConTests, "Check")
closed_cur_suite = unittest.makeSuite(ClosedCurTests, "Check")
on_conflict_suite = unittest.makeSuite(SqliteOnConflictTests, "Check")
+ blob_suite = unittest.makeSuite(BlobTests, "Check")
+ closed_blob_suite = unittest.makeSuite(ClosedBlobTests, "Check")
+ blob_context_manager_suite = unittest.makeSuite(BlobContextManagerTests, "Check")
return unittest.TestSuite((
- module_suite, connection_suite, cursor_suite, thread_suite,
- constructor_suite, ext_suite, closed_con_suite, closed_cur_suite,
- on_conflict_suite,
- ))
+ module_suite, connection_suite, cursor_suite, thread_suite, constructor_suite,
+ ext_suite, closed_con_suite, closed_cur_suite, on_conflict_suite,
+ blob_suite, closed_blob_suite, blob_context_manager_suite,
+ ))
def test():
runner = unittest.TextTestRunner()
diff --git a/Misc/NEWS.d/next/Library/2018-04-18-16-15-55.bpo-24905.jYqjYx.rst b/Misc/NEWS.d/next/Library/2018-04-18-16-15-55.bpo-24905.jYqjYx.rst
new file mode 100644
index 00000000000000..c7d2405d89539e
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2018-04-18-16-15-55.bpo-24905.jYqjYx.rst
@@ -0,0 +1,4 @@
+The :class:`sqlite3.Connection` now has the
+:meth:`sqlite3.Connection.open_blob` method. The :class:`sqlite3.Blob`
+allows incremental I/O operations to blobs. (Patch by Aviv Palivoda in
+:issue:`24905`)
diff --git a/Modules/_sqlite/blob.c b/Modules/_sqlite/blob.c
new file mode 100644
index 00000000000000..49e664631e2774
--- /dev/null
+++ b/Modules/_sqlite/blob.c
@@ -0,0 +1,652 @@
+#include "blob.h"
+#include "util.h"
+
+
+int pysqlite_blob_init(pysqlite_Blob *self, pysqlite_Connection* connection,
+ sqlite3_blob *blob)
+{
+ Py_INCREF(connection);
+ self->connection = connection;
+ self->offset = 0;
+ self->blob = blob;
+ self->in_weakreflist = NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ self->length = sqlite3_blob_bytes(self->blob);
+ Py_END_ALLOW_THREADS
+
+ if (!pysqlite_check_thread(self->connection)) {
+ return -1;
+ }
+ return 0;
+}
+
+static void remove_blob_from_connection_blob_list(pysqlite_Blob *self)
+{
+ Py_ssize_t i;
+ PyObject *item;
+
+ for (i = 0; i < PyList_GET_SIZE(self->connection->blobs); i++) {
+ item = PyList_GET_ITEM(self->connection->blobs, i);
+ if (PyWeakref_GetObject(item) == (PyObject *)self) {
+ PyList_SetSlice(self->connection->blobs, i, i+1, NULL);
+ break;
+ }
+ }
+}
+
+static void _close_blob_inner(pysqlite_Blob* self)
+{
+ sqlite3_blob *blob;
+
+ /* close the blob */
+ blob = self->blob;
+ self->blob = NULL;
+ if (blob) {
+ Py_BEGIN_ALLOW_THREADS
+ sqlite3_blob_close(blob);
+ Py_END_ALLOW_THREADS
+ }
+
+ /* remove from connection weaklist */
+ remove_blob_from_connection_blob_list(self);
+ if (self->in_weakreflist != NULL) {
+ PyObject_ClearWeakRefs((PyObject*)self);
+ }
+}
+
+static void pysqlite_blob_dealloc(pysqlite_Blob* self)
+{
+ _close_blob_inner(self);
+ Py_XDECREF(self->connection);
+ Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+/*
+ * Checks if a blob object is usable (i. e. not closed).
+ *
+ * 0 => error; 1 => ok
+ */
+int pysqlite_check_blob(pysqlite_Blob *blob)
+{
+
+ if (!blob->blob) {
+ PyErr_SetString(pysqlite_ProgrammingError,
+ "Cannot operate on a closed blob.");
+ return 0;
+ } else if (!pysqlite_check_connection(blob->connection) ||
+ !pysqlite_check_thread(blob->connection)) {
+ return 0;
+ } else {
+ return 1;
+ }
+}
+
+
+PyObject* pysqlite_blob_close(pysqlite_Blob *self)
+{
+
+ if (!pysqlite_check_blob(self)) {
+ return NULL;
+ }
+
+ _close_blob_inner(self);
+ Py_RETURN_NONE;
+};
+
+
+static Py_ssize_t pysqlite_blob_length(pysqlite_Blob *self)
+{
+ if (!pysqlite_check_blob(self)) {
+ return -1;
+ }
+
+ return self->length;
+};
+
+static PyObject* inner_read(pysqlite_Blob *self, int read_length, int offset)
+{
+ PyObject *buffer;
+ char *raw_buffer;
+ int rc;
+
+ buffer = PyBytes_FromStringAndSize(NULL, read_length);
+ if (!buffer) {
+ return NULL;
+ }
+ raw_buffer = PyBytes_AS_STRING(buffer);
+
+ Py_BEGIN_ALLOW_THREADS
+ rc = sqlite3_blob_read(self->blob, raw_buffer, read_length, self->offset);
+ Py_END_ALLOW_THREADS
+
+ if (rc != SQLITE_OK){
+ Py_DECREF(buffer);
+ /* For some reason after modifying blob the
+ error is not set on the connection db. */
+ if (rc == SQLITE_ABORT) {
+ PyErr_SetString(pysqlite_OperationalError,
+ "Cannot operate on modified blob");
+ } else {
+ _pysqlite_seterror(self->connection->db, NULL);
+ }
+ return NULL;
+ }
+ return buffer;
+}
+
+
+PyObject* pysqlite_blob_read(pysqlite_Blob *self, PyObject *args)
+{
+ int read_length = -1;
+ PyObject *buffer;
+
+ if (!PyArg_ParseTuple(args, "|i", &read_length)) {
+ return NULL;
+ }
+
+ if (!pysqlite_check_blob(self)) {
+ return NULL;
+ }
+
+ if (read_length < 0) {
+ /* same as file read. */
+ read_length = self->length;
+ }
+
+ /* making sure we don't read more then blob size */
+ if (read_length > self->length - self->offset) {
+ read_length = self->length - self->offset;
+ }
+
+ buffer = inner_read(self, read_length, self->offset);
+
+ if (buffer != NULL) {
+ /* update offset on sucess. */
+ self->offset += read_length;
+ }
+
+ return buffer;
+};
+
+static int write_inner(pysqlite_Blob *self, const void *buf, Py_ssize_t len, int offset)
+{
+ int rc;
+
+ Py_BEGIN_ALLOW_THREADS
+ rc = sqlite3_blob_write(self->blob, buf, len, offset);
+ Py_END_ALLOW_THREADS
+ if (rc != SQLITE_OK) {
+ /* For some reason after modifying blob the
+ error is not set on the connection db. */
+ if (rc == SQLITE_ABORT) {
+ PyErr_SetString(pysqlite_OperationalError,
+ "Cannot operate on modified blob");
+ } else {
+ _pysqlite_seterror(self->connection->db, NULL);
+ }
+ return -1;
+ }
+ return 0;
+}
+
+
+PyObject* pysqlite_blob_write(pysqlite_Blob *self, PyObject *data)
+{
+ Py_buffer data_buffer;
+ int rc;
+
+ if (PyObject_GetBuffer(data, &data_buffer, PyBUF_SIMPLE) < 0) {
+ return NULL;
+ }
+
+ if (data_buffer.len > INT_MAX) {
+ PyErr_SetString(PyExc_OverflowError,
+ "data longer than INT_MAX bytes");
+ PyBuffer_Release(&data_buffer);
+ return NULL;
+ }
+
+ if (data_buffer.len > self->length - self->offset) {
+ PyErr_SetString(PyExc_ValueError,
+ "data longer than blob length");
+ PyBuffer_Release(&data_buffer);
+ return NULL;
+ }
+
+ if (!pysqlite_check_blob(self)) {
+ PyBuffer_Release(&data_buffer);
+ return NULL;
+ }
+
+ rc = write_inner(self, data_buffer.buf, data_buffer.len, self->offset);
+
+ if (rc == 0) {
+ self->offset += (int)data_buffer.len;
+ PyBuffer_Release(&data_buffer);
+ Py_RETURN_NONE;
+ } else {
+ PyBuffer_Release(&data_buffer);
+ return NULL;
+ }
+}
+
+
+PyObject* pysqlite_blob_seek(pysqlite_Blob *self, PyObject *args)
+{
+ int offset, from_what = 0;
+
+ if (!PyArg_ParseTuple(args, "i|i", &offset, &from_what)) {
+ return NULL;
+ }
+
+
+ if (!pysqlite_check_blob(self)) {
+ return NULL;
+ }
+
+ switch (from_what) {
+ case 0: // relative to blob begin
+ break;
+ case 1: // relative to current position
+ if (offset > INT_MAX - self->offset) {
+ goto overflow;
+ }
+ offset = self->offset + offset;
+ break;
+ case 2: // relative to blob end
+ if (offset > INT_MAX - self->length) {
+ goto overflow;
+ }
+ offset = self->length + offset;
+ break;
+ default:
+ PyErr_SetString(PyExc_ValueError,
+ "from_what should be 0, 1 or 2");
+ return NULL;
+ }
+
+ if (offset < 0 || offset > self->length) {
+ PyErr_SetString(PyExc_ValueError, "offset out of blob range");
+ return NULL;
+ }
+
+ self->offset = offset;
+ Py_RETURN_NONE;
+
+overflow:
+ PyErr_SetString(PyExc_OverflowError, "seek offset result in overflow");
+ return NULL;
+}
+
+
+PyObject* pysqlite_blob_tell(pysqlite_Blob *self)
+{
+ if (!pysqlite_check_blob(self)) {
+ return NULL;
+ }
+
+ return PyLong_FromLong(self->offset);
+}
+
+
+PyObject* pysqlite_blob_enter(pysqlite_Blob *self)
+{
+ if (!pysqlite_check_blob(self)) {
+ return NULL;
+ }
+
+ Py_INCREF(self);
+ return (PyObject *)self;
+}
+
+
+PyObject* pysqlite_blob_exit(pysqlite_Blob *self, PyObject *args)
+{
+ PyObject *res;
+ if (!pysqlite_check_blob(self)) {
+ return NULL;
+ }
+
+ res = pysqlite_blob_close(self);
+ if (!res) {
+ return NULL;
+ }
+ Py_XDECREF(res);
+
+ Py_RETURN_FALSE;
+}
+
+static PyObject* pysqlite_blob_concat(pysqlite_Blob *self, PyObject *args)
+{
+ if (pysqlite_check_blob(self)) {
+ PyErr_SetString(PyExc_SystemError,
+ "Blob don't support concatenation");
+ }
+ return NULL;
+}
+
+static PyObject* pysqlite_blob_repeat(pysqlite_Blob *self, PyObject *args)
+{
+ if (pysqlite_check_blob(self)) {
+ PyErr_SetString(PyExc_SystemError,
+ "Blob don't support repeat operation");
+ }
+ return NULL;
+}
+
+static int pysqlite_blob_contains(pysqlite_Blob *self, PyObject *args)
+{
+ if (pysqlite_check_blob(self)) {
+ PyErr_SetString(PyExc_SystemError,
+ "Blob don't support contains operation");
+ }
+ return -1;
+}
+
+static PyObject* pysqlite_blob_item(pysqlite_Blob *self, Py_ssize_t i)
+{
+ if (!pysqlite_check_blob(self)) {
+ return NULL;
+ }
+
+ if (i < 0 || i >= self->length) {
+ PyErr_SetString(PyExc_IndexError, "Blob index out of range");
+ return NULL;
+ }
+
+ return inner_read(self, 1, i);
+}
+
+static int pysqlite_blob_ass_item(pysqlite_Blob *self, Py_ssize_t i, PyObject *v)
+{
+ const char *buf;
+
+ if (!pysqlite_check_blob(self)) {
+ return -1;
+ }
+
+ if (i < 0 || i >= self->length) {
+ PyErr_SetString(PyExc_IndexError, "Blob index out of range");
+ return -1;
+ }
+ if (v == NULL) {
+ PyErr_SetString(PyExc_TypeError,
+ "Blob object doesn't support item deletion");
+ return -1;
+ }
+ if (! (PyBytes_Check(v) && PyBytes_Size(v)==1) ) {
+ PyErr_SetString(PyExc_IndexError,
+ "Blob assignment must be length-1 bytes()");
+ return -1;
+ }
+
+ buf = PyBytes_AsString(v);
+ return write_inner(self, buf, 1, i);
+}
+
+
+static PyObject * pysqlite_blob_subscript(pysqlite_Blob *self, PyObject *item)
+{
+ if (!pysqlite_check_blob(self)) {
+ return NULL;
+ }
+
+ if (PyIndex_Check(item)) {
+ Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
+ if (i == -1 && PyErr_Occurred())
+ return NULL;
+ if (i < 0)
+ i += self->length;
+ if (i < 0 || i >= self->length) {
+ PyErr_SetString(PyExc_IndexError,
+ "Blob index out of range");
+ return NULL;
+ }
+ // TODO: I am not sure...
+ return inner_read(self, 1, i);
+ }
+ else if (PySlice_Check(item)) {
+ Py_ssize_t start, stop, step, slicelen;
+
+ if (PySlice_GetIndicesEx(item, self->length,
+ &start, &stop, &step, &slicelen) < 0) {
+ return NULL;
+ }
+
+ if (slicelen <= 0) {
+ return PyBytes_FromStringAndSize("", 0);
+ } else if (step == 1) {
+ return inner_read(self, slicelen, start);
+ } else {
+ char *result_buf = (char *)PyMem_Malloc(slicelen);
+ char *data_buff = NULL;
+ Py_ssize_t cur, i;
+ PyObject *result;
+ int rc;
+
+ if (result_buf == NULL)
+ return PyErr_NoMemory();
+
+ data_buff = (char *)PyMem_Malloc(stop - start);
+ if (data_buff == NULL) {
+ PyMem_Free(result_buf);
+ return PyErr_NoMemory();
+ }
+
+ Py_BEGIN_ALLOW_THREADS
+ rc = sqlite3_blob_read(self->blob, data_buff, stop - start, start);
+ Py_END_ALLOW_THREADS
+
+ if (rc != SQLITE_OK){
+ /* For some reason after modifying blob the
+ error is not set on the connection db. */
+ if (rc == SQLITE_ABORT) {
+ PyErr_SetString(pysqlite_OperationalError,
+ "Cannot operate on modified blob");
+ } else {
+ _pysqlite_seterror(self->connection->db, NULL);
+ }
+ PyMem_Free(result_buf);
+ PyMem_Free(data_buff);
+ return NULL;
+ }
+
+ for (cur = 0, i = 0; i < slicelen;
+ cur += step, i++) {
+ result_buf[i] = data_buff[cur];
+ }
+ result = PyBytes_FromStringAndSize(result_buf,
+ slicelen);
+ PyMem_Free(result_buf);
+ PyMem_Free(data_buff);
+ return result;
+ }
+ }
+ else {
+ PyErr_SetString(PyExc_TypeError,
+ "Blob indices must be integers");
+ return NULL;
+ }
+}
+
+
+static int pysqlite_blob_ass_subscript(pysqlite_Blob *self, PyObject *item, PyObject *value)
+{
+ int rc;
+
+ if (!pysqlite_check_blob(self)) {
+ return -1;
+ }
+
+ if (PyIndex_Check(item)) {
+ Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
+ const char *buf;
+
+ if (i == -1 && PyErr_Occurred())
+ return -1;
+ if (i < 0)
+ i += self->length;
+ if (i < 0 || i >= self->length) {
+ PyErr_SetString(PyExc_IndexError,
+ "Blob index out of range");
+ return -1;
+ }
+ if (value == NULL) {
+ PyErr_SetString(PyExc_TypeError,
+ "Blob doesn't support item deletion");
+ return -1;
+ }
+ if (! (PyBytes_Check(value) && PyBytes_Size(value)==1) ) {
+ PyErr_SetString(PyExc_IndexError,
+ "Blob assignment must be length-1 bytes()");
+ return -1;
+ }
+
+ buf = PyBytes_AsString(value);
+ return write_inner(self, buf, 1, i);
+ }
+ else if (PySlice_Check(item)) {
+ Py_ssize_t start, stop, step, slicelen;
+ Py_buffer vbuf;
+
+ if (PySlice_GetIndicesEx(item,
+ self->length, &start, &stop,
+ &step, &slicelen) < 0) {
+ return -1;
+ }
+ if (value == NULL) {
+ PyErr_SetString(PyExc_TypeError,
+ "Blob object doesn't support slice deletion");
+ return -1;
+ }
+ if (PyObject_GetBuffer(value, &vbuf, PyBUF_SIMPLE) < 0)
+ return -1;
+ if (vbuf.len != slicelen) {
+ PyErr_SetString(PyExc_IndexError,
+ "Blob slice assignment is wrong size");
+ PyBuffer_Release(&vbuf);
+ return -1;
+ }
+
+ if (slicelen == 0) {
+ }
+ else if (step == 1) {
+ rc = write_inner(self, vbuf.buf, slicelen, start);
+ }
+ else {
+ Py_ssize_t cur, i;
+ char *data_buff;
+
+
+ data_buff = (char *)PyMem_Malloc(stop - start);
+ if (data_buff == NULL) {
+ PyErr_NoMemory();
+ return -1;
+ }
+
+ Py_BEGIN_ALLOW_THREADS
+ rc = sqlite3_blob_read(self->blob, data_buff, stop - start, start);
+ Py_END_ALLOW_THREADS
+
+ if (rc != SQLITE_OK){
+ /* For some reason after modifying blob the
+ error is not set on the connection db. */
+ if (rc == SQLITE_ABORT) {
+ PyErr_SetString(pysqlite_OperationalError,
+ "Cannot operate on modified blob");
+ } else {
+ _pysqlite_seterror(self->connection->db, NULL);
+ }
+ PyMem_Free(data_buff);
+ rc = -1;
+ }
+
+ for (cur = 0, i = 0;
+ i < slicelen;
+ cur += step, i++)
+ {
+ data_buff[cur] = ((char *)vbuf.buf)[i];
+ }
+
+ Py_BEGIN_ALLOW_THREADS
+ rc = sqlite3_blob_write(self->blob, data_buff, stop - start, start);
+ Py_END_ALLOW_THREADS
+
+ if (rc != SQLITE_OK){
+ /* For some reason after modifying blob the
+ error is not set on the connection db. */
+ if (rc == SQLITE_ABORT) {
+ PyErr_SetString(pysqlite_OperationalError,
+ "Cannot operate on modified blob");
+ } else {
+ _pysqlite_seterror(self->connection->db, NULL);
+ }
+ PyMem_Free(data_buff);
+ rc = -1;
+ }
+ rc = 0;
+
+ }
+ PyBuffer_Release(&vbuf);
+ return rc;
+ }
+ else {
+ PyErr_SetString(PyExc_TypeError,
+ "Blob indices must be integer");
+ return -1;
+ }
+}
+
+
+static PyMethodDef blob_methods[] = {
+ {"read", (PyCFunction)pysqlite_blob_read, METH_VARARGS,
+ PyDoc_STR("read data from blob")},
+ {"write", (PyCFunction)pysqlite_blob_write, METH_O,
+ PyDoc_STR("write data to blob")},
+ {"close", (PyCFunction)pysqlite_blob_close, METH_NOARGS,
+ PyDoc_STR("close blob")},
+ {"seek", (PyCFunction)pysqlite_blob_seek, METH_VARARGS,
+ PyDoc_STR("change blob current offset")},
+ {"tell", (PyCFunction)pysqlite_blob_tell, METH_NOARGS,
+ PyDoc_STR("return blob current offset")},
+ {"__enter__", (PyCFunction)pysqlite_blob_enter, METH_NOARGS,
+ PyDoc_STR("blob context manager enter")},
+ {"__exit__", (PyCFunction)pysqlite_blob_exit, METH_VARARGS,
+ PyDoc_STR("blob context manager exit")},
+ {NULL, NULL}
+};
+
+static PySequenceMethods blob_sequence_methods = {
+ .sq_length = (lenfunc)pysqlite_blob_length,
+ .sq_concat = (binaryfunc)pysqlite_blob_concat,
+ .sq_repeat = (ssizeargfunc)pysqlite_blob_repeat,
+ .sq_item = (ssizeargfunc)pysqlite_blob_item,
+ .sq_ass_item = (ssizeobjargproc)pysqlite_blob_ass_item,
+ .sq_contains = (objobjproc)pysqlite_blob_contains,
+};
+
+static PyMappingMethods blob_mapping_methods = {
+ (lenfunc)pysqlite_blob_length,
+ (binaryfunc)pysqlite_blob_subscript,
+ (objobjargproc)pysqlite_blob_ass_subscript,
+};
+
+PyTypeObject pysqlite_BlobType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ MODULE_NAME ".Blob",
+ .tp_basicsize = sizeof(pysqlite_Blob),
+ .tp_dealloc = (destructor)pysqlite_blob_dealloc,
+ .tp_as_sequence = &blob_sequence_methods,
+ .tp_as_mapping = &blob_mapping_methods,
+ .tp_flags = Py_TPFLAGS_DEFAULT,
+ .tp_weaklistoffset = offsetof(pysqlite_Blob, in_weakreflist),
+ .tp_methods = blob_methods,
+};
+
+extern int pysqlite_blob_setup_types(void)
+{
+ pysqlite_BlobType.tp_new = PyType_GenericNew;
+ return PyType_Ready(&pysqlite_BlobType);
+}
diff --git a/Modules/_sqlite/blob.h b/Modules/_sqlite/blob.h
new file mode 100644
index 00000000000000..649f09e5ecca24
--- /dev/null
+++ b/Modules/_sqlite/blob.h
@@ -0,0 +1,26 @@
+#ifndef PYSQLITE_BLOB_H
+#define PYSQLITE_BLOB_H
+#include "Python.h"
+#include "sqlite3.h"
+#include "connection.h"
+
+typedef struct
+{
+ PyObject_HEAD
+ pysqlite_Connection* connection;
+ sqlite3_blob *blob;
+ int offset;
+ int length;
+
+ PyObject* in_weakreflist; /* List of weak references */
+} pysqlite_Blob;
+
+extern PyTypeObject pysqlite_BlobType;
+
+int pysqlite_blob_init(pysqlite_Blob* self, pysqlite_Connection* connection,
+ sqlite3_blob *blob);
+PyObject* pysqlite_blob_close(pysqlite_Blob *self);
+
+int pysqlite_blob_setup_types(void);
+
+#endif
diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c
index 958be7d869794a..1d64bae7ca98f6 100644
--- a/Modules/_sqlite/connection.c
+++ b/Modules/_sqlite/connection.c
@@ -27,6 +27,7 @@
#include "connection.h"
#include "statement.h"
#include "cursor.h"
+#include "blob.h"
#include "prepare_protocol.h"
#include "util.h"
@@ -105,7 +106,8 @@ int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject
Py_CLEAR(self->statement_cache);
Py_CLEAR(self->statements);
Py_CLEAR(self->cursors);
-
+ Py_CLEAR(self->blobs);
+
Py_INCREF(Py_None);
Py_XSETREF(self->row_factory, Py_None);
@@ -159,10 +161,11 @@ int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject
self->created_statements = 0;
self->created_cursors = 0;
- /* Create lists of weak references to statements/cursors */
+ /* Create lists of weak references to statements/cursors/blobs */
self->statements = PyList_New(0);
self->cursors = PyList_New(0);
- if (!self->statements || !self->cursors) {
+ self->blobs = PyList_New(0);
+ if (!self->statements || !self->cursors || !self->blobs) {
return -1;
}
@@ -258,6 +261,8 @@ void pysqlite_connection_dealloc(pysqlite_Connection* self)
Py_XDECREF(self->collations);
Py_XDECREF(self->statements);
Py_XDECREF(self->cursors);
+ Py_XDECREF(self->blobs);
+
Py_TYPE(self)->tp_free((PyObject*)self);
}
@@ -327,6 +332,84 @@ PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args,
return cursor;
}
+PyObject* pysqlite_connection_blob(pysqlite_Connection *self, PyObject *args,
+ PyObject *kwargs)
+{
+ static char *kwlist[] = {"table", "column", "row", "readonly",
+ "dbname", NULL};
+ int rc;
+ const char *dbname = "main", *table, *column;
+ long long row;
+ int readonly = 0;
+ sqlite3_blob *blob;
+ pysqlite_Blob *pyblob = NULL;
+ PyObject *weakref;
+
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ssL|$ps", kwlist,
+ &table, &column, &row, &readonly,
+ &dbname)) {
+ return NULL;
+ }
+
+ Py_BEGIN_ALLOW_THREADS
+ rc = sqlite3_blob_open(self->db, dbname, table, column, row,
+ !readonly, &blob);
+ Py_END_ALLOW_THREADS
+
+ if (rc != SQLITE_OK) {
+ _pysqlite_seterror(self->db, NULL);
+ return NULL;
+ }
+
+ pyblob = PyObject_New(pysqlite_Blob, &pysqlite_BlobType);
+ if (!pyblob) {
+ goto error;
+ }
+
+ rc = pysqlite_blob_init(pyblob, self, blob);
+ if (rc) {
+ Py_CLEAR(pyblob);
+ goto error;
+ }
+
+ // Add our blob to connection blobs list
+ weakref = PyWeakref_NewRef((PyObject*)pyblob, NULL);
+ if (!weakref) {
+ Py_CLEAR(pyblob);
+ goto error;
+ }
+ if (PyList_Append(self->blobs, weakref) != 0) {
+ Py_CLEAR(weakref);
+ Py_CLEAR(pyblob);
+ goto error;
+ }
+ Py_DECREF(weakref);
+
+ return (PyObject*)pyblob;
+
+error:
+ Py_BEGIN_ALLOW_THREADS
+ sqlite3_blob_close(blob);
+ Py_END_ALLOW_THREADS
+ return NULL;
+}
+
+static void pysqlite_close_all_blobs(pysqlite_Connection *self)
+{
+ int i;
+ PyObject *weakref;
+ PyObject *blob;
+
+ for (i = 0; i < PyList_GET_SIZE(self->blobs); i++) {
+ weakref = PyList_GET_ITEM(self->blobs, i);
+ blob = PyWeakref_GetObject(weakref);
+ if (blob != Py_None) {
+ pysqlite_blob_close((pysqlite_Blob*)blob);
+ }
+ }
+}
+
PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args)
{
int rc;
@@ -337,6 +420,8 @@ PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args)
pysqlite_do_all_statements(self, ACTION_FINALIZE, 1);
+ pysqlite_close_all_blobs(self);
+
if (self->db) {
rc = SQLITE3_CLOSE(self->db);
@@ -1768,6 +1853,8 @@ static PyGetSetDef connection_getset[] = {
static PyMethodDef connection_methods[] = {
{"cursor", (PyCFunction)(void(*)(void))pysqlite_connection_cursor, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("Return a cursor for the connection.")},
+ {"open_blob", (PyCFunction)pysqlite_connection_blob, METH_VARARGS|METH_KEYWORDS,
+ PyDoc_STR("return a blob object")},
{"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS,
PyDoc_STR("Closes the connection.")},
{"commit", (PyCFunction)pysqlite_connection_commit, METH_NOARGS,
diff --git a/Modules/_sqlite/connection.h b/Modules/_sqlite/connection.h
index 206085e00a00c7..52dc27c8adff2d 100644
--- a/Modules/_sqlite/connection.h
+++ b/Modules/_sqlite/connection.h
@@ -66,9 +66,10 @@ typedef struct
pysqlite_Cache* statement_cache;
- /* Lists of weak references to statements and cursors used within this connection */
+ /* Lists of weak references to statements, cursors and blobs used within this connection */
PyObject* statements;
PyObject* cursors;
+ PyObject* blobs;
/* Counters for how many statements/cursors were created in the connection. May be
* reset to 0 at certain intervals */
diff --git a/Modules/_sqlite/module.c b/Modules/_sqlite/module.c
index 71d951ee887e47..f138e02357753f 100644
--- a/Modules/_sqlite/module.c
+++ b/Modules/_sqlite/module.c
@@ -28,6 +28,7 @@
#include "prepare_protocol.h"
#include "microprotocols.h"
#include "row.h"
+#include "blob.h"
#if SQLITE_VERSION_NUMBER >= 3003003
#define HAVE_SHARED_CACHE
@@ -368,7 +369,8 @@ PyMODINIT_FUNC PyInit__sqlite3(void)
(pysqlite_connection_setup_types() < 0) ||
(pysqlite_cache_setup_types() < 0) ||
(pysqlite_statement_setup_types() < 0) ||
- (pysqlite_prepare_protocol_setup_types() < 0)
+ (pysqlite_prepare_protocol_setup_types() < 0) ||
+ (pysqlite_blob_setup_types() < 0)
) {
Py_XDECREF(module);
return NULL;
diff --git a/PCbuild/_sqlite3.vcxproj b/PCbuild/_sqlite3.vcxproj
index 7e0062692b8f83..55f46c963b1e7d 100644
--- a/PCbuild/_sqlite3.vcxproj
+++ b/PCbuild/_sqlite3.vcxproj
@@ -107,6 +107,7 @@
+
@@ -118,6 +119,7 @@
+
diff --git a/PCbuild/_sqlite3.vcxproj.filters b/PCbuild/_sqlite3.vcxproj.filters
index 51830f6a4451a4..8d26c9ab6eb43f 100644
--- a/PCbuild/_sqlite3.vcxproj.filters
+++ b/PCbuild/_sqlite3.vcxproj.filters
@@ -39,6 +39,9 @@
Header Files
+
+ Header Files
+
@@ -68,6 +71,9 @@
Source Files
+
+ Source Files
+
diff --git a/setup.py b/setup.py
index 21a5a58981fc15..dd6b3509247fd8 100644
--- a/setup.py
+++ b/setup.py
@@ -1523,7 +1523,9 @@ def detect_sqlite(self):
'_sqlite/prepare_protocol.c',
'_sqlite/row.c',
'_sqlite/statement.c',
- '_sqlite/util.c', ]
+ '_sqlite/util.c',
+ '_sqlite/blob.c',
+ ]
sqlite_defines = []
if not MS_WINDOWS: