From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from [87.239.111.99] (localhost [127.0.0.1]) by dev.tarantool.org (Postfix) with ESMTP id 8C4376EC5B; Wed, 14 Apr 2021 00:36:56 +0300 (MSK) DKIM-Filter: OpenDKIM Filter v2.11.0 dev.tarantool.org 8C4376EC5B DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=tarantool.org; s=dev; t=1618349816; bh=k8Q8IIHQ+2WCqT45km85FK5ErdEqcPqvqWSlADbFo3w=; h=Date:To:References:In-Reply-To:Subject:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=b0DLkRY16Od2mprNbDMecdU4G3x4rLnqznVY7nwLdJZBW3e2VCKCfM0o82N1IiMiH dZanFtFfLbdax4nQRGq8u1qHOASh7Cm4qOvU8mMoanGxbNZr3Wv2I9g+pX0JUuvysG YjbZ2a2SUDrPfRBrYXyPoCIUebCpg8hhgPb7mHmU= Received: from smtp16.mail.ru (smtp16.mail.ru [94.100.176.153]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dev.tarantool.org (Postfix) with ESMTPS id 4B67A6EC5B for ; Wed, 14 Apr 2021 00:36:55 +0300 (MSK) DKIM-Filter: OpenDKIM Filter v2.11.0 dev.tarantool.org 4B67A6EC5B Received: by smtp16.mail.ru with esmtpa (envelope-from ) id 1lWQiM-0000wZ-7C; Wed, 14 Apr 2021 00:36:54 +0300 Date: Wed, 14 Apr 2021 00:36:52 +0300 To: Vladislav Shpilevoy Message-ID: <20210413213652.GA37176@tarantool.org> References: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline In-Reply-To: X-7564579A: B8F34718100C35BD X-77F55803: 4F1203BC0FB41BD92FFCB8E6708E74807BAE725B9AE625DE765B0E193B5B7687182A05F538085040A900545E9B74FD107E0601B4F35BD0305C03B55174E7B520AC58F9DE6E6ADA73 X-7FA49CB5: FF5795518A3D127A4AD6D5ED66289B5278DA827A17800CE7D9C4478D0B876341EA1F7E6F0F101C67BD4B6F7A4D31EC0BCC500DACC3FED6E28638F802B75D45FF8AA50765F7900637BB2557E27C12D3EF8638F802B75D45FF914D58D5BE9E6BC1A93B80C6DEB9DEE97C6FB206A91F05B237A6D80571A96E9EE37DE297A1FB15630A05E728617FD226D2E47CDBA5A96583C09775C1D3CA48CF27ED053E960B195E117882F4460429724CE54428C33FAD30A8DF7F3B2552694AC26CFBAC0749D213D2E47CDBA5A9658378DA827A17800CE78C592797616C97AB9FA2833FD35BB23DF004C90652538430302FCEF25BFAB3454AD6D5ED66289B5278DA827A17800CE7FA3D786573799A4ED32BA5DBAC0009BE395957E7521B51C20BC6067A898B09E4090A508E0FED6299176DF2183F8FC7C02059237F47C255B9CD04E86FAF290E2D7E9C4E3C761E06A71DD303D21008E298D5E8D9A59859A8B6B372FE9A2E580EFC725E5C173C3A84C3727597FF642BA4D735872C767BF85DA2F004C90652538430E4A6367B16DE6309 X-B7AD71C0: AC4F5C86D027EB782CDD5689AFBDA7A2368A440D3B0F6089093C9A16E5BC824A2A04A2ABAA09D25379311020FFC8D4AD709C0CAEBE946811818A328769E7B179 X-C1DE0DAB: 0D63561A33F958A5082903881E71EB17A642EA4AA9B28E330CD09799DB51308ED59269BC5F550898D99A6476B3ADF6B47008B74DF8BB9EF7333BD3B22AA88B938A852937E12ACA7502E6951B79FF9A3F410CA545F18667F91A7EA1CDA0B5A7A0 X-C8649E89: 4E36BF7865823D7055A7F0CF078B5EC49A30900B95165D3454E98140CCACB5B33A5A658FACEF252E14713CB98FBF512ADBFFBAB3784CC379CC2CB98EE7471D511D7E09C32AA3244CAF030E95E5E11E6B9E65214360623DFD95A9E0DC41E9A4CFFACE5A9C96DEB163 X-D57D3AED: 3ZO7eAau8CL7WIMRKs4sN3D3tLDjz0dLbV79QFUyzQ2Ujvy7cMT6pYYqY16iZVKkSc3dCLJ7zSJH7+u4VD18S7Vl4ZUrpaVfd2+vE6kuoey4m4VkSEu530nj6fImhcD4MUrOEAnl0W826KZ9Q+tr5ycPtXkTV4k65bRjmOUUP8cvGozZ33TWg5HZplvhhXbhDGzqmQDTd6OAevLeAnq3Ra9uf7zvY2zzsIhlcp/Y7m53TZgf2aB4JOg4gkr2biojnA7/qPBUIXFB+MUkg1L8kA== X-Mailru-Sender: 5C3750E245F362008BC1685FEC6306ED630839761C26A95D7E0601B4F35BD030C59A7EFB72EB47B25105BD0848736F9966FEC6BF5C9C28D97E07721503EA2E00ED97202A5A4E92BF7402F9BA4338D657ED14614B50AE0675 X-Mras: Ok Subject: Re: [Tarantool-patches] [PATCH v5 27/52] sql: introduce mem_set_str_*() functions X-BeenThere: tarantool-patches@dev.tarantool.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Tarantool development patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , From: Mergen Imeev via Tarantool-patches Reply-To: Mergen Imeev Cc: tarantool-patches@dev.tarantool.org Errors-To: tarantool-patches-bounces@dev.tarantool.org Sender: "Tarantool-patches" Thank you for the review! My answers, diff and new patch below. On Tue, Apr 13, 2021 at 01:34:22AM +0200, Vladislav Shpilevoy wrote: > Nice fixes! > > See 2 comments below. > > > diff --git a/src/box/sql/vdbeapi.c b/src/box/sql/vdbeapi.c > > index 6c08e772d..e0903e3b0 100644 > > --- a/src/box/sql/vdbeapi.c > > +++ b/src/box/sql/vdbeapi.c > > @@ -125,6 +125,27 @@ setResultStrOrError(sql_context * pCtx, /* Function context */ > > void (*xDel) (void *) /* Destructor function */ > > ) > > { > > + if (xDel == SQL_STATIC) { > > + if (n < 0) > > + mem_set_str0_static(pCtx->pOut, (char *)z); > > + else > > + mem_set_str_static(pCtx->pOut, (char *)z, n); > > + return; > > + } > > + if (xDel == SQL_DYNAMIC) { > > + if (n < 0) > > + mem_set_str0_allocated(pCtx->pOut, (char *)z); > > + else > > + mem_set_str_allocated(pCtx->pOut, (char *)z, n); > > 1. I don't understand. You check for xDel == SQL_DYNAMIC and yet > you use 'allocated' suffix. Below you check for != TRANSIENT > instead of == DYNAMIC, and use 'dynamic'. Why? All looks messed > up. The same in the next hunk. > This is how it worked in sqlValueSetStr(). xDel == SQL_DYNAMIC (which is actually == sqlMallocSize) was used to show that this value should be set as allocated memory; xDel == SQL_TRANSIENT (== -1) was used to show that value should be copied; xDel == SQL_STATIC (== 0) for MEM_Static and in case it some other functions it was treated as free() for given memory, i.e. MEM_Dyn. > > + return; > > + }> diff --git a/src/box/sql/vdbeaux.c b/src/box/sql/vdbeaux.c > > index ae55e4c29..171cb8946 100644 > > --- a/src/box/sql/vdbeaux.c > > +++ b/src/box/sql/vdbeaux.c > > @@ -1333,41 +1331,34 @@ sqlVdbeList(Vdbe * p) > > mem_set_int(pMem, pOp->p3, pOp->p3 < 0); > > pMem++; > > > > - if (sqlVdbeMemClearAndResize(pMem, 256)) { > > - assert(p->db->mallocFailed); > > + char *buf = sqlDbMallocRaw(sql_get(), 256); > > 2. I think you need some kind of mem_set_strlen(), or mem_grow()/mem_reserve(), > or something else to reserve the memory. To extend zMalloc. Otherwise you > can't reuse the memory which might already be in the mem object. Wouldn't mem_copy_*() be enough? In general, allocated by MEM memory should not be accessed for changing (except for MEM_Agg). Diff: diff --git a/src/box/sql/mem.h b/src/box/sql/mem.h index d8e640810..f029ee0e5 100644 --- a/src/box/sql/mem.h +++ b/src/box/sql/mem.h @@ -373,6 +373,42 @@ mem_set_str0_dynamic(struct Mem *mem, char *value); void mem_set_str0_allocated(struct Mem *mem, char *value); +static inline void +mem_set_strl_ephemeral(struct Mem *mem, char *value, int len_hint) +{ + if (len_hint < 0) + mem_set_str0_ephemeral(mem, value); + else + mem_set_str_ephemeral(mem, value, len_hint); +} + +static inline void +mem_set_strl_static(struct Mem *mem, char *value, int len_hint) +{ + if (len_hint < 0) + mem_set_str0_static(mem, value); + else + mem_set_str_static(mem, value, len_hint); +} + +static inline void +mem_set_strl_dynamic(struct Mem *mem, char *value, int len_hint) +{ + if (len_hint < 0) + mem_set_str0_dynamic(mem, value); + else + mem_set_str_dynamic(mem, value, len_hint); +} + +static inline void +mem_set_strl_allocated(struct Mem *mem, char *value, int len_hint) +{ + if (len_hint < 0) + mem_set_str0_allocated(mem, value); + else + mem_set_str_allocated(mem, value, len_hint); +} + /** * Copy content of MEM from one MEM to another. In case source MEM contains * string or binary and allocation type is not STATIC, this value is copied to diff --git a/src/box/sql/vdbeapi.c b/src/box/sql/vdbeapi.c index e0903e3b0..484c66b29 100644 --- a/src/box/sql/vdbeapi.c +++ b/src/box/sql/vdbeapi.c @@ -125,27 +125,12 @@ setResultStrOrError(sql_context * pCtx, /* Function context */ void (*xDel) (void *) /* Destructor function */ ) { - if (xDel == SQL_STATIC) { - if (n < 0) - mem_set_str0_static(pCtx->pOut, (char *)z); - else - mem_set_str_static(pCtx->pOut, (char *)z, n); - return; - } - if (xDel == SQL_DYNAMIC) { - if (n < 0) - mem_set_str0_allocated(pCtx->pOut, (char *)z); - else - mem_set_str_allocated(pCtx->pOut, (char *)z, n); - return; - } - if (xDel != SQL_TRANSIENT) { - if (n < 0) - mem_set_str0_dynamic(pCtx->pOut, (char *)z); - else - mem_set_str_dynamic(pCtx->pOut, (char *)z, n); - return; - } + if (xDel == SQL_STATIC) + return mem_set_strl_static(pCtx->pOut, (char *)z, n); + if (xDel == SQL_DYNAMIC) + return mem_set_strl_allocated(pCtx->pOut, (char *)z, n); + if (xDel != SQL_TRANSIENT) + return mem_set_strl_dynamic(pCtx->pOut, (char *)z, n); if (sqlVdbeMemSetStr(pCtx->pOut, z, n, 1, xDel) != 0) pCtx->is_aborted = true; } @@ -783,24 +768,14 @@ bindText(sql_stmt * pStmt, /* The statement to bind against */ if (zData == NULL) return 0; pVar = &p->aVar[i - 1]; - if (xDel == SQL_STATIC) { - if (nData < 0) - mem_set_str0_static(pVar, (char *)zData); - else - mem_set_str_static(pVar, (char *)zData, nData); - } else if (xDel == SQL_DYNAMIC) { - if (nData < 0) - mem_set_str0_allocated(pVar, (char *)zData); - else - mem_set_str_allocated(pVar, (char *)zData, nData); - } else if (xDel != SQL_TRANSIENT) { - if (nData < 0) - mem_set_str0_dynamic(pVar, (char *)zData); - else - mem_set_str_dynamic(pVar, (char *)zData, nData); - } else if (sqlVdbeMemSetStr(pVar, zData, nData, 1, xDel) != 0) { + if (xDel == SQL_STATIC) + mem_set_strl_static(pVar, (char *)zData, nData); + else if (xDel == SQL_DYNAMIC) + mem_set_strl_allocated(pVar, (char *)zData, nData); + else if (xDel != SQL_TRANSIENT) + mem_set_strl_dynamic(pVar, (char *)zData, nData); + else if (sqlVdbeMemSetStr(pVar, zData, nData, 1, xDel) != 0) return -1; - } return sql_bind_type(p, i, "text"); } New patch: commit 33b35f0b1d8578f99af39d509ac1bdf9abc458cc Author: Mergen Imeev Date: Mon Mar 15 14:28:29 2021 +0300 sql: introduce mem_set_str_*() functions This patch introduces set of mem_set_str_*() functions. These functions clears MEM and sets it to given string value. Degree of clearing and type of allocation of the string is determined by the function used. Part of #5818 diff --git a/src/box/sql/mem.c b/src/box/sql/mem.c index 683094599..5cf067453 100644 --- a/src/box/sql/mem.c +++ b/src/box/sql/mem.c @@ -169,6 +169,89 @@ mem_set_double(struct Mem *mem, double value) mem->flags = MEM_Real; } +static inline void +set_str_const(struct Mem *mem, char *value, uint32_t len, int alloc_type) +{ + assert((alloc_type & (MEM_Static | MEM_Ephem)) != 0); + mem_clear(mem); + mem->z = value; + mem->n = len; + mem->flags = MEM_Str | alloc_type; + mem->field_type = FIELD_TYPE_STRING; +} + +static inline void +set_str_dynamic(struct Mem *mem, char *value, uint32_t len, int alloc_type) +{ + assert((mem->flags & MEM_Dyn) == 0 || value != mem->z); + assert(mem->szMalloc == 0 || value != mem->zMalloc); + assert(alloc_type == MEM_Dyn || alloc_type == 0); + mem_destroy(mem); + mem->z = value; + mem->n = len; + mem->flags = MEM_Str | alloc_type; + mem->field_type = FIELD_TYPE_STRING; + if (alloc_type == MEM_Dyn) { + mem->xDel = sql_free; + } else { + mem->xDel = NULL; + mem->zMalloc = mem->z; + mem->szMalloc = sqlDbMallocSize(mem->db, mem->zMalloc); + } +} + +void +mem_set_str_ephemeral(struct Mem *mem, char *value, uint32_t len) +{ + set_str_const(mem, value, len, MEM_Ephem); +} + +void +mem_set_str_static(struct Mem *mem, char *value, uint32_t len) +{ + set_str_const(mem, value, len, MEM_Static); +} + +void +mem_set_str_dynamic(struct Mem *mem, char *value, uint32_t len) +{ + set_str_dynamic(mem, value, len, MEM_Dyn); +} + +void +mem_set_str_allocated(struct Mem *mem, char *value, uint32_t len) +{ + set_str_dynamic(mem, value, len, 0); +} + +void +mem_set_str0_ephemeral(struct Mem *mem, char *value) +{ + set_str_const(mem, value, strlen(value), MEM_Ephem); + mem->flags |= MEM_Term; +} + +void +mem_set_str0_static(struct Mem *mem, char *value) +{ + set_str_const(mem, value, strlen(value), MEM_Static); + mem->flags |= MEM_Term; +} + +void +mem_set_str0_dynamic(struct Mem *mem, char *value) +{ + set_str_dynamic(mem, value, strlen(value), MEM_Dyn); + mem->flags |= MEM_Term; +} + +void +mem_set_str0_allocated(struct Mem *mem, char *value) +{ + set_str_dynamic(mem, value, strlen(value), 0); + mem->flags |= MEM_Term; +} + int mem_copy(struct Mem *to, const struct Mem *from) { @@ -1908,20 +1991,6 @@ sqlVdbeMemSetZeroBlob(Mem * pMem, int n) pMem->z = 0; } -/* - * Change the string value of an sql_value object - */ -void -sqlValueSetStr(sql_value * v, /* Value to be set */ - int n, /* Length of string z */ - const void *z, /* Text of the new string */ - void (*xDel) (void *) /* Destructor for the string */ - ) -{ - if (v) - sqlVdbeMemSetStr((Mem *) v, z, n, 1, xDel); -} - /* * Free an sql_value object */ diff --git a/src/box/sql/mem.h b/src/box/sql/mem.h index d573487b0..f029ee0e5 100644 --- a/src/box/sql/mem.h +++ b/src/box/sql/mem.h @@ -320,6 +320,95 @@ mem_set_bool(struct Mem *mem, bool value); void mem_set_double(struct Mem *mem, double value); +/** Clear MEM and set it to STRING. The string belongs to another object. */ +void +mem_set_str_ephemeral(struct Mem *mem, char *value, uint32_t len); + +/** Clear MEM and set it to STRING. The string is static. */ +void +mem_set_str_static(struct Mem *mem, char *value, uint32_t len); + +/** + * Clear MEM and set it to STRING. The string was allocated by another object + * and passed to MEM. MEMs with this allocation type must free given memory + * whenever the MEM changes. + */ +void +mem_set_str_dynamic(struct Mem *mem, char *value, uint32_t len); + +/** + * Clear MEM and set it to STRING. The string was allocated by another object + * and passed to MEM. MEMs with this allocation type only deallocate the string + * on destruction. Also, the memory may be reallocated if MEM is set to a + * different value of this allocation type. + */ +void +mem_set_str_allocated(struct Mem *mem, char *value, uint32_t len); + +/** + * Clear MEM and set it to NULL-terminated STRING. The string belongs to + * another object. + */ +void +mem_set_str0_ephemeral(struct Mem *mem, char *value); + +/** Clear MEM and set it to NULL-terminated STRING. The string is static. */ +void +mem_set_str0_static(struct Mem *mem, char *value); + +/** + * Clear MEM and set it to NULL-terminated STRING. The string was allocated by + * another object and passed to MEM. MEMs with this allocation type must free + * given memory whenever the MEM changes. + */ +void +mem_set_str0_dynamic(struct Mem *mem, char *value); + +/** + * Clear MEM and set it to NULL-terminated STRING. The string was allocated by + * another object and passed to MEM. MEMs with this allocation type only + * deallocate the string on destruction. Also, the memory may be reallocated if + * MEM is set to a different value of this allocation type. + */ +void +mem_set_str0_allocated(struct Mem *mem, char *value); + +static inline void +mem_set_strl_ephemeral(struct Mem *mem, char *value, int len_hint) +{ + if (len_hint < 0) + mem_set_str0_ephemeral(mem, value); + else + mem_set_str_ephemeral(mem, value, len_hint); +} + +static inline void +mem_set_strl_static(struct Mem *mem, char *value, int len_hint) +{ + if (len_hint < 0) + mem_set_str0_static(mem, value); + else + mem_set_str_static(mem, value, len_hint); +} + +static inline void +mem_set_strl_dynamic(struct Mem *mem, char *value, int len_hint) +{ + if (len_hint < 0) + mem_set_str0_dynamic(mem, value); + else + mem_set_str_dynamic(mem, value, len_hint); +} + +static inline void +mem_set_strl_allocated(struct Mem *mem, char *value, int len_hint) +{ + if (len_hint < 0) + mem_set_str0_allocated(mem, value); + else + mem_set_str_allocated(mem, value, len_hint); +} + /** * Copy content of MEM from one MEM to another. In case source MEM contains * string or binary and allocation type is not STATIC, this value is copied to @@ -578,8 +667,6 @@ int sqlVdbeMemSetStr(struct Mem *, const char *, int, u8, void (*)(void *)); void sqlVdbeMemSetZeroBlob(struct Mem *, int); -void sqlValueSetStr(struct Mem *, int, const void *, - void (*)(void *)); void sqlValueFree(struct Mem *); struct Mem *sqlValueNew(struct sql *); diff --git a/src/box/sql/sqlInt.h b/src/box/sql/sqlInt.h index 259ba3833..7a026d21b 100644 --- a/src/box/sql/sqlInt.h +++ b/src/box/sql/sqlInt.h @@ -641,10 +641,6 @@ sql_bind_uint64(struct sql_stmt *stmt, int i, uint64_t value); int sql_bind_null(sql_stmt *, int); -int -sql_bind_text(sql_stmt *, int, const char *, int, - void (*)(void *)); - int sql_bind_text64(sql_stmt *, int, const char *, sql_uint64, void (*)(void *)); diff --git a/src/box/sql/vdbe.c b/src/box/sql/vdbe.c index 84704b9d0..d7f01000a 100644 --- a/src/box/sql/vdbe.c +++ b/src/box/sql/vdbe.c @@ -841,9 +841,8 @@ case OP_String8: { /* same as TK_STRING, out2 */ case OP_String: { /* out2 */ assert(pOp->p4.z!=0); pOut = vdbe_prepare_null_out(p, pOp->p2); - pOut->flags = MEM_Str|MEM_Static|MEM_Term; - pOut->z = pOp->p4.z; - pOut->n = pOp->p1; + assert(strlen(pOp->p4.z) == (size_t)pOp->p1); + mem_set_str0_static(pOut, pOp->p4.z); UPDATE_MAX_BLOBSIZE(pOut); break; } diff --git a/src/box/sql/vdbeapi.c b/src/box/sql/vdbeapi.c index 6c08e772d..484c66b29 100644 --- a/src/box/sql/vdbeapi.c +++ b/src/box/sql/vdbeapi.c @@ -125,6 +125,12 @@ setResultStrOrError(sql_context * pCtx, /* Function context */ void (*xDel) (void *) /* Destructor function */ ) { + if (xDel == SQL_STATIC) + return mem_set_strl_static(pCtx->pOut, (char *)z, n); + if (xDel == SQL_DYNAMIC) + return mem_set_strl_allocated(pCtx->pOut, (char *)z, n); + if (xDel != SQL_TRANSIENT) + return mem_set_strl_dynamic(pCtx->pOut, (char *)z, n); if (sqlVdbeMemSetStr(pCtx->pOut, z, n, 1, xDel) != 0) pCtx->is_aborted = true; } @@ -762,7 +768,13 @@ bindText(sql_stmt * pStmt, /* The statement to bind against */ if (zData == NULL) return 0; pVar = &p->aVar[i - 1]; - if (sqlVdbeMemSetStr(pVar, zData, nData, 1, xDel) != 0) + if (xDel == SQL_STATIC) + mem_set_strl_static(pVar, (char *)zData, nData); + else if (xDel == SQL_DYNAMIC) + mem_set_strl_allocated(pVar, (char *)zData, nData); + else if (xDel != SQL_TRANSIENT) + mem_set_strl_dynamic(pVar, (char *)zData, nData); + else if (sqlVdbeMemSetStr(pVar, zData, nData, 1, xDel) != 0) return -1; return sql_bind_type(p, i, "text"); } @@ -876,14 +888,6 @@ sql_bind_ptr(struct sql_stmt *stmt, int i, void *ptr) return rc; } -int -sql_bind_text(sql_stmt * pStmt, - int i, const char *zData, int nData, void (*xDel) (void *) - ) -{ - return bindText(pStmt, i, zData, nData, xDel); -} - int sql_bind_text64(sql_stmt * pStmt, int i, diff --git a/src/box/sql/vdbeaux.c b/src/box/sql/vdbeaux.c index c8ec7f4fa..dad9cab03 100644 --- a/src/box/sql/vdbeaux.c +++ b/src/box/sql/vdbeaux.c @@ -1295,10 +1295,8 @@ sqlVdbeList(Vdbe * p) pMem++; - pMem->flags = MEM_Static | MEM_Str | MEM_Term; - pMem->z = (char *)sqlOpcodeName(pOp->opcode); /* Opcode */ - assert(pMem->z != 0); - pMem->n = sqlStrlen30(pMem->z); + char *value = (char *)sqlOpcodeName(pOp->opcode); + mem_set_str0_static(pMem, value); pMem++; /* When an OP_Program opcode is encounter (the only opcode that has @@ -1333,41 +1331,34 @@ sqlVdbeList(Vdbe * p) mem_set_int(pMem, pOp->p3, pOp->p3 < 0); pMem++; - if (sqlVdbeMemClearAndResize(pMem, 256)) { - assert(p->db->mallocFailed); + char *buf = sqlDbMallocRaw(sql_get(), 256); + if (buf == NULL) return -1; - } - pMem->flags = MEM_Str | MEM_Term; - zP4 = displayP4(pOp, pMem->z, pMem->szMalloc); - - if (zP4 != pMem->z) { - pMem->n = 0; - sqlVdbeMemSetStr(pMem, zP4, -1, 1, 0); + zP4 = displayP4(pOp, buf, sqlDbMallocSize(sql_get(), buf)); + if (zP4 != buf) { + sqlDbFree(sql_get(), buf); + mem_set_str0_ephemeral(pMem, zP4); } else { - assert(pMem->z != 0); - pMem->n = sqlStrlen30(pMem->z); + mem_set_str0_allocated(pMem, zP4); } pMem++; if (p->explain == 1) { - if (sqlVdbeMemClearAndResize(pMem, 4)) { - assert(p->db->mallocFailed); + buf = sqlDbMallocRaw(sql_get(), 4); + if (buf == NULL) return -1; - } - pMem->flags = MEM_Str | MEM_Term; - pMem->n = 2; - sql_snprintf(3, pMem->z, "%.2x", pOp->p5); /* P5 */ + sql_snprintf(3, buf, "%.2x", pOp->p5); + mem_set_str0_allocated(pMem, buf); pMem++; #ifdef SQL_ENABLE_EXPLAIN_COMMENTS - if (sqlVdbeMemClearAndResize(pMem, 500)) { - assert(p->db->mallocFailed); + buf = sqlDbMallocRaw(sql_get(), 500); + if (buf == NULL) return -1; - } - pMem->flags = MEM_Str | MEM_Term; - pMem->n = displayComment(pOp, zP4, pMem->z, 500); + displayComment(pOp, zP4, buf, 500); + mem_set_str0_allocated(pMem, buf); #else - pMem->flags = MEM_Null; /* Comment */ + mem_set_null(pMem); #endif }