mirrors/sqlite
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add the contentless_unindexed=1 option to fts5. This causes the values of any UNINDEXED columns of a contentless fts5 table to be stored persistently in the database.

Browse Source 
FossilOrigin-Name: 58313ac59e0bd164f601d68a1474f658c5d1c038638e00f3dc15eb58202e661c
This commit is contained in:
dan 2024-10-02 17:04:30 +00:00
commit c5c3cbc026
9 changed files with 795 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ext/fts5/fts5Int.h
View File

@ -224,6 +224,7 @@ struct Fts5Config {
int *aPrefix; /* Sizes in bytes of nPrefix prefix indexes */
int eContent; /* An FTS5_CONTENT value */
int bContentlessDelete; /* "contentless_delete=" option (dflt==0) */
int bContentlessUnindexed; /* "contentless_unindexed=" option (dflt=0) */
char *zContent; /* content table */
char *zContentRowid; /* "content_rowid=" option value */
int bColumnsize; /* "columnsize=" option value (dflt==1) */
@ -262,9 +263,10 @@ struct Fts5Config {
#define FTS5_CURRENT_VERSION 4
#define FTS5_CURRENT_VERSION_SECUREDELETE 5
#define FTS5_CONTENT_NORMAL 0
#define FTS5_CONTENT_NONE 1
#define FTS5_CONTENT_EXTERNAL 2
#define FTS5_CONTENT_NORMAL 0
#define FTS5_CONTENT_NONE 1
#define FTS5_CONTENT_EXTERNAL 2
#define FTS5_CONTENT_UNINDEXED 3
#define FTS5_DETAIL_FULL 0
#define FTS5_DETAIL_NONE 1
@ -724,7 +726,7 @@ int sqlite3Fts5DropAll(Fts5Config*);
int sqlite3Fts5CreateTable(Fts5Config*, const char*, const char*, int, char **);
int sqlite3Fts5StorageDelete(Fts5Storage *p, i64, sqlite3_value**, int);
int sqlite3Fts5StorageContentInsert(Fts5Storage *p, sqlite3_value**, i64*);
int sqlite3Fts5StorageContentInsert(Fts5Storage *p, int, sqlite3_value**, i64*);
int sqlite3Fts5StorageIndexInsert(Fts5Storage *p, sqlite3_value**, i64);
int sqlite3Fts5StorageIntegrity(Fts5Storage *p, int iArg);

46
ext/fts5/fts5_config.c
View File

@ -241,6 +241,7 @@ static int fts5ConfigParseSpecial(
){
int rc = SQLITE_OK;
int nCmd = (int)strlen(zCmd);
if( sqlite3_strnicmp("prefix", zCmd, nCmd)==0 ){
const int nByte = sizeof(int) * FTS5_MAX_PREFIX_INDEXES;
const char *p;
@ -360,6 +361,16 @@ static int fts5ConfigParseSpecial(
return rc;
}
if( sqlite3_strnicmp("contentless_unindexed", zCmd, nCmd)==0 ){
if( (zArg[0]!='0' && zArg[0]!='1') || zArg[1]!='\0' ){
*pzErr = sqlite3_mprintf("malformed contentless_delete=... directive");
rc = SQLITE_ERROR;
}else{
pConfig->bContentlessUnindexed = (zArg[0]=='1');
}
return rc;
}
if( sqlite3_strnicmp("content_rowid", zCmd, nCmd)==0 ){
if( pConfig->zContentRowid ){
*pzErr = sqlite3_mprintf("multiple content_rowid=... directives");
@ -477,7 +488,8 @@ static int fts5ConfigParseColumn(
Fts5Config *p,
char *zCol,
char *zArg,
char **pzErr
char **pzErr,
int *pbUnindexed
){
int rc = SQLITE_OK;
if( 0==sqlite3_stricmp(zCol, FTS5_RANK_NAME)
@ -488,6 +500,7 @@ static int fts5ConfigParseColumn(
}else if( zArg ){
if( 0==sqlite3_stricmp(zArg, "unindexed") ){
p->abUnindexed[p->nCol] = 1;
*pbUnindexed = 1;
}else{
*pzErr = sqlite3_mprintf("unrecognized column option: %s", zArg);
rc = SQLITE_ERROR;
@ -508,11 +521,17 @@ static int fts5ConfigMakeExprlist(Fts5Config *p){
sqlite3Fts5BufferAppendPrintf(&rc, &buf, "T.%Q", p->zContentRowid);
if( p->eContent!=FTS5_CONTENT_NONE ){
assert( p->eContent==FTS5_CONTENT_EXTERNAL
|| p->eContent==FTS5_CONTENT_NORMAL
|| p->eContent==FTS5_CONTENT_UNINDEXED
);
for(i=0; i<p->nCol; i++){
if( p->eContent==FTS5_CONTENT_EXTERNAL ){
sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", T.%Q", p->azCol[i]);
}else{
}else if( p->eContent==FTS5_CONTENT_NORMAL || p->abUnindexed[i] ){
sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", T.c%d", i);
}else{
sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", NULL");
}
}
}
@ -555,6 +574,7 @@ int sqlite3Fts5ConfigParse(
Fts5Config *pRet; /* New object to return */
int i;
sqlite3_int64 nByte;
int bUnindexed = 0; /* True if there are one or more UNINDEXED */
*ppOut = pRet = (Fts5Config*)sqlite3_malloc(sizeof(Fts5Config));
if( pRet==0 ) return SQLITE_NOMEM;
@ -614,7 +634,7 @@ int sqlite3Fts5ConfigParse(
pzErr
);
}else{
rc = fts5ConfigParseColumn(pRet, zOne, zTwo, pzErr);
rc = fts5ConfigParseColumn(pRet, zOne, zTwo, pzErr, &bUnindexed);
zOne = 0;
}
}
@ -646,14 +666,30 @@ int sqlite3Fts5ConfigParse(
rc = SQLITE_ERROR;
}
/* We only allow contentless_unindexed=1 if the table is actually a
** contentless one.
*/
if( rc==SQLITE_OK
&& pRet->bContentlessUnindexed
&& pRet->eContent!=FTS5_CONTENT_NONE
){
*pzErr = sqlite3_mprintf(
"contentless_unindexed=1 requires a contentless table"
);
rc = SQLITE_ERROR;
}
/* If no zContent option was specified, fill in the default values. */
if( rc==SQLITE_OK && pRet->zContent==0 ){
const char *zTail = 0;
assert( pRet->eContent==FTS5_CONTENT_NORMAL
|| pRet->eContent==FTS5_CONTENT_NONE
assert( pRet->eContent==FTS5_CONTENT_NORMAL
|| pRet->eContent==FTS5_CONTENT_NONE
);
if( pRet->eContent==FTS5_CONTENT_NORMAL ){
zTail = "content";
}else if( bUnindexed && pRet->bContentlessUnindexed ){
pRet->eContent = FTS5_CONTENT_UNINDEXED;
zTail = "content";
}else if( pRet->bColumnsize ){
zTail = "docsize";
}

163
ext/fts5/fts5_main.c
View File

@ -332,10 +332,16 @@ static void fts5CheckTransactionState(Fts5FullTable *p, int op, int iSavepoint){
#endif
/*
** Return true if pTab is a contentless table.
** Return true if pTab is a contentless table. If parameter bIncludeUnindexed
** is true, this includes contentless tables that store UNINDEXED columns
** only.
*/
static int fts5IsContentless(Fts5FullTable *pTab){
return pTab->p.pConfig->eContent==FTS5_CONTENT_NONE;
static int fts5IsContentless(Fts5FullTable *pTab, int bIncludeUnindexed){
int eContent = pTab->p.pConfig->eContent;
return (
eContent==FTS5_CONTENT_NONE
|| (bIncludeUnindexed && eContent==FTS5_CONTENT_UNINDEXED)
);
}
/*
@ -1726,7 +1732,7 @@ static int fts5SpecialInsert(
}
bLoadConfig = 1;
}else if( 0==sqlite3_stricmp("rebuild", zCmd) ){
if( pConfig->eContent==FTS5_CONTENT_NONE ){
if( fts5IsContentless(pTab, 1) ){
fts5SetVtabError(pTab,
"'rebuild' may not be used with a contentless fts5 table"
);
@ -1795,7 +1801,7 @@ static void fts5StorageInsert(
){
int rc = *pRc;
if( rc==SQLITE_OK ){
rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, apVal, piRowid);
rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, 0, apVal, piRowid);
}
if( rc==SQLITE_OK ){
rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal, *piRowid);
@ -1803,6 +1809,67 @@ static void fts5StorageInsert(
*pRc = rc;
}
/*
**
** This function is called when the user attempts an UPDATE on a contentless
** table. Parameter bRowidModified is true if the UPDATE statement modifies
** the rowid value. Parameter apVal[] contains the new values for each user
** defined column of the fts5 table. pConfig is the configuration object of the
** table being updated (guaranteed to be contentless). The contentless_delete=1
** and contentless_unindexed=1 options may or may not be set.
**
** This function returns SQLITE_OK if the UPDATE can go ahead, or an SQLite
** error code if it cannot. In this case an error message is also loaded into
** pConfig. Output parameter (*pbContent) is set to true if the caller should
** update the %_content table only - not the FTS index or any other shadow
** table. This occurs when an UPDATE modifies only UNINDEXED columns of the
** table.
**
** An UPDATE may proceed if:
**
** * The only columns modified are UNINDEXED columns, or
**
** * The contentless_delete=1 option was specified and all of the indexed
** columns (not a subset) have been modified.
*/
static int fts5ContentlessUpdate(
Fts5Config *pConfig,
sqlite3_value **apVal,
int bRowidModified,
int *pbContent
){
int ii;
int bSeenIndex = 0; /* Have seen modified indexed column */
int bSeenIndexNC = 0; /* Have seen unmodified indexed column */
int rc = SQLITE_OK;
for(ii=0; ii<pConfig->nCol; ii++){
if( pConfig->abUnindexed[ii]==0 ){
if( sqlite3_value_nochange(apVal[ii]) ){
bSeenIndexNC++;
}else{
bSeenIndex++;
}
}
}
if( bSeenIndex==0 && bRowidModified==0 ){
*pbContent = 1;
}else{
if( bSeenIndexNC || pConfig->bContentlessDelete==0 ){
rc = SQLITE_ERROR;
sqlite3Fts5ConfigErrmsg(pConfig,
(pConfig->bContentlessDelete ?
"%s a subset of columns on fts5 contentless-delete table: %s" :
"%s contentless fts5 table: %s")
, "cannot UPDATE", pConfig->zName
);
}
}
return rc;
}
/*
** This function is the implementation of the xUpdate callback used by
** FTS3 virtual tables. It is invoked by SQLite each time a row is to be
@ -1889,25 +1956,20 @@ static int fts5UpdateMethod(
assert( eType0==SQLITE_INTEGER || eType0==SQLITE_NULL );
assert( nArg!=1 || eType0==SQLITE_INTEGER );
/* Filter out attempts to run UPDATE or DELETE on contentless tables.
** This is not suported. Except - they are both supported if the CREATE
** VIRTUAL TABLE statement contained "contentless_delete=1". */
if( eType0==SQLITE_INTEGER
&& pConfig->eContent==FTS5_CONTENT_NONE
&& pConfig->bContentlessDelete==0
){
pTab->p.base.zErrMsg = sqlite3_mprintf(
"cannot %s contentless fts5 table: %s",
(nArg>1 ? "UPDATE" : "DELETE from"), pConfig->zName
);
rc = SQLITE_ERROR;
}
/* DELETE */
else if( nArg==1 ){
i64 iDel = sqlite3_value_int64(apVal[0]); /* Rowid to delete */
rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, 0, 0);
bUpdateOrDelete = 1;
if( nArg==1 ){
/* It is only possible to DELETE from a contentless table if the
** contentless_delete=1 flag is set. */
if( fts5IsContentless(pTab, 1) && pConfig->bContentlessDelete==0 ){
fts5SetVtabError(pTab,
"cannot DELETE from contentless fts5 table: %s", pConfig->zName
);
rc = SQLITE_ERROR;
}else{
i64 iDel = sqlite3_value_int64(apVal[0]); /* Rowid to delete */
rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, 0, 0);
bUpdateOrDelete = 1;
}
}
/* INSERT or UPDATE */
@ -1941,35 +2003,55 @@ static int fts5UpdateMethod(
/* UPDATE */
else{
Fts5Storage *pStorage = pTab->pStorage;
i64 iOld = sqlite3_value_int64(apVal[0]); /* Old rowid */
i64 iNew = sqlite3_value_int64(apVal[1]); /* New rowid */
int bContent = 0; /* Content only update */
/* If this is a contentless table (including contentless_unindexed=1
** tables), check if the UPDATE may proceed. */
if( fts5IsContentless(pTab, 1) ){
rc = fts5ContentlessUpdate(pConfig, &apVal[2], iOld!=iNew, &bContent);
if( rc!=SQLITE_OK ) goto update_out;
}
if( eType1!=SQLITE_INTEGER ){
rc = SQLITE_MISMATCH;
}else if( iOld!=iNew ){
assert( bContent==0 );
if( eConflict==SQLITE_REPLACE ){
rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0, 1);
rc = sqlite3Fts5StorageDelete(pStorage, iOld, 0, 1);
if( rc==SQLITE_OK ){
rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0, 0);
rc = sqlite3Fts5StorageDelete(pStorage, iNew, 0, 0);
}
fts5StorageInsert(&rc, pTab, apVal, pRowid);
}else{
rc = sqlite3Fts5StorageFindDeleteRow(pTab->pStorage, iOld);
rc = sqlite3Fts5StorageFindDeleteRow(pStorage, iOld);
if( rc==SQLITE_OK ){
rc = sqlite3Fts5StorageContentInsert(pTab->pStorage,apVal,pRowid);
rc = sqlite3Fts5StorageContentInsert(pStorage, 0, apVal, pRowid);
}
if( rc==SQLITE_OK ){
rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0, 1);
rc = sqlite3Fts5StorageDelete(pStorage, iOld, 0, 0);
}
if( rc==SQLITE_OK ){
rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal,*pRowid);
rc = sqlite3Fts5StorageIndexInsert(pStorage, apVal, *pRowid);
}
}
}else if( bContent ){
/* This occurs when an UPDATE on a contentless table affects *only*
** UNINDEXED columns. This is a no-op for contentless_unindexed=0
** tables, or a write to the %_content table only for =1 tables. */
assert( fts5IsContentless(pTab, 1) );
rc = sqlite3Fts5StorageFindDeleteRow(pStorage, iOld);
if( rc==SQLITE_OK ){
rc = sqlite3Fts5StorageContentInsert(pStorage, 1, apVal, pRowid);
}
}else{
rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0, 1);
rc = sqlite3Fts5StorageDelete(pStorage, iOld, 0, 1);
fts5StorageInsert(&rc, pTab, apVal, pRowid);
}
bUpdateOrDelete = 1;
sqlite3Fts5StorageReleaseDeleteRow(pTab->pStorage);
sqlite3Fts5StorageReleaseDeleteRow(pStorage);
}
}
@ -2170,7 +2252,7 @@ static int fts5ApiColumnText(
assert( pCsr->ePlan!=FTS5_PLAN_SPECIAL );
if( iCol<0 || iCol>=pTab->pConfig->nCol ){
rc = SQLITE_RANGE;
}else if( fts5IsContentless((Fts5FullTable*)(pCsr->base.pVtab)) ){
}else if( fts5IsContentless((Fts5FullTable*)(pCsr->base.pVtab), 0) ){
*pz = 0;
*pn = 0;
}else{
@ -2203,7 +2285,7 @@ static int fts5CsrPoslist(
if( iPhrase<0 || iPhrase>=sqlite3Fts5ExprPhraseCount(pCsr->pExpr) ){
rc = SQLITE_RANGE;
}else if( pConfig->eDetail!=FTS5_DETAIL_FULL
&& pConfig->eContent==FTS5_CONTENT_NONE
&& fts5IsContentless((Fts5FullTable*)pCsr->base.pVtab, 1)
){
*pa = 0;
*pn = 0;
@ -2399,7 +2481,7 @@ static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
if( pConfig->bColumnsize ){
i64 iRowid = fts5CursorRowid(pCsr);
rc = sqlite3Fts5StorageDocsize(pTab->pStorage, iRowid, pCsr->aColumnSize);
}else if( pConfig->zContent==0 ){
}else if( !pConfig->zContent || pConfig->eContent==FTS5_CONTENT_UNINDEXED ){
int i;
for(i=0; i<pConfig->nCol; i++){
if( pConfig->abUnindexed[i]==0 ){
@ -2687,7 +2769,7 @@ static int fts5ApiColumnLocale(
rc = SQLITE_RANGE;
}else if(
pConfig->abUnindexed[iCol]==0
&& pConfig->eContent!=FTS5_CONTENT_NONE
&& 0==fts5IsContentless((Fts5FullTable*)pCsr->base.pVtab, 1)
&& pConfig->bLocale
){
rc = fts5SeekCursor(pCsr, 0);
@ -2962,16 +3044,7 @@ static int fts5ColumnMethod(
}
}
}else{
/* A column created by the user containing values. */
int bNochange = sqlite3_vtab_nochange(pCtx);
if( fts5IsContentless(pTab) ){
if( bNochange && pConfig->bContentlessDelete ){
fts5ResultError(pCtx, "cannot UPDATE a subset of "
"columns on fts5 contentless-delete table: %s", pConfig->zName
);
}
}else if( bNochange==0 || pConfig->eContent!=FTS5_CONTENT_NORMAL ){
if( !sqlite3_vtab_nochange(pCtx) && pConfig->eContent!=FTS5_CONTENT_NONE ){
pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
rc = fts5SeekCursor(pCsr, 1);
if( rc==SQLITE_OK ){

161
ext/fts5/fts5_storage.c
View File

@ -73,30 +73,6 @@ struct Fts5Storage {
#define FTS5_STMT_REPLACE_CONFIG 10
#define FTS5_STMT_SCAN 11
/*
** Return a pointer to a buffer obtained from sqlite3_malloc() that contains
** nBind comma-separated question marks. e.g. if nBind is passed 5, this
** function returns "?,?,?,?,?".
**
** If *pRc is not SQLITE_OK when this function is called, it is a no-op and
** NULL is returned immediately. Or, if the attempt to malloc a buffer
** fails, then *pRc is set to SQLITE_NOMEM and NULL is returned. Otherwise,
** if it is SQLITE_OK when this function is called and the malloc() succeeds,
** *pRc is left unchanged.
*/
static char *fts5BindingsList(int *pRc, int nBind){
char *zBind = sqlite3Fts5MallocZero(pRc, 1 + nBind*2);
if( zBind ){
int ii;
for(ii=0; ii<nBind; ii++){
zBind[ii*2] = '?';
zBind[ii*2 + 1] = ',';
}
zBind[ii*2-1] = '\0';
}
return zBind;
}
/*
** Prepare the two insert statements - Fts5Storage.pInsertContent and
** Fts5Storage.pInsertDocsize - if they have not already been prepared.
@ -165,23 +141,37 @@ static int fts5StorageGetStmt(
);
break;
case FTS5_STMT_INSERT_CONTENT: {
int nCol = 0;
char *zBind;
case FTS5_STMT_INSERT_CONTENT:
case FTS5_STMT_REPLACE_CONTENT: {
char *zBind = 0;
int i;
nCol = 1 + pC->nCol;
if( pC->bLocale ){
for(i=0; i<pC->nCol; i++){
if( pC->abUnindexed[i]==0 ) nCol++;
assert( pC->eContent==FTS5_CONTENT_NORMAL
|| pC->eContent==FTS5_CONTENT_UNINDEXED
);
/* Add bindings for the "c*" columns - those that store the actual
** table content. If eContent==NORMAL, then there is one binding
** for each column. Or, if eContent==UNINDEXED, then there are only
** bindings for the UNINDEXED columns. */
for(i=0; rc==SQLITE_OK && i<(pC->nCol+1); i++){
if( !i || pC->eContent==FTS5_CONTENT_NORMAL || pC->abUnindexed[i-1] ){
zBind = sqlite3Fts5Mprintf(&rc, "%z%s?%d", zBind, zBind?",":"",i+1);
}
}
zBind = fts5BindingsList(&rc, nCol);
if( zBind ){
zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
sqlite3_free(zBind);
/* Add bindings for any "l*" columns. Only non-UNINDEXED columns
** require these. */
if( pC->bLocale && pC->eContent==FTS5_CONTENT_NORMAL ){
for(i=0; rc==SQLITE_OK && i<pC->nCol; i++){
if( pC->abUnindexed[i]==0 ){
zBind = sqlite3Fts5Mprintf(&rc, "%z,?%d", zBind, pC->nCol+i+2);
}
}
}
zSql = sqlite3Fts5Mprintf(&rc, azStmt[eStmt], pC->zDb, pC->zName,zBind);
sqlite3_free(zBind);
break;
}
@ -367,7 +357,9 @@ int sqlite3Fts5StorageOpen(
p->pIndex = pIndex;
if( bCreate ){
if( pConfig->eContent==FTS5_CONTENT_NORMAL ){
if( pConfig->eContent==FTS5_CONTENT_NORMAL
|| pConfig->eContent==FTS5_CONTENT_UNINDEXED
){
int nDefn = 32 + pConfig->nCol*10;
char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 20);
if( zDefn==0 ){
@ -378,8 +370,12 @@ int sqlite3Fts5StorageOpen(
sqlite3_snprintf(nDefn, zDefn, "id INTEGER PRIMARY KEY");
iOff = (int)strlen(zDefn);
for(i=0; i<pConfig->nCol; i++){
sqlite3_snprintf(nDefn-iOff, &zDefn[iOff], ", c%d", i);
iOff += (int)strlen(&zDefn[iOff]);
if( pConfig->eContent==FTS5_CONTENT_NORMAL
|| pConfig->abUnindexed[i]
){
sqlite3_snprintf(nDefn-iOff, &zDefn[iOff], ", c%d", i);
iOff += (int)strlen(&zDefn[iOff]);
}
}
if( pConfig->bLocale ){
for(i=0; i<pConfig->nCol; i++){
@ -617,7 +613,9 @@ static int fts5StorageContentlessDelete(Fts5Storage *p, i64 iDel){
int rc = SQLITE_OK;
assert( p->pConfig->bContentlessDelete );
assert( p->pConfig->eContent==FTS5_CONTENT_NONE );
assert( p->pConfig->eContent==FTS5_CONTENT_NONE
|| p->pConfig->eContent==FTS5_CONTENT_UNINDEXED
);
/* Look up the origin of the document in the %_docsize table. Store
** this in stack variable iOrigin. */
@ -741,6 +739,12 @@ int sqlite3Fts5StorageDelete(
if( rc==SQLITE_OK ){
if( p->pConfig->bContentlessDelete ){
rc = fts5StorageContentlessDelete(p, iDel);
if( rc==SQLITE_OK
&& bSaveRow
&& p->pConfig->eContent==FTS5_CONTENT_UNINDEXED
){
rc = sqlite3Fts5StorageFindDeleteRow(p, iDel);
}
}else{
rc = fts5StorageDeleteFromIndex(p, iDel, apVal, bSaveRow);
}
@ -757,7 +761,9 @@ int sqlite3Fts5StorageDelete(
}
/* Delete the %_content record */
if( pConfig->eContent==FTS5_CONTENT_NORMAL ){
if( pConfig->eContent==FTS5_CONTENT_NORMAL
|| pConfig->eContent==FTS5_CONTENT_UNINDEXED
){
if( rc==SQLITE_OK ){
rc = fts5StorageGetStmt(p, FTS5_STMT_DELETE_CONTENT, &pDel, 0);
}
@ -789,8 +795,13 @@ int sqlite3Fts5StorageDeleteAll(Fts5Storage *p){
);
if( rc==SQLITE_OK && pConfig->bColumnsize ){
rc = fts5ExecPrintf(pConfig->db, 0,
"DELETE FROM %Q.'%q_docsize';",
pConfig->zDb, pConfig->zName
"DELETE FROM %Q.'%q_docsize';", pConfig->zDb, pConfig->zName
);
}
if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_UNINDEXED ){
rc = fts5ExecPrintf(pConfig->db, 0,
"DELETE FROM %Q.'%q_content';", pConfig->zDb, pConfig->zName
);
}
@ -926,6 +937,7 @@ static int fts5StorageNewRowid(Fts5Storage *p, i64 *piRowid){
*/
int sqlite3Fts5StorageContentInsert(
Fts5Storage *p,
int bReplace, /* True to use REPLACE instead of INSERT */
sqlite3_value **apVal,
i64 *piRowid
){
@ -933,7 +945,9 @@ int sqlite3Fts5StorageContentInsert(
int rc = SQLITE_OK;
/* Insert the new row into the %_content table. */
if( pConfig->eContent!=FTS5_CONTENT_NORMAL ){
if( pConfig->eContent!=FTS5_CONTENT_NORMAL
&& pConfig->eContent!=FTS5_CONTENT_UNINDEXED
){
if( sqlite3_value_type(apVal[1])==SQLITE_INTEGER ){
*piRowid = sqlite3_value_int64(apVal[1]);
}else{
@ -942,8 +956,10 @@ int sqlite3Fts5StorageContentInsert(
}else{
sqlite3_stmt *pInsert = 0; /* Statement to write %_content table */
int i; /* Counter variable */
int nIndexed = 0; /* Number indexed columns seen */
rc = fts5StorageGetStmt(p, FTS5_STMT_INSERT_CONTENT, &pInsert, 0);
assert( FTS5_STMT_INSERT_CONTENT+1==FTS5_STMT_REPLACE_CONTENT );
assert( bReplace==0 || bReplace==1 );
rc = fts5StorageGetStmt(p, FTS5_STMT_INSERT_CONTENT+bReplace, &pInsert, 0);
if( pInsert ) sqlite3_clear_bindings(pInsert);
/* Bind the rowid value */
@ -953,38 +969,39 @@ int sqlite3Fts5StorageContentInsert(
** user-defined column. As is column 1 of pSavedRow. */
for(i=2; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
int bUnindexed = pConfig->abUnindexed[i-2];
sqlite3_value *pVal = apVal[i];
if( pConfig->eContent==FTS5_CONTENT_NORMAL || bUnindexed ){
sqlite3_value *pVal = apVal[i];
nIndexed += !bUnindexed;
if( sqlite3_value_nochange(pVal) && p->pSavedRow ){
/* This is an UPDATE statement, and column (i-2) was not modified.
** Retrieve the value from Fts5Storage.pSavedRow instead. */
pVal = sqlite3_column_value(p->pSavedRow, i-1);
if( pConfig->bLocale && bUnindexed==0 ){
sqlite3_bind_value(pInsert, pConfig->nCol + 1 + nIndexed,
sqlite3_column_value(p->pSavedRow, pConfig->nCol + i - 1)
);
}
}else if( sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
const char *pText = 0;
const char *pLoc = 0;
int nText = 0;
int nLoc = 0;
assert( pConfig->bLocale );
rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
if( rc==SQLITE_OK ){
sqlite3_bind_text(pInsert, i, pText, nText, SQLITE_TRANSIENT);
if( bUnindexed==0 ){
int iLoc = pConfig->nCol + 1 + nIndexed;
sqlite3_bind_text(pInsert, iLoc, pLoc, nLoc, SQLITE_TRANSIENT);
if( sqlite3_value_nochange(pVal) && p->pSavedRow ){
/* This is an UPDATE statement, and user-defined column (i-2) was not
** modified. Retrieve the value from Fts5Storage.pSavedRow. */
pVal = sqlite3_column_value(p->pSavedRow, i-1);
if( pConfig->bLocale && bUnindexed==0 ){
sqlite3_bind_value(pInsert, pConfig->nCol + i,
sqlite3_column_value(p->pSavedRow, pConfig->nCol + i - 1)
);
}
}else if( sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
const char *pText = 0;
const char *pLoc = 0;
int nText = 0;
int nLoc = 0;
assert( pConfig->bLocale );
rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
if( rc==SQLITE_OK ){
sqlite3_bind_text(pInsert, i, pText, nText, SQLITE_TRANSIENT);
if( bUnindexed==0 ){
int iLoc = pConfig->nCol + i;
sqlite3_bind_text(pInsert, iLoc, pLoc, nLoc, SQLITE_TRANSIENT);
}
}
continue;
}
continue;
rc = sqlite3_bind_value(pInsert, i, pVal);
}
rc = sqlite3_bind_value(pInsert, i, pVal);
}
if( rc==SQLITE_OK ){
sqlite3_step(pInsert);

52
ext/fts5/test/fts5delete.test
View File

@ -113,5 +113,57 @@ do_execsql_test 3.4 {
INSERT INTO tx(tx) VALUES('integrity-check');
}
#-------------------------------------------------------------------------
reset_db
do_execsql_test 4.0 {
CREATE VIRTUAL TABLE ft1 USING fts5(a, b UNINDEXED,
content='', contentless_unindexed=1
);
CREATE VIRTUAL TABLE ft2 USING fts5(a, b UNINDEXED,
content='', contentless_unindexed=1, contentless_delete=1
);
INSERT INTO ft1(rowid, a, b) VALUES(1, 'one', 'i');
INSERT INTO ft1(rowid, a, b) VALUES(2, 'two', 'ii');
INSERT INTO ft1(rowid, a, b) VALUES(3, 'three', 'iii');
INSERT INTO ft2(rowid, a, b) VALUES(1, 'one', 'i');
INSERT INTO ft2(rowid, a, b) VALUES(2, 'two', 'ii');
INSERT INTO ft2(rowid, a, b) VALUES(3, 'three', 'iii');
}
do_catchsql_test 4.1 {
DELETE FROM ft1 WHERE rowid=2
} {1 {cannot DELETE from contentless fts5 table: ft1}}
do_catchsql_test 4.2 {
DELETE FROM ft2 WHERE rowid=2
} {0 {}}
do_catchsql_test 4.3 {
INSERT INTO ft1(ft1, rowid, a) VALUES('delete', 2, 'two');
} {0 {}}
do_catchsql_test 4.2 {
INSERT INTO ft2(ft2, rowid, a) VALUES('delete', 2, 'two');
} {1 {'delete' may not be used with a contentless_delete=1 table}}
do_execsql_test 4.3 {
SELECT rowid, * FROM ft1;
} {
1 {} i
3 {} iii
}
do_execsql_test 4.4 {
SELECT rowid, * FROM ft2;
} {
1 {} i
3 {} iii
}
do_execsql_test 4.5 {
SELECT * FROM ft1_content
} {1 i 3 iii}
do_execsql_test 4.6 {
SELECT * FROM ft1_content
} {1 i 3 iii}
finish_test

297
ext/fts5/test/fts5unindexed2.test Normal file
View File

@ -0,0 +1,297 @@
# 2024 Sep 13
#
# The author disclaims copyright to this source code. In place of
# a legal notice, here is a blessing:
#
# May you do good and not evil.
# May you find forgiveness for yourself and forgive others.
# May you share freely, never taking more than you give.
#
#***********************************************************************
#
# The tests in this file focus on "unindexed" columns in contentless
# tables.
#
source [file join [file dirname [info script]] fts5_common.tcl]
set testprefix fts5unindexed2
# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
ifcapable !fts5 {
finish_test
return
}
do_execsql_test 1.1 {
CREATE VIRTUAL TABLE t1 USING fts5(
a, b UNINDEXED, content=, contentless_unindexed=1
);
} {}
do_execsql_test 1.2 {
INSERT INTO t1 VALUES('abc def', 'ghi jkl');
}
do_execsql_test 1.3 {
SELECT rowid, a, b FROM t1
} {1 {} {ghi jkl}}
do_execsql_test 1.4 {
INSERT INTO t1(rowid, a, b) VALUES(11, 'hello world', 'one two three');
}
do_execsql_test 1.5 {
INSERT INTO t1(t1, rowid, a, b) VALUES('delete', 1, 'abc def', 'ghi jkl');
}
do_execsql_test 1.6 {
SELECT rowid, a, b FROM t1
} {
11 {} {one two three}
}
do_execsql_test 1.7 {
PRAGMA integrity_check
} {ok}
do_execsql_test 1.8 {
INSERT INTO t1(rowid, a, b) VALUES(12, 'abc def', 'ghi jkl');
}
do_execsql_test 1.9 {
SELECT rowid, a, b FROM t1('def')
} {12 {} {ghi jkl}}
do_execsql_test 1.10 {
SELECT rowid, a, b FROM t1('def OR hello') ORDER BY rank
} {11 {} {one two three} 12 {} {ghi jkl}}
do_execsql_test 1.11 {
SELECT rowid, a, b FROM t1 WHERE rowid=11
} {11 {} {one two three}}
do_execsql_test 1.12 {
SELECT rowid, a, b FROM t1
} {11 {} {one two three} 12 {} {ghi jkl}}
fts5_aux_test_functions db
do_execsql_test 1.12.2 {
SELECT rowid, fts5_test_columntext(t1) FROM t1('def OR hello')
} {11 {{} {one two three}} 12 {{} {ghi jkl}}}
do_execsql_test 1.13 {
INSERT INTO t1(t1) VALUES('delete-all');
}
do_execsql_test 1.14 {
SELECT rowid, a, b FROM t1
}
do_execsql_test 1.15 {
PRAGMA integrity_check
} {ok}
do_execsql_test 2.0 {
CREATE VIRTUAL TABLE t4 USING fts5(
x, y UNINDEXED, z, columnsize=0, content='', contentless_unindexed=1
);
}
do_execsql_test 2.1 {
INSERT INTO t4(rowid, x, y, z) VALUES(1, 'a a', 'b b b', 'c');
}
#-------------------------------------------------------------------------
reset_db
do_execsql_test 3.0 {
CREATE VIRTUAL TABLE x1 USING fts5(
a UNINDEXED, b, c UNINDEXED, d, content=, contentless_delete=1,
contentless_unindexed=1
);
}
do_execsql_test 3.1 {
INSERT INTO x1(rowid, a, b, c, d) VALUES(131, 'aaa', 'bbb', 'ccc', 'ddd');
}
do_execsql_test 3.2 {
SELECT * FROM x1
} {aaa {} ccc {}}
do_execsql_test 3.3 {
INSERT INTO x1(rowid, a, b, c, d) VALUES(1000, 'AAA', 'BBB', 'CCC', 'DDD');
}
do_execsql_test 3.4 {
SELECT rowid, * FROM x1
} {
131 aaa {} ccc {}
1000 AAA {} CCC {}
}
do_execsql_test 3.5 {
DELETE FROM x1 WHERE rowid=131;
SELECT rowid, * FROM x1
} {
1000 AAA {} CCC {}
}
do_execsql_test 3.6 {
INSERT INTO x1(rowid, a, b, c, d) VALUES(112, 'aaa', 'bbb', 'ccc', 'ddd');
SELECT rowid, * FROM x1
} {
112 aaa {} ccc {}
1000 AAA {} CCC {}
}
do_execsql_test 3.7 {
UPDATE x1 SET b='hello', d='world', rowid=1120 WHERE rowid=112
}
do_execsql_test 3.8 {
SELECT rowid, * FROM x1
} {
1000 AAA {} CCC {}
1120 aaa {} ccc {}
}
do_execsql_test 3.9 {
SELECT rowid, * FROM x1('hello');
} {
1120 aaa {} ccc {}
}
do_execsql_test 3.9 {
SELECT rowid, * FROM x1('bbb');
} {
1000 AAA {} CCC {}
}
fts5_aux_test_functions db
do_execsql_test 3.10 {
SELECT rowid, fts5_test_columntext(x1) FROM x1('b*')
} {1000 {AAA {} CCC {}}}
#-------------------------------------------------------------------------
# Check that if contentless_unindexed=1 is not specified, the values
# of UNINDEXED columns are not stored in the database.
#
# Also check that contentless_unindexed=1 is not allowed unless the table
# is actually contentless.
#
reset_db
do_execsql_test 4.0 {
CREATE VIRTUAL TABLE ft USING fts5(a, b, c UNINDEXED, content='');
INSERT INTO ft VALUES('one', 'two', 'three');
SELECT rowid, * FROM ft;
} {1 {} {} {}}
do_execsql_test 4.1 {
SELECT name FROM sqlite_schema ORDER BY 1
} {
ft ft_config ft_data ft_docsize ft_idx
}
do_catchsql_test 4.2 {
CREATE VIRTUAL TABLE ft2 USING fts5(
a, b, c UNINDEXED, contentless_unindexed=1
);
} {1 {contentless_unindexed=1 requires a contentless table}}
do_catchsql_test 4.3 {
DELETE FROM ft WHERE rowid=1
} {1 {cannot DELETE from contentless fts5 table: ft}}
#-------------------------------------------------------------------------
# Check that the usual restrictions on contentless tables apply to
# contentless_unindexed=1 tables.
#
reset_db
do_execsql_test 5.0 {
CREATE VIRTUAL TABLE ft USING fts5(
a, b UNINDEXED, c, content='', contentless_unindexed=1
);
INSERT INTO ft VALUES('one', 'two', 'three');
INSERT INTO ft VALUES('four', 'five', 'six');
INSERT INTO ft VALUES('seven', 'eight', 'nine');
SELECT rowid, * FROM ft;
} {
1 {} two {}
2 {} five {}
3 {} eight {}
}
do_execsql_test 5.1 {
PRAGMA integrity_check
} {ok}
do_catchsql_test 5.2 {
DELETE FROM ft WHERE rowid=2
} {1 {cannot DELETE from contentless fts5 table: ft}}
do_execsql_test 5.3 {
SELECT rowid, * FROM ft('six')
} {
2 {} five {}
}
do_catchsql_test 5.4 {
UPDATE ft SET a='x', b='y', c='z' WHERE rowid=3
} {1 {cannot UPDATE contentless fts5 table: ft}}
fts5_aux_test_functions db
do_execsql_test 5.5 {
SELECT fts5_test_columntext(ft) FROM ft WHERE rowid=3
} {
{{} eight {}}
}
do_execsql_test 5.6 {
SELECT fts5_test_columntext(ft) FROM ft('three');
} {
{{} two {}}
}
#-------------------------------------------------------------------------
# Check that it is possible to UPDATE a contentless_unindexed=1 table
# if the only columns being modified are UNINDEXED.
#
# If the contentless_unindexed=1 table is also contentless_delete=1, then
# it is also possible to update indexed columns - but only if *all* indexed
# columns are updated.
#
reset_db
do_execsql_test 6.0 {
CREATE VIRTUAL TABLE ft1 USING fts5(a, b UNINDEXED, c UNINDEXED, d,
contentless_unindexed=1, content=''
);
INSERT INTO ft1(rowid, a, b, c, d) VALUES
(100, 'x y', 'b1', 'c1', 'a b'),
(200, 'c d', 'b2', 'c2', 'a b'),
(300, 'e f', 'b3', 'c3', 'a b');
}
do_execsql_test 6.1 {
UPDATE ft1 SET b='b1.1', c='c1.1' WHERE rowid=100;
}
do_execsql_test 6.2 {
UPDATE ft1 SET b='b2.1' WHERE rowid=200;
}
do_execsql_test 6.3 {
UPDATE ft1 SET c='c3.1' WHERE rowid=300;
}
do_execsql_test 6.4 {
SELECT rowid, a, b, c, d FROM ft1
} {
100 {} b1.1 c1.1 {}
200 {} b2.1 c2 {}
300 {} b3 c3.1 {}
}
finish_test

177
ext/fts5/test/fts5update2.test Normal file
View File

@ -0,0 +1,177 @@
# 2024 Sep 27
#
# The author disclaims copyright to this source code. In place of
# a legal notice, here is a blessing:
#
# May you do good and not evil.
# May you find forgiveness for yourself and forgive others.
# May you share freely, never taking more than you give.
#
#*************************************************************************
# This file implements regression tests for SQLite library. The
# focus of this script is testing the FTS5 module.
#
source [file join [file dirname [info script]] fts5_common.tcl]
set testprefix fts5update2
# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
ifcapable !fts5 {
finish_test
return
}
#-------------------------------------------------------------------------
# Test that the various types of UPDATE statement are handled correctly
# by different table types.
#
foreach_detail_mode $testprefix {
foreach {tn cu} {
1 0
2 1
} {
reset_db
do_execsql_test 1.$tn.1 "
CREATE VIRTUAL TABLE ft1 USING fts5(a, b UNINDEXED, c UNINDEXED, d,
content='',
contentless_unindexed=$cu,
detail=%DETAIL%
);
CREATE VIRTUAL TABLE ft2 USING fts5(a, b UNINDEXED, c UNINDEXED, d,
content='',
contentless_unindexed=$cu, contentless_delete=1,
detail=%DETAIL%
);
"
do_execsql_test 1.$tn.2 {
INSERT INTO ft1(rowid, a, b, c, d) VALUES(1, 'a1', 'b1', 'c1', 'd1');
INSERT INTO ft1(rowid, a, b, c, d) VALUES(2, 'a2', 'b2', 'c2', 'd2');
INSERT INTO ft1(rowid, a, b, c, d) VALUES(3, 'a3', 'b3', 'c3', 'd3');
INSERT INTO ft2(rowid, a, b, c, d) VALUES(1, 'a1', 'b1', 'c1', 'd1');
INSERT INTO ft2(rowid, a, b, c, d) VALUES(2, 'a2', 'b2', 'c2', 'd2');
INSERT INTO ft2(rowid, a, b, c, d) VALUES(3, 'a3', 'b3', 'c3', 'd3');
}
# It should be possible to update a subset of the UNINDEXED columns of
# a contentless table. Regardless of whether or not contentless_unindexed=1
# or contentless_delete=1 is set.
do_execsql_test 1.$tn.3 {
UPDATE ft1 SET b=b||'.1';
UPDATE ft2 SET b=b||'.1';
}
do_execsql_test 1.$tn.4 {
UPDATE ft1 SET b=b||'.2', c=c||'.2';
UPDATE ft2 SET b=b||'.2', c=c||'.2';
}
set res(0) {
1 {} {} {} {}
2 {} {} {} {}
3 {} {} {} {}
}
set res(1) {
1 {} b1.1.2 c1.2 {}
2 {} b2.1.2 c2.2 {}
3 {} b3.1.2 c3.2 {}
}
do_execsql_test 1.$tn.5 {
SELECT rowid, * FROM ft2
} $res($cu)
do_execsql_test 1.6.1 { SELECT rowid FROM ft1('a2') } {2}
do_execsql_test 1.6.2 { SELECT rowid FROM ft2('a2') } {2}
# It should be possible to update all indexed columns (but no other subset)
# if the contentless_delete=1 option is set, as it is for "ft2".
do_execsql_test 1.$tn.7 {
UPDATE ft2 SET a='a22', d='d22' WHERE rowid=2;
}
do_execsql_test 1.$tn.8 { SELECT rowid FROM ft2('a22 AND d22') } {2}
do_execsql_test 1.$tn.9 {
UPDATE ft2 SET a='a33', d='d33', b='b3' WHERE rowid=3;
}
set res(1) {
1 {} b1.1.2 c1.2 {}
2 {} b2.1.2 c2.2 {}
3 {} b3 c3.2 {}
}
do_execsql_test 1.$tn.10 {
SELECT rowid, * FROM ft2
} $res($cu)
do_catchsql_test 1.$tn.11 {
UPDATE ft2 SET a='a11' WHERE rowid=1
} {1 {cannot UPDATE a subset of columns on fts5 contentless-delete table: ft2}}
do_catchsql_test 1.$tn.12 {
UPDATE ft2 SET d='d11' WHERE rowid=1
} {1 {cannot UPDATE a subset of columns on fts5 contentless-delete table: ft2}}
# It is not possible to update the values of indexed columns if
# contentless_delete=1 is not set.
do_catchsql_test 1.$tn.13 {
UPDATE ft1 SET a='a11' WHERE rowid=1
} {1 {cannot UPDATE contentless fts5 table: ft1}}
do_catchsql_test 1.$tn.14 {
UPDATE ft1 SET d='d11' WHERE rowid=1
} {1 {cannot UPDATE contentless fts5 table: ft1}}
# It should be possible to update the rowid if contentless_delete=1 is
# set and all indexed columns are updated.
do_execsql_test 1.$tn.15 {
UPDATE ft2 SET a='aXone', d='dXone', rowid=11 WHERE rowid=1
}
set res(0) {
2 {} {} {} {}
3 {} {} {} {}
11 {} {} {} {}
}
set res(1) {
2 {} b2.1.2 c2.2 {}
3 {} b3 c3.2 {}
11 {} b1.1.2 c1.2 {}
}
do_execsql_test 1.$tn.16 {
SELECT rowid, * FROM ft2
} $res($cu)
# Should not be possible to update the rowid of a contentless_delete=1
# table if no indexed columns are updated.
do_catchsql_test 1.$tn.17 {
UPDATE ft2 SET rowid=12 WHERE rowid=11
} {1 {cannot UPDATE a subset of columns on fts5 contentless-delete table: ft2}}
do_catchsql_test 1.$tn.18 {
UPDATE ft1 SET rowid=12 WHERE rowid=1
} {1 {cannot UPDATE contentless fts5 table: ft1}}
do_execsql_test 1.$tn.19 {
UPDATE ft2 SET a='aXtwo', d='dXtwo', c='newval', rowid=12 WHERE rowid=2
} {}
set res(0) {
3 {} {} {} {}
11 {} {} {} {}
12 {} {} {} {}
}
set res(1) {
3 {} b3 c3.2 {}
11 {} b1.1.2 c1.2 {}
12 {} b2.1.2 newval {}
}
do_execsql_test 1.$tn.20 {
SELECT rowid, * FROM ft2
} $res($cu)
do_execsql_test 1.$tn.21 {
SELECT rowid, * FROM ft2('aXtwo AND dXtwo')
} [lrange $res($cu) 10 end]
}} ;# end of [foreach_detail_mode] loop
finish_test

25
manifest
View File

@ -1,5 +1,5 @@
C Adjust\sthe\snew\struncation\sbehavior\sof\ssqlite_dbpage(N,null)\ssuch\sthat\sit\scauses\nthe\sdatabase\sto\sbe\struncated\sto\sN-1\spages.\s\sThis\smakes\smore\ssince.\s\sAn\serror\sis\nraised\sif\sN\sis\sless\sthan\s2.
D 2024-10-02T16:55:27.051
C Add\sthe\scontentless_unindexed=1\soption\sto\sfts5.\sThis\scauses\sthe\svalues\sof\sany\sUNINDEXED\scolumns\sof\sa\scontentless\sfts5\stable\sto\sbe\sstored\spersistently\sin\sthe\sdatabase.
D 2024-10-02T17:04:30.788
F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1
F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea
F LICENSE.md df5091916dbb40e6e9686186587125e1b2ff51f022cc334e886c19a0e9982724
@ -93,15 +93,15 @@ F ext/fts3/unicode/mkunicode.tcl 63db9624ccf70d4887836c320eda93ab552f21008f3be7e
F ext/fts3/unicode/parseunicode.tcl a981bd6466d12dd17967515801c3ff23f74a281be1a03cf1e6f52a6959fc77eb
F ext/fts5/extract_api_docs.tcl 009cf59c77afa86d137b0cca3e3b1a5efbe2264faa2df233f9a7aa8563926d15
F ext/fts5/fts5.h efaaac0df3d3bc740383044c144b582f47921aafa21d7b10eb98f42c24c740b0
F ext/fts5/fts5Int.h 93aba03ca417f403b07b2ab6f50aa0e0c1b8b031917a9026b81520e7047a168e
F ext/fts5/fts5Int.h bf0d3efa144f36e00f9b5206626aec2f436f58186a0835092394f2202e9828e3
F ext/fts5/fts5_aux.c 65a0468dd177d6093aa9ae1622e6d86b0136b8d267c62c0ad6493ad1e9a3d759
F ext/fts5/fts5_buffer.c 0eec58bff585f1a44ea9147eae5da2447292080ea435957f7488c70673cb6f09
F ext/fts5/fts5_config.c da21548ddbc1a457cb42545f527065221ede8ada6a734891b8c34317a7a9506b
F ext/fts5/fts5_config.c a6633d88596758941c625b526075b85d3d9fd1089d8d9eab5db6e8a71fd347ad
F ext/fts5/fts5_expr.c 9a56f53700d1860f0ee2f373c2b9074eaf2a7aa0637d0e27a6476de26a3fee33
F ext/fts5/fts5_hash.c adda4272be401566a6e0ba1acbe70ee5cb97fce944bc2e04dc707152a0ec91b1
F ext/fts5/fts5_index.c 368a968570ce12ba40223e284a588d9f93ee23a0133727f0df1fcd64086b1fb6
F ext/fts5/fts5_main.c 4503498d3453e29a3cd89dacaba029011e89cb8c481a6241611d106e7a369bd4
F ext/fts5/fts5_storage.c 3332497823c3d171cf56379f2bd8c971ce15a19aadacff961106462022c92470
F ext/fts5/fts5_main.c 50eb059e51d730e8e0c77df4e568b018079e112a755c094488b0d5b1aa06afbb
F ext/fts5/fts5_storage.c 337b05e4c66fc822d031e264d65bde807ec2fab08665ca2cc8aaf9c5fa06792c
F ext/fts5/fts5_tcl.c 4db9258a7882c5eac0da4433042132aaf15b87dd1e1636c7a6ca203abd2c8bfe
F ext/fts5/fts5_test_mi.c 08c11ec968148d4cb4119d96d819f8c1f329812c568bac3684f5464be177d3ee
F ext/fts5/fts5_test_tok.c 3cb0a9b508b30d17ef025ccddd26ae3dc8ddffbe76c057616e59a9aa85d36f3b
@ -154,7 +154,7 @@ F ext/fts5/test/fts5corrupt5.test 11b47126f5772cc37b67e3e8b2ed05895c4d07c05338bc
F ext/fts5/test/fts5corrupt6.test 2d72db743db7b5d9c9a6d0cfef24d799ed1aa5e8192b66c40e871a37ed9eed06
F ext/fts5/test/fts5corrupt7.test 4e830875c33b9ea3c4cf1ba71e692b63893cbb4faae8c69b1071889dc26e211c
F ext/fts5/test/fts5corrupt8.test b81d802e41631e98100f49a1aadeeffef860e30a62d6ed7d743c2797c477239e
F ext/fts5/test/fts5delete.test 619295b20dbc1d840b403ee07c878f52378849c3c02e44f2ee143b3e978a0aa7
F ext/fts5/test/fts5delete.test e5ad73ce7cda1201b15ead1170f0bc6a2402107b4c2b4e8c8d38c3c7a5140739
F ext/fts5/test/fts5detail.test 54015e9c43ec4ba542cfb93268abdf280e0300f350efd08ee411284b03595cc4
F ext/fts5/test/fts5determin.test 1b77879b2ae818b5b71c859e534ee334dac088b7cf3ff3bf76a2c82b1c788d11
F ext/fts5/test/fts5dlidx.test a7c42b0a74dc7c8aa1a46d586e0aadda4b6cc42c24450f8d3774b21166e93159
@ -246,7 +246,9 @@ F ext/fts5/test/fts5unicode2.test 3bbd30152f9f760bf13886e5b1e5ec23ff62f56758ddda
F ext/fts5/test/fts5unicode3.test f4891a3dac3b49c3d7c0fdb29566e9eb0ecff35263370c89f9661b1952b20818
F ext/fts5/test/fts5unicode4.test 728c8f0caafb05567f524ad313d9f8b780fa45987b8a8df04eff87923c74b4d0
F ext/fts5/test/fts5unindexed.test 168838d2c385e131120bbf5b516d2432a5fabc4caa2259c932e1d49ae209a4ae
F ext/fts5/test/fts5unindexed2.test 516236eceaac05ace322290a0d3705b4c4ffe4760d8eb9d014d9d27d56dfcc02
F ext/fts5/test/fts5update.test b8affd796e45c94a4d19ad5c26606ea06065a0f162a9562d9f005b5a80ccf0bc
F ext/fts5/test/fts5update2.test c5baa76799ac605ebb8e5e21035db2014b396cef25c903eb96ba39b1d6f9f046
F ext/fts5/test/fts5version.test c22d163c17e60a99f022cbc52de5a48bb7f84deaa00fe15e9bc4c3aa1996204e
F ext/fts5/test/fts5vocab.test 2a2bdb60d0998fa3124d541b6d30b019504918dc43a6584645b63a24be72f992
F ext/fts5/test/fts5vocab2.test bbba149c254375d00055930c1a501c9a51e80b0d20bf7b98f3e9fa3b03786373
@ -2213,8 +2215,9 @@ F vsixtest/vsixtest.tcl 6195aba1f12a5e10efc2b8c0009532167be5e301abe5b31385638080
F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
P 761d8fd18b0ee8681b12998f01a2eca1b796807a5174a1270cfb9bdc841424ac
R afa8cb87d393983234687bde8f6e9625
U drh
Z 3ddb58c2554e681f7603c7c59106deb3
P 7d5ff86ef7386f4f7f6a956dc0de607e61040d335c9f98d1f71e76a39f4f5e03 81d48df62ccf8b56e7adbc5327103e8ab5499bb22e587c4f0d0780a66adbdb67
R a123da90db9c6c32b958de081bea877e
T +closed 81d48df62ccf8b56e7adbc5327103e8ab5499bb22e587c4f0d0780a66adbdb67
U dan
Z 2e9bc797f2c159dea04278d2c7653c83
# Remove this line to create a well-formed Fossil manifest.

2
manifest.uuid
View File

@ -1 +1 @@
7d5ff86ef7386f4f7f6a956dc0de607e61040d335c9f98d1f71e76a39f4f5e03
58313ac59e0bd164f601d68a1474f658c5d1c038638e00f3dc15eb58202e661c