LCOV - code coverage report
Current view: | top level - Modules/_sqlite - blob.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 6 | 259 | 2.3 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 1 | 27 | 3.7 %
|  |  | Branches: | 1 | 142 | 0.7 %

               Branch data     Line data    Source code
           1                 :            : #include "blob.h"
           2                 :            : #include "util.h"
           3                 :            :
           4                 :            : #define clinic_state() (pysqlite_get_state_by_type(Py_TYPE(self)))
           5                 :            : #include "clinic/blob.c.h"
           6                 :            : #undef clinic_state
           7                 :            :
           8                 :            : /*[clinic input]
           9                 :            : module _sqlite3
          10                 :            : class _sqlite3.Blob "pysqlite_Blob *" "clinic_state()->BlobType"
          11                 :            : [clinic start generated code]*/
          12                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=908d3e16a45f8da7]*/
          13                 :            :
          14                 :            : static void
          15                 :          0 : close_blob(pysqlite_Blob *self)
          16                 :            : {
          17         [ #  # ]:          0 :     if (self->blob) {
          18                 :          0 :         sqlite3_blob *blob = self->blob;
          19                 :          0 :         self->blob = NULL;
          20                 :            :
          21                 :          0 :         Py_BEGIN_ALLOW_THREADS
          22                 :          0 :         sqlite3_blob_close(blob);
          23                 :          0 :         Py_END_ALLOW_THREADS
          24                 :            :     }
          25                 :          0 : }
          26                 :            :
          27                 :            : static int
          28                 :          0 : blob_traverse(pysqlite_Blob *self, visitproc visit, void *arg)
          29                 :            : {
          30   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(self));
          31   [ #  #  #  # ]:          0 :     Py_VISIT(self->connection);
          32                 :          0 :     return 0;
          33                 :            : }
          34                 :            :
          35                 :            : static int
          36                 :          0 : blob_clear(pysqlite_Blob *self)
          37                 :            : {
          38         [ #  # ]:          0 :     Py_CLEAR(self->connection);
          39                 :          0 :     return 0;
          40                 :            : }
          41                 :            :
          42                 :            : static void
          43                 :          0 : blob_dealloc(pysqlite_Blob *self)
          44                 :            : {
          45                 :          0 :     PyTypeObject *tp = Py_TYPE(self);
          46                 :          0 :     PyObject_GC_UnTrack(self);
          47                 :            :
          48                 :          0 :     close_blob(self);
          49                 :            :
          50         [ #  # ]:          0 :     if (self->in_weakreflist != NULL) {
          51                 :          0 :         PyObject_ClearWeakRefs((PyObject*)self);
          52                 :            :     }
          53                 :          0 :     tp->tp_clear((PyObject *)self);
          54                 :          0 :     tp->tp_free(self);
          55                 :          0 :     Py_DECREF(tp);
          56                 :          0 : }
          57                 :            :
          58                 :            : // Return 1 if the blob object is usable, 0 if not.
          59                 :            : static int
          60                 :          0 : check_blob(pysqlite_Blob *self)
          61                 :            : {
          62   [ #  #  #  # ]:          0 :     if (!pysqlite_check_connection(self->connection) ||
          63                 :          0 :         !pysqlite_check_thread(self->connection)) {
          64                 :          0 :         return 0;
          65                 :            :     }
          66         [ #  # ]:          0 :     if (self->blob == NULL) {
          67                 :          0 :         pysqlite_state *state = self->connection->state;
          68                 :          0 :         PyErr_SetString(state->ProgrammingError,
          69                 :            :                         "Cannot operate on a closed blob.");
          70                 :          0 :         return 0;
          71                 :            :     }
          72                 :          0 :     return 1;
          73                 :            : }
          74                 :            :
          75                 :            :
          76                 :            : /*[clinic input]
          77                 :            : _sqlite3.Blob.close as blob_close
          78                 :            :
          79                 :            : Close the blob.
          80                 :            : [clinic start generated code]*/
          81                 :            :
          82                 :            : static PyObject *
          83                 :          0 : blob_close_impl(pysqlite_Blob *self)
          84                 :            : /*[clinic end generated code: output=848accc20a138d1b input=7bc178a402a40bd8]*/
          85                 :            : {
          86   [ #  #  #  # ]:          0 :     if (!pysqlite_check_connection(self->connection) ||
          87                 :          0 :         !pysqlite_check_thread(self->connection))
          88                 :            :     {
          89                 :          0 :         return NULL;
          90                 :            :     }
          91                 :          0 :     close_blob(self);
          92                 :          0 :     Py_RETURN_NONE;
          93                 :            : };
          94                 :            :
          95                 :            : void
          96                 :          0 : pysqlite_close_all_blobs(pysqlite_Connection *self)
          97                 :            : {
          98         [ #  # ]:          0 :     for (int i = 0; i < PyList_GET_SIZE(self->blobs); i++) {
          99                 :          0 :         PyObject *weakref = PyList_GET_ITEM(self->blobs, i);
         100                 :          0 :         PyObject *blob = PyWeakref_GetObject(weakref);
         101         [ #  # ]:          0 :         if (!Py_IsNone(blob)) {
         102                 :          0 :             close_blob((pysqlite_Blob *)blob);
         103                 :            :         }
         104                 :            :     }
         105                 :          0 : }
         106                 :            :
         107                 :            : static void
         108                 :          0 : blob_seterror(pysqlite_Blob *self, int rc)
         109                 :            : {
         110                 :            :     assert(self->connection != NULL);
         111                 :            : #if SQLITE_VERSION_NUMBER < 3008008
         112                 :            :     // SQLite pre 3.8.8 does not set this blob error on the connection
         113                 :            :     if (rc == SQLITE_ABORT) {
         114                 :            :         PyErr_SetString(self->connection->OperationalError,
         115                 :            :                         "Cannot operate on an expired blob handle");
         116                 :            :         return;
         117                 :            :     }
         118                 :            : #endif
         119                 :          0 :     _pysqlite_seterror(self->connection->state, self->connection->db);
         120                 :          0 : }
         121                 :            :
         122                 :            : static PyObject *
         123                 :          0 : read_single(pysqlite_Blob *self, Py_ssize_t offset)
         124                 :            : {
         125                 :          0 :     unsigned char buf = 0;
         126                 :            :     int rc;
         127                 :          0 :     Py_BEGIN_ALLOW_THREADS
         128                 :          0 :     rc = sqlite3_blob_read(self->blob, (void *)&buf, 1, (int)offset);
         129                 :          0 :     Py_END_ALLOW_THREADS
         130                 :            :
         131         [ #  # ]:          0 :     if (rc != SQLITE_OK) {
         132                 :          0 :         blob_seterror(self, rc);
         133                 :          0 :         return NULL;
         134                 :            :     }
         135                 :          0 :     return PyLong_FromUnsignedLong((unsigned long)buf);
         136                 :            : }
         137                 :            :
         138                 :            : static PyObject *
         139                 :          0 : read_multiple(pysqlite_Blob *self, Py_ssize_t length, Py_ssize_t offset)
         140                 :            : {
         141                 :            :     assert(length <= sqlite3_blob_bytes(self->blob));
         142                 :            :     assert(offset < sqlite3_blob_bytes(self->blob));
         143                 :            :
         144                 :          0 :     PyObject *buffer = PyBytes_FromStringAndSize(NULL, length);
         145         [ #  # ]:          0 :     if (buffer == NULL) {
         146                 :          0 :         return NULL;
         147                 :            :     }
         148                 :            :
         149                 :          0 :     char *raw_buffer = PyBytes_AS_STRING(buffer);
         150                 :            :     int rc;
         151                 :          0 :     Py_BEGIN_ALLOW_THREADS
         152                 :          0 :     rc = sqlite3_blob_read(self->blob, raw_buffer, (int)length, (int)offset);
         153                 :          0 :     Py_END_ALLOW_THREADS
         154                 :            :
         155         [ #  # ]:          0 :     if (rc != SQLITE_OK) {
         156                 :          0 :         Py_DECREF(buffer);
         157                 :          0 :         blob_seterror(self, rc);
         158                 :          0 :         return NULL;
         159                 :            :     }
         160                 :          0 :     return buffer;
         161                 :            : }
         162                 :            :
         163                 :            :
         164                 :            : /*[clinic input]
         165                 :            : _sqlite3.Blob.read as blob_read
         166                 :            :
         167                 :            :     length: int = -1
         168                 :            :         Read length in bytes.
         169                 :            :     /
         170                 :            :
         171                 :            : Read data at the current offset position.
         172                 :            :
         173                 :            : If the end of the blob is reached, the data up to end of file will be returned.
         174                 :            : When length is not specified, or is negative, Blob.read() will read until the
         175                 :            : end of the blob.
         176                 :            : [clinic start generated code]*/
         177                 :            :
         178                 :            : static PyObject *
         179                 :          0 : blob_read_impl(pysqlite_Blob *self, int length)
         180                 :            : /*[clinic end generated code: output=1fc99b2541360dde input=f2e4aa4378837250]*/
         181                 :            : {
         182         [ #  # ]:          0 :     if (!check_blob(self)) {
         183                 :          0 :         return NULL;
         184                 :            :     }
         185                 :            :
         186                 :            :     /* Make sure we never read past "EOB". Also read the rest of the blob if a
         187                 :            :      * negative length is specified. */
         188                 :          0 :     int blob_len = sqlite3_blob_bytes(self->blob);
         189                 :          0 :     int max_read_len = blob_len - self->offset;
         190   [ #  #  #  # ]:          0 :     if (length < 0 || length > max_read_len) {
         191                 :          0 :         length = max_read_len;
         192                 :            :     }
         193                 :            :
         194                 :            :     assert(length >= 0);
         195         [ #  # ]:          0 :     if (length == 0) {
         196                 :          0 :         return PyBytes_FromStringAndSize(NULL, 0);
         197                 :            :     }
         198                 :            :
         199                 :          0 :     PyObject *buffer = read_multiple(self, length, self->offset);
         200         [ #  # ]:          0 :     if (buffer == NULL) {
         201                 :          0 :         return NULL;
         202                 :            :     }
         203                 :          0 :     self->offset += length;
         204                 :          0 :     return buffer;
         205                 :            : };
         206                 :            :
         207                 :            : static int
         208                 :          0 : inner_write(pysqlite_Blob *self, const void *buf, Py_ssize_t len,
         209                 :            :             Py_ssize_t offset)
         210                 :            : {
         211                 :          0 :     Py_ssize_t blob_len = sqlite3_blob_bytes(self->blob);
         212                 :          0 :     Py_ssize_t remaining_len = blob_len - offset;
         213         [ #  # ]:          0 :     if (len > remaining_len) {
         214                 :          0 :         PyErr_SetString(PyExc_ValueError, "data longer than blob length");
         215                 :          0 :         return -1;
         216                 :            :     }
         217                 :            :
         218                 :            :     assert(offset <= blob_len);
         219                 :            :     int rc;
         220                 :          0 :     Py_BEGIN_ALLOW_THREADS
         221                 :          0 :     rc = sqlite3_blob_write(self->blob, buf, (int)len, (int)offset);
         222                 :          0 :     Py_END_ALLOW_THREADS
         223                 :            :
         224         [ #  # ]:          0 :     if (rc != SQLITE_OK) {
         225                 :          0 :         blob_seterror(self, rc);
         226                 :          0 :         return -1;
         227                 :            :     }
         228                 :          0 :     return 0;
         229                 :            : }
         230                 :            :
         231                 :            :
         232                 :            : /*[clinic input]
         233                 :            : _sqlite3.Blob.write as blob_write
         234                 :            :
         235                 :            :     data: Py_buffer
         236                 :            :     /
         237                 :            :
         238                 :            : Write data at the current offset.
         239                 :            :
         240                 :            : This function cannot change the blob length.  Writing beyond the end of the
         241                 :            : blob will result in an exception being raised.
         242                 :            : [clinic start generated code]*/
         243                 :            :
         244                 :            : static PyObject *
         245                 :          0 : blob_write_impl(pysqlite_Blob *self, Py_buffer *data)
         246                 :            : /*[clinic end generated code: output=b34cf22601b570b2 input=a84712f24a028e6d]*/
         247                 :            : {
         248         [ #  # ]:          0 :     if (!check_blob(self)) {
         249                 :          0 :         return NULL;
         250                 :            :     }
         251                 :            :
         252                 :          0 :     int rc = inner_write(self, data->buf, data->len, self->offset);
         253         [ #  # ]:          0 :     if (rc < 0) {
         254                 :          0 :         return NULL;
         255                 :            :     }
         256                 :          0 :     self->offset += (int)data->len;
         257                 :          0 :     Py_RETURN_NONE;
         258                 :            : }
         259                 :            :
         260                 :            :
         261                 :            : /*[clinic input]
         262                 :            : _sqlite3.Blob.seek as blob_seek
         263                 :            :
         264                 :            :     offset: int
         265                 :            :     origin: int = 0
         266                 :            :     /
         267                 :            :
         268                 :            : Set the current access position to offset.
         269                 :            :
         270                 :            : The origin argument defaults to os.SEEK_SET (absolute blob positioning).
         271                 :            : Other values for origin are os.SEEK_CUR (seek relative to the current position)
         272                 :            : and os.SEEK_END (seek relative to the blob's end).
         273                 :            : [clinic start generated code]*/
         274                 :            :
         275                 :            : static PyObject *
         276                 :          0 : blob_seek_impl(pysqlite_Blob *self, int offset, int origin)
         277                 :            : /*[clinic end generated code: output=854c5a0e208547a5 input=5da9a07e55fe6bb6]*/
         278                 :            : {
         279         [ #  # ]:          0 :     if (!check_blob(self)) {
         280                 :          0 :         return NULL;
         281                 :            :     }
         282                 :            :
         283                 :          0 :     int blob_len = sqlite3_blob_bytes(self->blob);
         284   [ #  #  #  # ]:          0 :     switch (origin) {
         285                 :          0 :         case SEEK_SET:
         286                 :          0 :             break;
         287                 :          0 :         case SEEK_CUR:
         288         [ #  # ]:          0 :             if (offset > INT_MAX - self->offset) {
         289                 :          0 :                 goto overflow;
         290                 :            :             }
         291                 :          0 :             offset += self->offset;
         292                 :          0 :             break;
         293                 :          0 :         case SEEK_END:
         294         [ #  # ]:          0 :             if (offset > INT_MAX - blob_len) {
         295                 :          0 :                 goto overflow;
         296                 :            :             }
         297                 :          0 :             offset += blob_len;
         298                 :          0 :             break;
         299                 :          0 :         default:
         300                 :          0 :             PyErr_SetString(PyExc_ValueError,
         301                 :            :                             "'origin' should be os.SEEK_SET, os.SEEK_CUR, or "
         302                 :            :                             "os.SEEK_END");
         303                 :          0 :             return NULL;
         304                 :            :     }
         305                 :            :
         306   [ #  #  #  # ]:          0 :     if (offset < 0 || offset > blob_len) {
         307                 :          0 :         PyErr_SetString(PyExc_ValueError, "offset out of blob range");
         308                 :          0 :         return NULL;
         309                 :            :     }
         310                 :            :
         311                 :          0 :     self->offset = offset;
         312                 :          0 :     Py_RETURN_NONE;
         313                 :            :
         314                 :          0 : overflow:
         315                 :          0 :     PyErr_SetString(PyExc_OverflowError, "seek offset results in overflow");
         316                 :          0 :     return NULL;
         317                 :            : }
         318                 :            :
         319                 :            :
         320                 :            : /*[clinic input]
         321                 :            : _sqlite3.Blob.tell as blob_tell
         322                 :            :
         323                 :            : Return the current access position for the blob.
         324                 :            : [clinic start generated code]*/
         325                 :            :
         326                 :            : static PyObject *
         327                 :          0 : blob_tell_impl(pysqlite_Blob *self)
         328                 :            : /*[clinic end generated code: output=3d3ba484a90b3a99 input=7e34057aa303612c]*/
         329                 :            : {
         330         [ #  # ]:          0 :     if (!check_blob(self)) {
         331                 :          0 :         return NULL;
         332                 :            :     }
         333                 :          0 :     return PyLong_FromLong(self->offset);
         334                 :            : }
         335                 :            :
         336                 :            :
         337                 :            : /*[clinic input]
         338                 :            : _sqlite3.Blob.__enter__ as blob_enter
         339                 :            :
         340                 :            : Blob context manager enter.
         341                 :            : [clinic start generated code]*/
         342                 :            :
         343                 :            : static PyObject *
         344                 :          0 : blob_enter_impl(pysqlite_Blob *self)
         345                 :            : /*[clinic end generated code: output=4fd32484b071a6cd input=fe4842c3c582d5a7]*/
         346                 :            : {
         347         [ #  # ]:          0 :     if (!check_blob(self)) {
         348                 :          0 :         return NULL;
         349                 :            :     }
         350                 :          0 :     return Py_NewRef(self);
         351                 :            : }
         352                 :            :
         353                 :            :
         354                 :            : /*[clinic input]
         355                 :            : _sqlite3.Blob.__exit__ as blob_exit
         356                 :            :
         357                 :            :     type: object
         358                 :            :     val: object
         359                 :            :     tb: object
         360                 :            :     /
         361                 :            :
         362                 :            : Blob context manager exit.
         363                 :            : [clinic start generated code]*/
         364                 :            :
         365                 :            : static PyObject *
         366                 :          0 : blob_exit_impl(pysqlite_Blob *self, PyObject *type, PyObject *val,
         367                 :            :                PyObject *tb)
         368                 :            : /*[clinic end generated code: output=fc86ceeb2b68c7b2 input=575d9ecea205f35f]*/
         369                 :            : {
         370         [ #  # ]:          0 :     if (!check_blob(self)) {
         371                 :          0 :         return NULL;
         372                 :            :     }
         373                 :          0 :     close_blob(self);
         374                 :          0 :     Py_RETURN_FALSE;
         375                 :            : }
         376                 :            :
         377                 :            : static Py_ssize_t
         378                 :          0 : blob_length(pysqlite_Blob *self)
         379                 :            : {
         380         [ #  # ]:          0 :     if (!check_blob(self)) {
         381                 :          0 :         return -1;
         382                 :            :     }
         383                 :          0 :     return sqlite3_blob_bytes(self->blob);
         384                 :            : };
         385                 :            :
         386                 :            : static Py_ssize_t
         387                 :          0 : get_subscript_index(pysqlite_Blob *self, PyObject *item)
         388                 :            : {
         389                 :          0 :     Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
         390   [ #  #  #  # ]:          0 :     if (i == -1 && PyErr_Occurred()) {
         391                 :          0 :         return -1;
         392                 :            :     }
         393                 :          0 :     int blob_len = sqlite3_blob_bytes(self->blob);
         394         [ #  # ]:          0 :     if (i < 0) {
         395                 :          0 :         i += blob_len;
         396                 :            :     }
         397   [ #  #  #  # ]:          0 :     if (i < 0 || i >= blob_len) {
         398                 :          0 :         PyErr_SetString(PyExc_IndexError, "Blob index out of range");
         399                 :          0 :         return -1;
         400                 :            :     }
         401                 :          0 :     return i;
         402                 :            : }
         403                 :            :
         404                 :            : static PyObject *
         405                 :          0 : subscript_index(pysqlite_Blob *self, PyObject *item)
         406                 :            : {
         407                 :          0 :     Py_ssize_t i = get_subscript_index(self, item);
         408         [ #  # ]:          0 :     if (i < 0) {
         409                 :          0 :         return NULL;
         410                 :            :     }
         411                 :          0 :     return read_single(self, i);
         412                 :            : }
         413                 :            :
         414                 :            : static int
         415                 :          0 : get_slice_info(pysqlite_Blob *self, PyObject *item, Py_ssize_t *start,
         416                 :            :                Py_ssize_t *stop, Py_ssize_t *step, Py_ssize_t *slicelen)
         417                 :            : {
         418         [ #  # ]:          0 :     if (PySlice_Unpack(item, start, stop, step) < 0) {
         419                 :          0 :         return -1;
         420                 :            :     }
         421                 :          0 :     int len = sqlite3_blob_bytes(self->blob);
         422                 :          0 :     *slicelen = PySlice_AdjustIndices(len, start, stop, *step);
         423                 :          0 :     return 0;
         424                 :            : }
         425                 :            :
         426                 :            : static PyObject *
         427                 :          0 : subscript_slice(pysqlite_Blob *self, PyObject *item)
         428                 :            : {
         429                 :            :     Py_ssize_t start, stop, step, len;
         430         [ #  # ]:          0 :     if (get_slice_info(self, item, &start, &stop, &step, &len) < 0) {
         431                 :          0 :         return NULL;
         432                 :            :     }
         433                 :            :
         434         [ #  # ]:          0 :     if (step == 1) {
         435                 :          0 :         return read_multiple(self, len, start);
         436                 :            :     }
         437                 :          0 :     PyObject *blob = read_multiple(self, stop - start, start);
         438         [ #  # ]:          0 :     if (blob == NULL) {
         439                 :          0 :         return NULL;
         440                 :            :     }
         441                 :          0 :     PyObject *result = PyBytes_FromStringAndSize(NULL, len);
         442         [ #  # ]:          0 :     if (result != NULL) {
         443                 :          0 :         char *blob_buf = PyBytes_AS_STRING(blob);
         444                 :          0 :         char *res_buf = PyBytes_AS_STRING(result);
         445         [ #  # ]:          0 :         for (Py_ssize_t i = 0, j = 0; i < len; i++, j += step) {
         446                 :          0 :             res_buf[i] = blob_buf[j];
         447                 :            :         }
         448                 :          0 :         Py_DECREF(blob);
         449                 :            :     }
         450                 :          0 :     return result;
         451                 :            : }
         452                 :            :
         453                 :            : static PyObject *
         454                 :          0 : blob_subscript(pysqlite_Blob *self, PyObject *item)
         455                 :            : {
         456         [ #  # ]:          0 :     if (!check_blob(self)) {
         457                 :          0 :         return NULL;
         458                 :            :     }
         459                 :            :
         460         [ #  # ]:          0 :     if (PyIndex_Check(item)) {
         461                 :          0 :         return subscript_index(self, item);
         462                 :            :     }
         463         [ #  # ]:          0 :     if (PySlice_Check(item)) {
         464                 :          0 :         return subscript_slice(self, item);
         465                 :            :     }
         466                 :            :
         467                 :          0 :     PyErr_SetString(PyExc_TypeError, "Blob indices must be integers");
         468                 :          0 :     return NULL;
         469                 :            : }
         470                 :            :
         471                 :            : static int
         472                 :          0 : ass_subscript_index(pysqlite_Blob *self, PyObject *item, PyObject *value)
         473                 :            : {
         474         [ #  # ]:          0 :     if (value == NULL) {
         475                 :          0 :         PyErr_SetString(PyExc_TypeError,
         476                 :            :                         "Blob doesn't support item deletion");
         477                 :          0 :         return -1;
         478                 :            :     }
         479         [ #  # ]:          0 :     if (!PyLong_Check(value)) {
         480                 :          0 :         PyErr_Format(PyExc_TypeError,
         481                 :            :                      "'%s' object cannot be interpreted as an integer",
         482                 :          0 :                      Py_TYPE(value)->tp_name);
         483                 :          0 :         return -1;
         484                 :            :     }
         485                 :          0 :     Py_ssize_t i = get_subscript_index(self, item);
         486         [ #  # ]:          0 :     if (i < 0) {
         487                 :          0 :         return -1;
         488                 :            :     }
         489                 :            :
         490                 :          0 :     long val = PyLong_AsLong(value);
         491   [ #  #  #  # ]:          0 :     if (val == -1 && PyErr_Occurred()) {
         492                 :          0 :         PyErr_Clear();
         493                 :          0 :         val = -1;
         494                 :            :     }
         495   [ #  #  #  # ]:          0 :     if (val < 0 || val > 255) {
         496                 :          0 :         PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");
         497                 :          0 :         return -1;
         498                 :            :     }
         499                 :            :     // Downcast to avoid endianness problems.
         500                 :          0 :     unsigned char byte = (unsigned char)val;
         501                 :          0 :     return inner_write(self, (const void *)&byte, 1, i);
         502                 :            : }
         503                 :            :
         504                 :            : static int
         505                 :          0 : ass_subscript_slice(pysqlite_Blob *self, PyObject *item, PyObject *value)
         506                 :            : {
         507         [ #  # ]:          0 :     if (value == NULL) {
         508                 :          0 :         PyErr_SetString(PyExc_TypeError,
         509                 :            :                         "Blob doesn't support slice deletion");
         510                 :          0 :         return -1;
         511                 :            :     }
         512                 :            :
         513                 :            :     Py_ssize_t start, stop, step, len;
         514         [ #  # ]:          0 :     if (get_slice_info(self, item, &start, &stop, &step, &len) < 0) {
         515                 :          0 :         return -1;
         516                 :            :     }
         517                 :            :
         518         [ #  # ]:          0 :     if (len == 0) {
         519                 :          0 :         return 0;
         520                 :            :     }
         521                 :            :
         522                 :            :     Py_buffer vbuf;
         523         [ #  # ]:          0 :     if (PyObject_GetBuffer(value, &vbuf, PyBUF_SIMPLE) < 0) {
         524                 :          0 :         return -1;
         525                 :            :     }
         526                 :            :
         527                 :          0 :     int rc = -1;
         528         [ #  # ]:          0 :     if (vbuf.len != len) {
         529                 :          0 :         PyErr_SetString(PyExc_IndexError,
         530                 :            :                         "Blob slice assignment is wrong size");
         531                 :            :     }
         532         [ #  # ]:          0 :     else if (step == 1) {
         533                 :          0 :         rc = inner_write(self, vbuf.buf, len, start);
         534                 :            :     }
         535                 :            :     else {
         536                 :          0 :         PyObject *blob_bytes = read_multiple(self, stop - start, start);
         537         [ #  # ]:          0 :         if (blob_bytes != NULL) {
         538                 :          0 :             char *blob_buf = PyBytes_AS_STRING(blob_bytes);
         539         [ #  # ]:          0 :             for (Py_ssize_t i = 0, j = 0; i < len; i++, j += step) {
         540                 :          0 :                 blob_buf[j] = ((char *)vbuf.buf)[i];
         541                 :            :             }
         542                 :          0 :             rc = inner_write(self, blob_buf, stop - start, start);
         543                 :          0 :             Py_DECREF(blob_bytes);
         544                 :            :         }
         545                 :            :     }
         546                 :          0 :     PyBuffer_Release(&vbuf);
         547                 :          0 :     return rc;
         548                 :            : }
         549                 :            :
         550                 :            : static int
         551                 :          0 : blob_ass_subscript(pysqlite_Blob *self, PyObject *item, PyObject *value)
         552                 :            : {
         553         [ #  # ]:          0 :     if (!check_blob(self)) {
         554                 :          0 :         return -1;
         555                 :            :     }
         556                 :            :
         557         [ #  # ]:          0 :     if (PyIndex_Check(item)) {
         558                 :          0 :         return ass_subscript_index(self, item, value);
         559                 :            :     }
         560         [ #  # ]:          0 :     if (PySlice_Check(item)) {
         561                 :          0 :         return ass_subscript_slice(self, item, value);
         562                 :            :     }
         563                 :            :
         564                 :          0 :     PyErr_SetString(PyExc_TypeError, "Blob indices must be integers");
         565                 :          0 :     return -1;
         566                 :            : }
         567                 :            :
         568                 :            :
         569                 :            : static PyMethodDef blob_methods[] = {
         570                 :            :     BLOB_CLOSE_METHODDEF
         571                 :            :     BLOB_ENTER_METHODDEF
         572                 :            :     BLOB_EXIT_METHODDEF
         573                 :            :     BLOB_READ_METHODDEF
         574                 :            :     BLOB_SEEK_METHODDEF
         575                 :            :     BLOB_TELL_METHODDEF
         576                 :            :     BLOB_WRITE_METHODDEF
         577                 :            :     {NULL, NULL}
         578                 :            : };
         579                 :            :
         580                 :            : static struct PyMemberDef blob_members[] = {
         581                 :            :     {"__weaklistoffset__", T_PYSSIZET, offsetof(pysqlite_Blob, in_weakreflist), READONLY},
         582                 :            :     {NULL},
         583                 :            : };
         584                 :            :
         585                 :            : static PyType_Slot blob_slots[] = {
         586                 :            :     {Py_tp_dealloc, blob_dealloc},
         587                 :            :     {Py_tp_traverse, blob_traverse},
         588                 :            :     {Py_tp_clear, blob_clear},
         589                 :            :     {Py_tp_methods, blob_methods},
         590                 :            :     {Py_tp_members, blob_members},
         591                 :            :
         592                 :            :     // Mapping protocol
         593                 :            :     {Py_mp_length, blob_length},
         594                 :            :     {Py_mp_subscript, blob_subscript},
         595                 :            :     {Py_mp_ass_subscript, blob_ass_subscript},
         596                 :            :     {0, NULL},
         597                 :            : };
         598                 :            :
         599                 :            : static PyType_Spec blob_spec = {
         600                 :            :     .name = MODULE_NAME ".Blob",
         601                 :            :     .basicsize = sizeof(pysqlite_Blob),
         602                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
         603                 :            :               Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION),
         604                 :            :     .slots = blob_slots,
         605                 :            : };
         606                 :            :
         607                 :            : int
         608                 :          1 : pysqlite_blob_setup_types(PyObject *mod)
         609                 :            : {
         610                 :          1 :     PyObject *type = PyType_FromModuleAndSpec(mod, &blob_spec, NULL);
         611         [ -  + ]:          1 :     if (type == NULL) {
         612                 :          0 :         return -1;
         613                 :            :     }
         614                 :          1 :     pysqlite_state *state = pysqlite_get_state(mod);
         615                 :          1 :     state->BlobType = (PyTypeObject *)type;
         616                 :          1 :     return 0;
         617                 :            : }

Generated by: LCOV version 1.14