// Code generated by modernc.org/undup from the per-target sqlite_*.go files; DO NOT EDIT. //go:build (freebsd && arm) || (linux && arm) || (windows && 386) package sqlite3 import ( "unsafe" "modernc.org/libc" ) type TBtCursor = struct { F__ccgo_align [0]uint32 FeState Tu8 FcurFlags Tu8 FcurPagerFlags Tu8 Fhints Tu8 FskipNext int32 FpBtree uintptr FaOverflow uintptr FpKey uintptr FpBt uintptr FpNext uintptr F__ccgo_align10 [4]byte Finfo TCellInfo FnKey Ti64 FpgnoRoot TPgno FiPage Ti8 FcurIntKey Tu8 Fix Tu16 FaiIdx [19]Tu16 FpKeyInfo uintptr FpPage uintptr FapPage [19]uintptr F__ccgo_pad20 [4]byte } type TBtreePayload = struct { F__ccgo_align [0]uint32 FpKey uintptr F__ccgo_align1 [4]byte FnKey Tsqlite3_int64 FpData uintptr FaMem uintptr FnMem Tu16 FnData int32 FnZero int32 F__ccgo_pad7 [4]byte } /* ** Context object type used by rank(), dense_rank(), percent_rank() and ** cume_dist(). */ type TCallCount = struct { F__ccgo_align [0]uint32 FnValue Ti64 FnStep Ti64 FnTotal Ti64 } type TCellInfo = struct { F__ccgo_align [0]uint32 FnKey Ti64 FpPayload uintptr FnPayload Tu32 FnLocal Tu16 FnSize Tu16 F__ccgo_pad5 [4]byte } // C documentation // // /* // ** The following structure keeps track of state information for the // ** count() aggregate function. // */ type TCountCtx = struct { F__ccgo_align [0]uint32 Fn Ti64 } // C documentation // // /* // ** Handle type for pages. // */ type TDbPage = struct { F__ccgo_align [0]uint32 FpPage uintptr FpData uintptr FpExtra uintptr FpCache uintptr FpDirty uintptr FpPager uintptr Fpgno TPgno Fflags Tu16 F__ccgo_align8 [2]byte FnRef Ti64 FpDirtyNext uintptr FpDirtyPrev uintptr } type TFilePoint = struct { F__ccgo_align [0]uint32 FiOffset Tsqlite3_int64 FpChunk uintptr F__ccgo_pad2 [4]byte } // C documentation // // /* // ** The first time the bm25() function is called for a query, an instance // ** of the following structure is allocated and populated. // */ type TFts5Bm25Data = struct { F__ccgo_align [0]uint32 FnPhrase int32 F__ccgo_align1 [4]byte Favgdl float64 FaIDF uintptr FaFreq uintptr } type TFts5Cursor = struct { F__ccgo_align [0]uint32 Fbase Tsqlite3_vtab_cursor FpNext uintptr FaColumnSize uintptr F__ccgo_align3 [4]byte FiCsrId Ti64 FePlan int32 FbDesc int32 FiFirstRowid Ti64 FiLastRowid Ti64 FpStmt uintptr FpExpr uintptr FpSorter uintptr Fcsrflags int32 FiSpecial Ti64 FzRank uintptr FzRankArgs uintptr FpRank uintptr FnRankArg int32 FapRankArg uintptr FpRankArgStmt uintptr FpAux uintptr FpAuxdata uintptr FaInstIter uintptr FnInstAlloc int32 FnInstCount int32 FaInst uintptr } type TFts5DlidxIter = struct { F__ccgo_align [0]uint32 FnLvl int32 FiSegid int32 } type TFts5DlidxLvl = struct { F__ccgo_align [0]uint32 FpData uintptr FiOff int32 FbEof int32 FiFirstOff int32 FiLeafPgno int32 F__ccgo_align5 [4]byte FiRowid Ti64 } type TFts5DlidxWriter = struct { F__ccgo_align [0]uint32 Fpgno int32 FbPrevValid int32 FiPrev Ti64 Fbuf TFts5Buffer F__ccgo_pad4 [4]byte } type TFts5DoclistIter = struct { F__ccgo_align [0]uint32 FaEof uintptr F__ccgo_align1 [4]byte FiRowid Ti64 FaPoslist uintptr FnPoslist int32 FnSize int32 F__ccgo_pad5 [4]byte } type TFts5ExprCtx = struct { F__ccgo_align [0]uint32 FpExpr uintptr FaPopulator uintptr FiOff Ti64 } type TFts5ExprNode = struct { F__ccgo_align [0]uint32 FeType int32 FbEof int32 FbNomatch int32 FiHeight int32 FxNext uintptr F__ccgo_align5 [4]byte FiRowid Ti64 FpNear uintptr FnChild int32 } type TFts5FlushCtx = struct { F__ccgo_align [0]uint32 FpIdx uintptr F__ccgo_align1 [4]byte Fwriter TFts5SegWriter } type TFts5Global = struct { F__ccgo_align [0]uint32 Fapi Tfts5_api Fdb uintptr F__ccgo_align2 [4]byte FiNextId Ti64 FpAux uintptr FpTok uintptr FpDfltTok uintptr FpCsr uintptr FaLocaleHdr [4]Tu32 } type TFts5HashEntry = struct { F__ccgo_align [0]uint32 FpHashNext uintptr FpScanNext uintptr FnAlloc int32 FiSzPoslist int32 FnData int32 FnKey int32 FbDel Tu8 FbContent Tu8 FiCol Ti16 FiPos int32 FiRowid Ti64 } type TFts5Index = struct { F__ccgo_align [0]uint32 FpConfig uintptr FzDataTbl uintptr FnWorkUnit int32 FpHash uintptr FnPendingData int32 F__ccgo_align5 [4]byte FiWriteRowid Ti64 FbDelete int32 FnContentlessDelete int32 FnPendingRow int32 Frc int32 FflushRc int32 FpReader uintptr FpWriter uintptr FpDeleter uintptr FpIdxWriter uintptr FpIdxDeleter uintptr FpIdxSelect uintptr FpIdxNextSelect uintptr FnRead int32 FpDeleteFromIdx uintptr FpDataVersion uintptr F__ccgo_align21 [4]byte FiStructVersion Ti64 FpStruct uintptr F__ccgo_pad23 [4]byte } type TFts5IndexIter = struct { F__ccgo_align [0]uint32 FiRowid Ti64 FpData uintptr FnData int32 FbEof Tu8 F__ccgo_pad4 [7]byte } // C documentation // // /* // ** Context object used by sqlite3Fts5StorageIntegrity(). // */ type TFts5IntegrityCtx = struct { F__ccgo_align [0]uint32 FiRowid Ti64 FiCol int32 FszCol int32 Fcksum Tu64 FpTermset uintptr FpConfig uintptr } type TFts5Iter = struct { F__ccgo_align [0]uint32 Fbase TFts5IndexIter FpTokenDataIter uintptr FpIndex uintptr Fposlist TFts5Buffer FpColset uintptr FxSetOutputs uintptr FnSeg int32 FbRev int32 FbSkipEmpty Tu8 F__ccgo_align9 [3]byte FiSwitchRowid Ti64 FaFirst uintptr F__ccgo_pad12 [4]byte } type TFts5LookaheadReader = struct { F__ccgo_align [0]uint32 Fa uintptr Fn int32 Fi int32 F__ccgo_align3 [4]byte FiPos Ti64 FiLookahead Ti64 } type TFts5NearTrimmer = struct { F__ccgo_align [0]uint32 Freader TFts5LookaheadReader Fwriter TFts5PoslistWriter FpOut uintptr F__ccgo_pad3 [4]byte } type TFts5PoslistPopulator = struct { F__ccgo_align [0]uint32 Fwriter TFts5PoslistWriter FbOk int32 FbMiss int32 } type TFts5PoslistReader = struct { F__ccgo_align [0]uint32 Fa uintptr Fn int32 Fi int32 FbFlag Tu8 FbEof Tu8 F__ccgo_align5 [2]byte FiPos Ti64 } type TFts5PoslistWriter = struct { F__ccgo_align [0]uint32 FiPrev Ti64 } type TFts5SegIter = struct { F__ccgo_align [0]uint32 FpSeg uintptr Fflags int32 FiLeafPgno int32 FpLeaf uintptr FpNextLeaf uintptr F__ccgo_align5 [4]byte FiLeafOffset Ti64 FpTombArray uintptr FxNext uintptr FiTermLeafPgno int32 FiTermLeafOffset int32 FiPgidxOff int32 FiEndofDoclist int32 FiRowidOffset int32 FnRowidOffset int32 FaRowidOffset uintptr FpDlidx uintptr Fterm TFts5Buffer F__ccgo_align17 [4]byte FiRowid Ti64 FnPos int32 FbDel Tu8 F__ccgo_pad20 [3]byte } type TFts5SegWriter = struct { F__ccgo_align [0]uint32 FiSegid int32 Fwriter TFts5PageWriter FiPrevRowid Ti64 FbFirstRowidInDoclist Tu8 FbFirstRowidInPage Tu8 FbFirstTermInPage Tu8 FnLeafWritten int32 FnEmpty int32 FnDlidx int32 FaDlidx uintptr Fbtterm TFts5Buffer FiBtPage int32 F__ccgo_pad12 [4]byte } type TFts5Sorter = struct { F__ccgo_align [0]uint32 FpStmt uintptr F__ccgo_align1 [4]byte FiRowid Ti64 FaPoslist uintptr FnIdx int32 } type TFts5Storage = struct { F__ccgo_align [0]uint32 FpConfig uintptr FpIndex uintptr FbTotalsValid int32 F__ccgo_align3 [4]byte FnTotalRow Ti64 FaTotalSize uintptr FpSavedRow uintptr FaStmt [12]uintptr } type TFts5Structure = struct { F__ccgo_align [0]uint32 FnRef int32 F__ccgo_align1 [4]byte FnWriteCounter Tu64 FnOriginCntr Tu64 FnSegment int32 FnLevel int32 } type TFts5StructureSegment = struct { F__ccgo_align [0]uint32 FiSegid int32 FpgnoFirst int32 FpgnoLast int32 F__ccgo_align3 [4]byte FiOrigin1 Tu64 FiOrigin2 Tu64 FnPgTombstone int32 F__ccgo_align6 [4]byte FnEntryTombstone Tu64 FnEntry Tu64 } type TFts5TokenDataIter = struct { F__ccgo_align [0]uint32 FnMapAlloc Ti64 FnMap Ti64 FaMap uintptr Fterms TFts5Buffer FnIter Ti64 FnIterAlloc Ti64 FaPoslistReader uintptr FaPoslistToIter uintptr } type TFts5TokenDataMap = struct { F__ccgo_align [0]uint32 FiRowid Ti64 FiPos Ti64 FiIter int32 FnByte int32 } type TFts5VocabCursor = struct { F__ccgo_align [0]uint32 Fbase Tsqlite3_vtab_cursor FpStmt uintptr FpFts5 uintptr FbEof int32 FpIter uintptr FpStruct uintptr FnLeTerm int32 FzLeTerm uintptr FcolUsed int32 FiCol int32 FaCnt uintptr FaDoc uintptr Frowid Ti64 Fterm TFts5Buffer F__ccgo_align14 [4]byte FiInstPos Ti64 FiInstOff int32 F__ccgo_pad16 [4]byte } // C documentation // // /* Objects used by the overlap algorithm. */ type TGeoEvent = struct { F__ccgo_align [0]uint32 Fx float64 FeType int32 FpSeg uintptr FpNext uintptr F__ccgo_pad4 [4]byte } type TGeoSegment = struct { F__ccgo_align [0]uint32 FC float64 FB float64 Fy float64 Fy0 float32 Fside uint8 Fidx uint32 FpNext uintptr } /* In-memory list of records */ type TIncrMerger = struct { F__ccgo_align [0]uint32 FpTask uintptr FpMerger uintptr FiStartOff Ti64 FmxSz int32 FbEof int32 FbUseThread int32 F__ccgo_align6 [4]byte FaFile [2]TSorterFile } type TIndex = struct { F__ccgo_align [0]uint32 FzName uintptr FaiColumn uintptr FaiRowLogEst uintptr FpTable uintptr FzColAff uintptr FpNext uintptr FpSchema uintptr FaSortOrder uintptr FazColl uintptr FpPartIdxWhere uintptr FaColExpr uintptr Ftnum TPgno FszIdxRow TLogEst FnKeyCol Tu16 FnColumn Tu16 FonError Tu8 F__ccgo56 uint16 FnSample int32 FmxSample int32 FnSampleCol int32 FaAvgEq uintptr FaSample uintptr FaiRowEst uintptr F__ccgo_align33 [4]byte FnRowEst0 TtRowcnt FcolNotIdxed TBitmask } // C documentation // // /* // ** This structure is passed around through all the PRAGMA integrity_check // ** checking routines in order to keep track of some global state information. // ** // ** The aRef[] array is allocated so that there is 1 bit for each page in // ** the database. As the integrity-check proceeds, for each page used in // ** the database the corresponding bit is set. This allows integrity-check to // ** detect pages that are used twice and orphaned pages (both of which // ** indicate corruption). // */ type TIntegrityCk = struct { F__ccgo_align [0]uint32 FpBt uintptr FpPager uintptr FaPgRef uintptr FnCkPage TPgno FmxErr int32 FnErr int32 Frc int32 FnStep Tu32 FzPfx uintptr Fv0 TPgno Fv1 TPgno Fv2 int32 FerrMsg TStrAccum Fheap uintptr Fdb uintptr FnRow Ti64 } type TJsonEachCursor = struct { F__ccgo_align [0]uint32 Fbase Tsqlite3_vtab_cursor FiRowid Tu32 Fi Tu32 FiEnd Tu32 FnRoot Tu32 FeType Tu8 FbRecursive Tu8 FeMode Tu8 FnParent Tu32 FnParentAlloc Tu32 FaParent uintptr Fdb uintptr Fpath TJsonString FsParse TJsonParse } // C documentation // // /**************************************************************************** // ** The json_each virtual table // ****************************************************************************/ type TJsonParent = struct { F__ccgo_align [0]uint32 FiHead Tu32 FiValue Tu32 FiEnd Tu32 FnPath Tu32 FiKey Ti64 } // C documentation // // /* // ** The names of the following types declared in vdbeInt.h are required // ** for the VdbeOp definition. // */ type TMem = struct { F__ccgo_align [0]uint32 Fu TMemValue Fz uintptr Fn int32 Fflags Tu16 Fenc Tu8 FeSubtype Tu8 Fdb uintptr FszMalloc int32 FuTemp Tu32 FzMalloc uintptr FxDel uintptr } // C documentation // // /* // ** State information local to the memory allocation subsystem. // */ type TMem0Global = struct { F__ccgo_align [0]uint32 Fmutex uintptr F__ccgo_align1 [4]byte FalarmThreshold Tsqlite3_int64 FhardLimit Tsqlite3_int64 FnearlyFull int32 F__ccgo_pad4 [4]byte } // C documentation // // /* Forward references to internal structures */ type TMemJournal = struct { F__ccgo_align [0]uint32 FpMethod uintptr FnChunkSize int32 FnSpill int32 FpFirst uintptr Fendpoint TFilePoint Freadpoint TFilePoint Fflags int32 FpVfs uintptr FzJournal uintptr F__ccgo_pad9 [4]byte } type TMemStore = struct { F__ccgo_align [0]uint32 Fsz Tsqlite3_int64 FszAlloc Tsqlite3_int64 FszMax Tsqlite3_int64 FaData uintptr FpMutex uintptr FnMmap int32 FmFlags uint32 FnRdLock int32 FnWrLock int32 FnRef int32 FzFName uintptr } type TMemValue = struct { F__ccgo_align [0]uint32 Fi [0]int64 FnZero [0]int32 FzPType [0]uintptr FpDef [0]uintptr Fr float64 } /* ** Implementation of built-in window function nth_value(). This ** implementation is used in "slow mode" only - when the EXCLUDE clause ** is not set to the default value "NO OTHERS". */ type TNthValueCtx = struct { F__ccgo_align [0]uint32 FnStep Ti64 FpValue uintptr F__ccgo_pad2 [4]byte } /* ** Context object for ntile() window function. */ type TNtileCtx = struct { F__ccgo_align [0]uint32 FnTotal Ti64 FnParam Ti64 FiRow Ti64 } type TPCache = struct { F__ccgo_align [0]uint32 FpDirty uintptr FpDirtyTail uintptr FpSynced uintptr F__ccgo_align3 [4]byte FnRefSum Ti64 FszCache int32 FszSpill int32 FszPage int32 FszExtra int32 FbPurgeable Tu8 FeCreate Tu8 FxStress uintptr FpStress uintptr FpCache uintptr } // C documentation // // /* // ** An instance of the following structure is allocated for each active // ** savepoint and statement transaction in the system. All such structures // ** are stored in the Pager.aSavepoint[] array, which is allocated and // ** resized using sqlite3Realloc(). // ** // ** When a savepoint is created, the PagerSavepoint.iHdrOffset field is // ** set to 0. If a journal-header is written into the main journal while // ** the savepoint is active, then iHdrOffset is set to the byte offset // ** immediately following the last journal record written into the main // ** journal before the journal-header. This is required during savepoint // ** rollback (see pagerPlaybackSavepoint()). // */ type TPagerSavepoint = struct { F__ccgo_align [0]uint32 FiOffset Ti64 FiHdrOffset Ti64 FpInSavepoint uintptr FnOrig TPgno FiSubRec TPgno FbTruncateOnRelease int32 FaWalData [4]Tu32 } /* Merge PMAs together */ type TPmaReader = struct { F__ccgo_align [0]uint32 FiReadOff Ti64 FiEof Ti64 FnAlloc int32 FnKey int32 FpFd uintptr FaAlloc uintptr FaKey uintptr FaBuffer uintptr FnBuffer int32 FaMap uintptr FpIncr uintptr F__ccgo_pad11 [4]byte } /* Incrementally read one PMA */ type TPmaWriter = struct { F__ccgo_align [0]uint32 FeFWErr int32 FaBuffer uintptr FnBuffer int32 FiBufStart int32 FiBufEnd int32 F__ccgo_align5 [4]byte FiWriteOff Ti64 FpFd uintptr F__ccgo_align7 [4]byte FnPmaSpill Tu64 } // C documentation // // /* Definitions of all built-in pragmas */ type TPragmaName = struct { F__ccgo_align [0]uint32 FzName uintptr FePragTyp Tu8 FmPragFlg Tu8 FiPragCName Tu8 FnPragCName Tu8 FiArg Tu64 } type TPragmaVtabCursor = struct { F__ccgo_align [0]uint32 Fbase Tsqlite3_vtab_cursor FpPragma uintptr FiRowid Tsqlite_int64 FazArg [2]uintptr } type TPreUpdate = struct { F__ccgo_align [0]uint32 Fv uintptr FpCsr uintptr Fop int32 FaRecord uintptr FpKeyinfo uintptr FpUnpacked uintptr FpNewUnpacked uintptr FiNewReg int32 FiBlobWrite int32 F__ccgo_align9 [4]byte FiKey1 Ti64 FiKey2 Ti64 Foldipk TMem FaNew uintptr FpTab uintptr FpPk uintptr FapDflt uintptr FuKey struct { FkeyinfoSpace [20]Tu8 } F__ccgo_pad17 [4]byte } type TPrefixMerger = struct { F__ccgo_align [0]uint32 Fiter TFts5DoclistIter FiPos Ti64 FiOff int32 FaPos uintptr FpNext uintptr F__ccgo_pad5 [4]byte } // C documentation // // /* // ** Context object passed by fts5SetupPrefixIter() to fts5VisitEntries(). // */ type TPrefixSetupCtx = struct { F__ccgo_align [0]uint32 FxMerge uintptr FxAppend uintptr FiLastRowid Ti64 FnMerge int32 FaBuf uintptr FnBuf int32 Fdoclist TFts5Buffer FpTokendata uintptr F__ccgo_pad8 [4]byte } type TRCStr = struct { F__ccgo_align [0]uint32 FnRCRef Tu64 } type TRbuState = struct { F__ccgo_align [0]uint32 FeStage int32 FzTbl uintptr FzDataTbl uintptr FzIdx uintptr FiWalCksum Ti64 FnRow int32 F__ccgo_align6 [4]byte FnProgress Ti64 FiCookie Tu32 F__ccgo_align8 [4]byte FiOalSz Ti64 FnPhaseOneStep Ti64 } /* Structure used to pass information throughout the Walker in order to ** implement sqlite3ReferencesSrcList(). */ type TRefSrcList = struct { F__ccgo_align [0]uint32 Fdb uintptr FpRef uintptr FnExclude Ti64 FaiExclude uintptr F__ccgo_pad4 [4]byte } /* An instance of this object describes bulk memory available for use ** by subcomponents of a prepared statement. Space is allocated out ** of a ReusableSpace object by the allocSpace() routine below. */ type TReusableSpace = struct { F__ccgo_align [0]uint32 FpSpace uintptr F__ccgo_align1 [4]byte FnFree Tsqlite3_int64 FnNeeded Tsqlite3_int64 } /* ** RowSetEntry objects are allocated in large chunks (instances of the ** following structure) to reduce memory allocation overhead. The ** chunks are kept on a linked list so that they can be deallocated ** when the RowSet is destroyed. */ type TRowSetChunk = struct { F__ccgo_align [0]uint32 FpNextChunk uintptr F__ccgo_align1 [4]byte FaEntry [63]TRowSetEntry } /* ** Each entry in a RowSet is an instance of the following object. ** ** This same object is reused to store a linked list of trees of RowSetEntry ** objects. In that alternative use, pRight points to the next entry ** in the list, pLeft points to the tree, and v is unused. The ** RowSet.pForest value points to the head of this forest list. */ type TRowSetEntry = struct { F__ccgo_align [0]uint32 Fv Ti64 FpRight uintptr FpLeft uintptr } type TRtree = struct { F__ccgo_align [0]uint32 Fbase Tsqlite3_vtab Fdb uintptr FiNodeSize int32 FnDim Tu8 FnDim2 Tu8 FeCoordType Tu8 FnBytesPerCell Tu8 FinWrTrans Tu8 FnAux Tu16 FnAuxNotNull Tu8 FiDepth int32 FzDb uintptr FzName uintptr FzNodeName uintptr FnBusy Tu32 F__ccgo_align15 [4]byte FnRowEst Ti64 FnCursor Tu32 FnNodeRef Tu32 FzReadAuxSql uintptr FpDeleted uintptr FpNodeBlob uintptr FpWriteNode uintptr FpDeleteNode uintptr FpReadRowid uintptr FpWriteRowid uintptr FpDeleteRowid uintptr FpReadParent uintptr FpWriteParent uintptr FpDeleteParent uintptr FpWriteAux uintptr FaHash [97]uintptr F__ccgo_pad31 [4]byte } type TRtreeCell = struct { F__ccgo_align [0]uint32 FiRowid Ti64 FaCoord [10]TRtreeCoord } type TRtreeConstraint = struct { F__ccgo_align [0]uint32 FiCoord int32 Fop int32 Fu struct { F__ccgo_align [0]uint32 FxGeom [0]uintptr FxQueryFunc [0]uintptr FrValue TRtreeDValue } FpInfo uintptr F__ccgo_pad4 [4]byte } type TRtreeCursor = struct { F__ccgo_align [0]uint32 Fbase Tsqlite3_vtab_cursor FatEOF Tu8 FbPoint Tu8 FbAuxValid Tu8 FiStrategy int32 FnConstraint int32 FaConstraint uintptr FnPointAlloc int32 FnPoint int32 FmxLevel int32 FaPoint uintptr FpReadAux uintptr FsPoint TRtreeSearchPoint FaNode [5]uintptr FanQueue [42]Tu32 F__ccgo_pad15 [4]byte } type TRtreeMatchArg = struct { F__ccgo_align [0]uint32 FiSize Tu32 Fcb TRtreeGeomCallback FnParam int32 FapSqlParam uintptr F__ccgo_pad5 [4]byte } type TRtreeNode = struct { F__ccgo_align [0]uint32 FpParent uintptr F__ccgo_align1 [4]byte FiNode Ti64 FnRef int32 FisDirty int32 FzData uintptr FpNext uintptr } type TRtreeSearchPoint = struct { F__ccgo_align [0]uint32 FrScore TRtreeDValue Fid Tsqlite3_int64 FiLevel Tu8 FeWithin Tu8 FiCell Tu8 F__ccgo_pad5 [5]byte } type TSavepoint = struct { F__ccgo_align [0]uint32 FzName uintptr F__ccgo_align1 [4]byte FnDeferredCons Ti64 FnDeferredImmCons Ti64 FpNext uintptr F__ccgo_pad4 [4]byte } /* A record being sorted */ type TSortSubtask = struct { F__ccgo_align [0]uint32 FpThread uintptr FbDone int32 FnPMA int32 FpSorter uintptr FpUnpacked uintptr F__ccgo_align5 [4]byte Flist TSorterList FxCompare TSorterCompare F__ccgo_align7 [4]byte Ffile TSorterFile Ffile2 TSorterFile FnSpill Tu64 } /* A sub-task in the sort process */ type TSorterFile = struct { F__ccgo_align [0]uint32 FpFd uintptr F__ccgo_align1 [4]byte FiEof Ti64 } /* Temporary file object wrapper */ type TSorterList = struct { F__ccgo_align [0]uint32 FpList uintptr FaMemory uintptr FszPMA Ti64 } /* ** Structure containing global configuration data for the SQLite library. ** ** This structure also contains some state information. */ type TSqlite3Config = struct { F__ccgo_align [0]uint32 FbMemstat int32 FbCoreMutex Tu8 FbFullMutex Tu8 FbOpenUri Tu8 FbUseCis Tu8 FbSmallMalloc Tu8 FbExtraSchemaChecks Tu8 FmxStrlen int32 FneverCorrupt int32 FszLookaside int32 FnLookaside int32 FnStmtSpill int32 Fm Tsqlite3_mem_methods Fmutex Tsqlite3_mutex_methods Fpcache2 Tsqlite3_pcache_methods2 FpHeap uintptr FnHeap int32 FmnReq int32 FmxReq int32 FszMmap Tsqlite3_int64 FmxMmap Tsqlite3_int64 FpPage uintptr FszPage int32 FnPage int32 FmxParserStack int32 FsharedCacheEnabled int32 FszPma Tu32 FisInit int32 FinProgress int32 FisMutexInit int32 FisMallocInit int32 FisPCacheInit int32 FnRefInitMutex int32 FpInitMutex uintptr FxLog uintptr FpLogArg uintptr F__ccgo_align36 [4]byte FmxMemdbSize Tsqlite3_int64 FxTestCallback uintptr FbLocaltimeFault int32 FxAltLocaltime uintptr FiOnceResetThreshold int32 FszSorterRef Tu32 FiPrngSeed uint32 } type TSrcItem = struct { F__ccgo_align [0]uint32 FzName uintptr FzAlias uintptr FpSTab uintptr Ffg struct { Fjointype Tu8 F__ccgo4 uint32 } FiCursor int32 FcolUsed TBitmask Fu1 struct { FpFuncArg [0]uintptr FnRow [0]Tu32 FzIndexedBy uintptr } Fu2 struct { FpCteUse [0]uintptr FpIBIndex uintptr } Fu3 struct { FpUsing [0]uintptr FpOn uintptr } Fu4 struct { FzDatabase [0]uintptr FpSubq [0]uintptr FpSchema uintptr } } type TSrcList = struct { F__ccgo_align [0]uint32 FnSrc int32 FnAlloc Tu32 } // C documentation // // /* // ** Three SQL functions - stat_init(), stat_push(), and stat_get() - // ** share an instance of the following structure to hold their state // ** information. // */ type TStatAccum = struct { F__ccgo_align [0]uint32 Fdb uintptr F__ccgo_align1 [4]byte FnEst TtRowcnt FnRow TtRowcnt FnLimit int32 FnCol int32 FnKeyCol int32 FnSkipAhead Tu8 F__ccgo_align7 [3]byte Fcurrent TStatSample FnPSample TtRowcnt FmxSample int32 FiPrn Tu32 FaBest uintptr FiMin int32 FnSample int32 FnMaxEqZero int32 FiGet int32 Fa uintptr } type TStatCursor = struct { F__ccgo_align [0]uint32 Fbase Tsqlite3_vtab_cursor FpStmt uintptr FisEof Tu8 FisAgg Tu8 FiDb int32 FaPage [32]TStatPage FiPage int32 FiPageno Tu32 FzName uintptr FzPath uintptr FzPagetype uintptr FnPage int32 FnCell int32 FnMxPayload int32 FnUnused Ti64 FnPayload Ti64 FiOffset Ti64 FszPage Ti64 } type TStatSample = struct { F__ccgo_align [0]uint32 FanDLt uintptr FanEq uintptr FanLt uintptr F__ccgo_align3 [4]byte Fu struct { F__ccgo_align [0]uint32 FaRowid [0]uintptr FiRowid Ti64 } FnRowid Tu32 FisPSample Tu8 FiCol int32 FiHash Tu32 } // C documentation // // /* // ** An instance of the following structure holds the context of a // ** sum() or avg() aggregate computation. // */ type TSumCtx = struct { F__ccgo_align [0]uint32 FrSum float64 FrErr float64 FiSum Ti64 Fcnt Ti64 Fapprox Tu8 Fovrfl Tu8 F__ccgo_pad6 [6]byte } type TUnpackedRecord = struct { F__ccgo_align [0]uint32 FpKeyInfo uintptr FaMem uintptr Fu struct { F__ccgo_align [0]uint32 Fi [0]Ti64 Fz uintptr F__ccgo_pad2 [4]byte } Fn int32 FnField Tu16 Fdefault_rc Ti8 FerrCode Tu8 Fr1 Ti8 Fr2 Ti8 FeqSeen Tu8 F__ccgo_pad10 [5]byte } // C documentation // // /* // ** A single VDBE is an opaque structure named "Vdbe". Only routines // ** in the source file sqliteVdbe.c are allowed to see the insides // ** of this structure. // */ type TVdbe = struct { F__ccgo_align [0]uint32 Fdb uintptr FppVPrev uintptr FpVNext uintptr FpParse uintptr FnVar TynVar FnMem int32 FnCursor int32 FcacheCtr Tu32 Fpc int32 Frc int32 FnChange Ti64 FiStatement int32 F__ccgo_align12 [4]byte FiCurrentTime Ti64 FnFkConstraint Ti64 FnStmtDefCons Ti64 FnStmtDefImmCons Ti64 FaMem uintptr FapArg uintptr FapCsr uintptr FaVar uintptr FaOp uintptr FnOp int32 FnOpAlloc int32 FaColName uintptr FpResultRow uintptr FzErrMsg uintptr FpVList uintptr F__ccgo_align27 [4]byte FstartTime Ti64 FnResColumn Tu16 FnResAlloc Tu16 FerrorAction Tu8 FminWriteFileFormat Tu8 FprepFlags Tu8 FeVdbeState Tu8 F__ccgo152 uint16 FbtreeMask TyDbMask FlockMask TyDbMask FaCounter [9]Tu32 FzSql uintptr FpFree uintptr FpFrame uintptr FpDelFrame uintptr FnFrame int32 Fexpmask Tu32 FpProgram uintptr FpAuxData uintptr } // C documentation // // /* // ** A VdbeCursor is an superclass (a wrapper) for various cursor objects: // ** // ** * A b-tree cursor // ** - In the main database or in an ephemeral database // ** - On either an index or a table // ** * A sorter // ** * A virtual table // ** * A one-row "pseudotable" stored in a single register // */ type TVdbeCursor = struct { F__ccgo_align [0]uint32 FeCurType Tu8 FiDb Ti8 FnullRow Tu8 FdeferredMoveto Tu8 FisTable Tu8 F__ccgo_align5 [3]byte F__ccgo8 uint8 FseekHit Tu16 Fub struct { FaAltMap [0]uintptr FpBtx uintptr } FseqCount Ti64 FcacheStatus Tu32 FseekResult int32 FpAltCursor uintptr Fuc struct { FpVCur [0]uintptr FpSorter [0]uintptr FpCursor uintptr } FpKeyInfo uintptr FiHdrOffset Tu32 FpgnoRoot TPgno FnField Ti16 FnHdrParsed Tu16 FmovetoTarget Ti64 FaOffset uintptr FaRow uintptr FpayloadSize Tu32 FszRow Tu32 FpCache uintptr F__ccgo_pad29 [4]byte } // C documentation // // /* // ** When a sub-program is executed (OP_Program), a structure of this type // ** is allocated to store the current value of the program counter, as // ** well as the current memory cell array and various other frame specific // ** values stored in the Vdbe struct. When the sub-program is finished, // ** these values are copied back to the Vdbe from the VdbeFrame structure, // ** restoring the state of the VM to as it was before the sub-program // ** began executing. // ** // ** The memory for a VdbeFrame object is allocated and managed by a memory // ** cell in the parent (calling) frame. When the memory cell is deleted or // ** overwritten, the VdbeFrame object is not freed immediately. Instead, it // ** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame // ** list is deleted when the VM is reset in VdbeHalt(). The reason for doing // ** this instead of deleting the VdbeFrame immediately is to avoid recursive // ** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the // ** child frame are released. // ** // ** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is // ** set to NULL if the currently executing frame is the main program. // */ type TVdbeFrame = struct { F__ccgo_align [0]uint32 Fv uintptr FpParent uintptr FaOp uintptr FaMem uintptr FapCsr uintptr FaOnce uintptr Ftoken uintptr F__ccgo_align7 [4]byte FlastRowid Ti64 FpAuxData uintptr FnCursor int32 Fpc int32 FnOp int32 FnMem int32 FnChildMem int32 FnChildCsr int32 F__ccgo_align15 [4]byte FnChange Ti64 FnDbChange Ti64 } // C documentation // // /* Opaque type used by code in vdbesort.c */ type TVdbeSorter = struct { F__ccgo_align [0]uint32 FmnPmaSize int32 FmxPmaSize int32 FmxKeysize int32 Fpgsz int32 FpReader uintptr FpMerger uintptr Fdb uintptr FpKeyInfo uintptr FpUnpacked uintptr F__ccgo_align9 [4]byte Flist TSorterList FiMemory int32 FnMemory int32 FbUsePMA Tu8 FbUseThreads Tu8 FiPrev Tu8 FnTask Tu8 FtypeMask Tu8 F__ccgo_pad18 [3]byte } // C documentation // // /* A cache of large TEXT or BLOB values in a VdbeCursor */ type TVdbeTxtBlbCache = struct { F__ccgo_align [0]uint32 FpCValue uintptr F__ccgo_align1 [4]byte FiOffset Ti64 FiCol int32 FcacheStatus Tu32 FcolCacheCtr Tu32 F__ccgo_pad5 [4]byte } // C documentation // // /* Connection to a write-ahead log (WAL) file. // ** There is one object of this type for each pager. // */ type TWal = struct { F__ccgo_align [0]uint32 FpVfs uintptr FpDbFd uintptr FpWalFd uintptr FiCallback Tu32 FmxWalSize Ti64 FnWiData int32 FszFirstBlock int32 FapWiData uintptr FszPage Tu32 FreadLock Ti16 FsyncFlags Tu8 FexclusiveMode Tu8 FwriteLock Tu8 FckptLock Tu8 FreadOnly Tu8 FtruncateOnCommit Tu8 FsyncHeader Tu8 FpadToSectorBoundary Tu8 FbShmUnreliable Tu8 Fhdr TWalIndexHdr FminFrame Tu32 FiReCksum Tu32 FzWalName uintptr FnCkpt Tu32 FpSnapshot uintptr FbGetSnapshot int32 F__ccgo_pad26 [4]byte } // C documentation // // /* // ** Information about the current state of the WAL file and where // ** the next fsync should occur - passed from sqlite3WalFrames() into // ** walWriteToLog(). // */ type TWalWriter = struct { F__ccgo_align [0]uint32 FpWal uintptr FpFd uintptr FiSyncPoint Tsqlite3_int64 FsyncFlags int32 FszPage int32 } type TWhereAndInfo = struct { F__ccgo_align [0]uint32 Fwc TWhereClause } // C documentation // // /* Forward references // */ type TWhereClause = struct { F__ccgo_align [0]uint32 FpWInfo uintptr FpOuter uintptr Fop Tu8 FhasOr Tu8 FnTerm int32 FnSlot int32 FnBase int32 Fa uintptr F__ccgo_align8 [4]byte FaStatic [8]TWhereTerm } type TWhereInfo = struct { F__ccgo_align [0]uint32 FpParse uintptr FpTabList uintptr FpOrderBy uintptr FpResultSet uintptr FpSelect uintptr FaiCurOnePass [2]int32 FiContinue int32 FiBreak int32 FsavedNQueryLoop int32 FwctrlFlags Tu16 FiLimit TLogEst FnLevel Tu8 FnOBSat Ti8 FeOnePass Tu8 FeDistinct Tu8 F__ccgo48 uint8 FnRowOut TLogEst FiTop int32 FiEndWhere int32 FpLoops uintptr FpMemToFree uintptr F__ccgo_align26 [4]byte FrevMask TBitmask FsWC TWhereClause FsMaskSet TWhereMaskSet } type TWhereLevel = struct { F__ccgo_align [0]uint32 FiLeftJoin int32 FiTabCur int32 FiIdxCur int32 FaddrBrk int32 FaddrHalt int32 FaddrNxt int32 FaddrSkip int32 FaddrCont int32 FaddrFirst int32 FaddrBody int32 FregBignull int32 FaddrBignull int32 FregFilter int32 FpRJ uintptr FiFrom Tu8 Fop Tu8 Fp3 Tu8 Fp5 Tu8 Fp1 int32 Fp2 int32 Fu struct { FpCoveringIdx [0]uintptr Fin struct { FnIn int32 FaInLoop uintptr } } FpWLoop uintptr FnotReady TBitmask } type TWhereLoop = struct { F__ccgo_align [0]uint32 Fprereq TBitmask FmaskSelf TBitmask FiTab Tu8 FiSortIdx Tu8 FrSetup TLogEst FrRun TLogEst FnOut TLogEst Fu struct { Fvtab [0]struct { FidxNum int32 F__ccgo4 uint8 FisOrdered Ti8 FomitMask Tu16 FidxStr uintptr FmHandleIn Tu32 } Fbtree struct { FnEq Tu16 FnBtm Tu16 FnTop Tu16 FnDistinctCol Tu16 FpIndex uintptr FpOrderBy uintptr } } FwsFlags Tu32 FnLTerm Tu16 FnSkip Tu16 FnLSlot Tu16 FaLTerm uintptr FpNextLoop uintptr FaLTermSpace [3]uintptr } type TWhereMemBlock = struct { F__ccgo_align [0]uint32 FpNext uintptr F__ccgo_align1 [4]byte Fsz Tu64 } type TWhereOrCost = struct { F__ccgo_align [0]uint32 Fprereq TBitmask FrRun TLogEst FnOut TLogEst F__ccgo_pad3 [4]byte } type TWhereOrInfo = struct { F__ccgo_align [0]uint32 Fwc TWhereClause Findexable TBitmask } type TWhereOrSet = struct { F__ccgo_align [0]uint32 Fn Tu16 F__ccgo_align1 [6]byte Fa [3]TWhereOrCost } type TWherePath = struct { F__ccgo_align [0]uint32 FmaskLoop TBitmask FrevLoop TBitmask FnRow TLogEst FrCost TLogEst FrUnsort TLogEst FisOrdered Ti8 FaLoop uintptr F__ccgo_pad7 [4]byte } type TWhereTerm = struct { F__ccgo_align [0]uint32 FpExpr uintptr FpWC uintptr FtruthProb TLogEst FwtFlags Tu16 FeOperator Tu16 FnChild Tu8 FeMatchOp Tu8 FiParent int32 FleftCursor int32 Fu struct { FpOrInfo [0]uintptr FpAndInfo [0]uintptr Fx struct { FleftColumn int32 FiField int32 } } FprereqRight TBitmask FprereqAll TBitmask } type Tlldiv_t = struct { F__ccgo_align [0]uint32 Fquot int64 Frem int64 } type Trbu_file = struct { F__ccgo_align [0]uint32 Fbase Tsqlite3_file FpReal uintptr FpRbuVfs uintptr FpRbu uintptr Fsz Ti64 FopenFlags int32 FiCookie Tu32 FiWriteVer Tu8 FbNolock Tu8 FnShm int32 FapShm uintptr FzDel uintptr FzWal uintptr FpWalFd uintptr FpMainNext uintptr FpMainRbuNext uintptr } // C documentation // // /* // ** CAPI3REF: Database Connection Handle // ** KEYWORDS: {database connection} {database connections} // ** // ** Each open SQLite database is represented by a pointer to an instance of // ** the opaque structure named "sqlite3". It is useful to think of an sqlite3 // ** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and // ** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] // ** and [sqlite3_close_v2()] are its destructors. There are many other // ** interfaces (such as // ** [sqlite3_prepare_v2()], [sqlite3_create_function()], and // ** [sqlite3_busy_timeout()] to name but three) that are methods on an // ** sqlite3 object. // */ type Tsqlite3 = struct { F__ccgo_align [0]uint32 FpVfs uintptr FpVdbe uintptr FpDfltColl uintptr Fmutex uintptr FaDb uintptr FnDb int32 FmDbFlags Tu32 F__ccgo_align7 [4]byte Fflags Tu64 FlastRowid Ti64 FszMmap Ti64 FnSchemaLock Tu32 FopenFlags uint32 FerrCode int32 FerrByteOffset int32 FerrMask int32 FiSysErrno int32 FdbOptFlags Tu32 Fenc Tu8 FautoCommit Tu8 Ftemp_store Tu8 FmallocFailed Tu8 FbBenignMalloc Tu8 FdfltLockMode Tu8 FnextAutovac int8 FsuppressErr Tu8 FvtabOnConflict Tu8 FisTransactionSavepoint Tu8 FmTrace Tu8 FnoSharedCache Tu8 FnSqlExec Tu8 FeOpenState Tu8 FnFpDigit Tu8 FnextPagesize int32 FnChange Ti64 FnTotalChange Ti64 FaLimit [13]int32 FnMaxSorterMmap int32 Finit1 Tsqlite3InitInfo FnVdbeActive int32 FnVdbeRead int32 FnVdbeWrite int32 FnVdbeExec int32 FnVDestroy int32 FnExtension int32 FaExtension uintptr Ftrace struct { FxV2 [0]uintptr FxLegacy uintptr } FpTraceArg uintptr FxProfile uintptr FpProfileArg uintptr FpCommitArg uintptr FxCommitCallback uintptr FpRollbackArg uintptr FxRollbackCallback uintptr FpUpdateArg uintptr FxUpdateCallback uintptr FpAutovacPagesArg uintptr FxAutovacDestr uintptr FxAutovacPages uintptr FpParse uintptr FpPreUpdateArg uintptr FxPreUpdateCallback uintptr FpPreUpdate uintptr FxWalCallback uintptr FpWalArg uintptr FxCollNeeded uintptr FxCollNeeded16 uintptr FpCollNeededArg uintptr FpErr uintptr Fu1 struct { F__ccgo_align [0]uint32 FnotUsed1 [0]float64 FisInterrupted int32 F__ccgo_pad2 [4]byte } Flookaside TLookaside FxAuth Tsqlite3_xauth FpAuthArg uintptr FxProgress uintptr FpProgressArg uintptr FnProgressOps uint32 FnVTrans int32 FaModule THash FpVtabCtx uintptr FaVTrans uintptr FpDisconnect uintptr FaFunc THash FaCollSeq THash FbusyHandler TBusyHandler FaDbStatic [2]TDb FpSavepoint uintptr FnAnalysisLimit int32 FbusyTimeout int32 FnSavepoint int32 FnStatement int32 FnDeferredCons Ti64 FnDeferredImmCons Ti64 FpnBytesFreed uintptr FpDbData uintptr FnSpill Tu64 FpBlockingConnection uintptr FpUnlockConnection uintptr FpUnlockArg uintptr FxUnlockNotify uintptr FpNextBlocked uintptr F__ccgo_pad99 [4]byte } type Tsqlite3_index_info = struct { F__ccgo_align [0]uint32 FnConstraint int32 FaConstraint uintptr FnOrderBy int32 FaOrderBy uintptr FaConstraintUsage uintptr FidxNum int32 FidxStr uintptr FneedToFreeIdxStr int32 ForderByConsumed int32 F__ccgo_align9 [4]byte FestimatedCost float64 FestimatedRows Tsqlite3_int64 FidxFlags int32 F__ccgo_align12 [4]byte FcolUsed Tsqlite3_uint64 } type Tsqlite3_rtree_query_info = struct { F__ccgo_align [0]uint32 FpContext uintptr FnParam int32 FaParam uintptr FpUser uintptr FxDelUser uintptr FaCoord uintptr FanQueue uintptr FnCoord int32 FiLevel int32 FmxLevel int32 FiRowid Tsqlite3_int64 FrParentScore Tsqlite3_rtree_dbl FeParentWithin int32 FeWithin int32 FrScore Tsqlite3_rtree_dbl FapSqlParam uintptr F__ccgo_pad16 [4]byte } // C documentation // // /* // ** CAPI3REF: Session Object Handle // ** // ** An instance of this object is a [session] that can be used to // ** record changes to a database. // */ type Tsqlite3_session = struct { F__ccgo_align [0]uint32 Fdb uintptr FzDb uintptr FbEnableSize int32 FbEnable int32 FbIndirect int32 FbAutoAttach int32 FbImplicitPK int32 Frc int32 FpFilterCtx uintptr FxTableFilter uintptr FnMalloc Ti64 FnMaxChangesetSize Ti64 FpZeroBlob uintptr FpNext uintptr FpTable uintptr Fhook TSessionHook } // C documentation // // /* // ** CAPI3REF: Dynamically Typed Value Object // ** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value} // ** // ** SQLite uses the sqlite3_value object to represent all values // ** that can be stored in a database table. SQLite uses dynamic typing // ** for the values it stores. ^Values stored in sqlite3_value objects // ** can be integers, floating point values, strings, BLOBs, or NULL. // ** // ** An sqlite3_value object may be either "protected" or "unprotected". // ** Some interfaces require a protected sqlite3_value. Other interfaces // ** will accept either a protected or an unprotected sqlite3_value. // ** Every interface that accepts sqlite3_value arguments specifies // ** whether or not it requires a protected sqlite3_value. The // ** [sqlite3_value_dup()] interface can be used to construct a new // ** protected sqlite3_value from an unprotected sqlite3_value. // ** // ** The terms "protected" and "unprotected" refer to whether or not // ** a mutex is held. An internal mutex is held for a protected // ** sqlite3_value object but no mutex is held for an unprotected // ** sqlite3_value object. If SQLite is compiled to be single-threaded // ** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0) // ** or if SQLite is run in one of reduced mutex modes // ** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD] // ** then there is no distinction between protected and unprotected // ** sqlite3_value objects and they can be used interchangeably. However, // ** for maximum code portability it is recommended that applications // ** still make the distinction between protected and unprotected // ** sqlite3_value objects even when not strictly required. // ** // ** ^The sqlite3_value objects that are passed as parameters into the // ** implementation of [application-defined SQL functions] are protected. // ** ^The sqlite3_value objects returned by [sqlite3_vtab_rhs_value()] // ** are protected. // ** ^The sqlite3_value object returned by // ** [sqlite3_column_value()] is unprotected. // ** Unprotected sqlite3_value objects may only be used as arguments // ** to [sqlite3_result_value()], [sqlite3_bind_value()], and // ** [sqlite3_value_dup()]. // ** The [sqlite3_value_blob | sqlite3_value_type()] family of // ** interfaces require protected sqlite3_value objects. // */ type Tsqlite3_value = struct { F__ccgo_align [0]uint32 Fu TMemValue Fz uintptr Fn int32 Fflags Tu16 Fenc Tu8 FeSubtype Tu8 Fdb uintptr FszMalloc int32 FuTemp Tu32 FzMalloc uintptr FxDel uintptr } // C documentation // // /* // ** Set all the parameters in the compiled SQL statement to NULL. // */ func Xsqlite3_clear_bindings(tls *libc.TLS, pStmt uintptr) (r int32) { var i, rc int32 var mutex, p uintptr _, _, _, _ = i, mutex, p, rc rc = SQLITE_OK p = pStmt mutex = (*Tsqlite3)(unsafe.Pointer((*TVdbe)(unsafe.Pointer(p)).Fdb)).Fmutex Xsqlite3_mutex_enter(tls, mutex) i = 0 for { if !(i < int32((*TVdbe)(unsafe.Pointer(p)).FnVar)) { break } _sqlite3VdbeMemRelease(tls, (*TVdbe)(unsafe.Pointer(p)).FaVar+uintptr(i)*40) (**(**TMem)(__ccgo_up((*TVdbe)(unsafe.Pointer(p)).FaVar + uintptr(i)*40))).Fflags = uint16(MEM_Null) goto _1 _1: ; i = i + 1 } if (*TVdbe)(unsafe.Pointer(p)).Fexpmask != 0 { libc.SetBitFieldPtr16Uint32(p+152, libc.Uint32FromInt32(1), 0, 0x3) } Xsqlite3_mutex_leave(tls, mutex) return rc } // C documentation // // /* // ** External API to drop all virtual-table modules, except those named // ** on the azNames list. // */ func Xsqlite3_drop_modules(tls *libc.TLS, db uintptr, azNames uintptr) (r int32) { var ii int32 var pMod, pNext, pThis uintptr _, _, _, _ = ii, pMod, pNext, pThis Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) pThis = (*THash)(unsafe.Pointer(db + 404)).Ffirst for { if !(pThis != 0) { break } pMod = (*THashElem)(unsafe.Pointer(pThis)).Fdata pNext = (*THashElem)(unsafe.Pointer(pThis)).Fnext if azNames != 0 { ii = 0 for { if !(**(**uintptr)(__ccgo_up(azNames + uintptr(ii)*4)) != uintptr(0) && libc.Xstrcmp(tls, **(**uintptr)(__ccgo_up(azNames + uintptr(ii)*4)), (*TModule)(unsafe.Pointer(pMod)).FzName) != 0) { break } goto _2 _2: ; ii = ii + 1 } if **(**uintptr)(__ccgo_up(azNames + uintptr(ii)*4)) != uintptr(0) { goto _1 } } _createModule(tls, db, (*TModule)(unsafe.Pointer(pMod)).FzName, uintptr(0), uintptr(0), uintptr(0)) goto _1 _1: ; pThis = pNext } Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) return SQLITE_OK } // C documentation // // /* // ** Return TRUE (non-zero) of the statement supplied as an argument needs // ** to be recompiled. A statement needs to be recompiled whenever the // ** execution environment changes in a way that would alter the program // ** that sqlite3_prepare() generates. For example, if new functions or // ** collating sequences are registered or if an authorizer function is // ** added or changed. // */ func Xsqlite3_expired(tls *libc.TLS, pStmt uintptr) (r int32) { var iRet int32 var p uintptr _, _ = iRet, p iRet = int32(1) if pStmt != 0 { p = pStmt Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer((*TVdbe)(unsafe.Pointer(p)).Fdb)).Fmutex) iRet = int32(Tbft(*(*uint16)(unsafe.Pointer(p + 152)) & 0x3 >> 0)) Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer((*TVdbe)(unsafe.Pointer(p)).Fdb)).Fmutex) } return iRet } // C documentation // // /* // ** Cause any pending operation to stop at its earliest opportunity. // */ func Xsqlite3_interrupt(tls *libc.TLS, db uintptr) { libc.AtomicStoreNInt32(db+312, libc.Int32FromInt32(1), libc.Int32FromInt32(__ATOMIC_RELAXED)) } // C documentation // // /* // ** Return true or false depending on whether or not an interrupt is // ** pending on connection db. // */ func Xsqlite3_is_interrupted(tls *libc.TLS, db uintptr) (r int32) { return libc.BoolInt32(libc.AtomicLoadNInt32(db+312, libc.Int32FromInt32(__ATOMIC_RELAXED)) != 0) } // C documentation // // /* // ** Change the value of a limit. Report the old value. // ** If an invalid limit index is supplied, report -1. // ** Make no changes but still report the old value if the // ** new limit is negative. // ** // ** A new lower limit does not shrink existing constructs. // ** It merely prevents new constructs that exceed the limit // ** from forming. // */ func Xsqlite3_limit(tls *libc.TLS, db uintptr, limitId int32, newLimit int32) (r int32) { var oldLimit int32 _ = oldLimit /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME ** there is a hard upper bound set at compile-time by a C preprocessor ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to ** "_MAX_".) */ if limitId < 0 || limitId >= libc.Int32FromInt32(SQLITE_LIMIT_PARSER_DEPTH)+libc.Int32FromInt32(1) { return -int32(1) } Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) oldLimit = **(**int32)(__ccgo_up(db + 120 + uintptr(limitId)*4)) if newLimit >= 0 { /* IMP: R-52476-28732 */ if newLimit > _aHardLimit[limitId] { newLimit = _aHardLimit[limitId] /* IMP: R-51463-25634 */ } else { if newLimit < int32(SQLITE_MIN_LENGTH) && limitId == SQLITE_LIMIT_LENGTH { newLimit = int32(SQLITE_MIN_LENGTH) } } **(**int32)(__ccgo_up(db + 120 + uintptr(limitId)*4)) = newLimit } Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) return oldLimit /* IMP: R-53341-35419 */ } // C documentation // // /* // ** Register a profile function. The pArg from the previously registered // ** profile function is returned. // ** // ** A NULL profile function means that no profiling is executes. A non-NULL // ** profile is a pointer to a function that is invoked at the conclusion of // ** each SQL statement that is run. // */ func Xsqlite3_profile(tls *libc.TLS, db uintptr, __ccgo_fp_xProfile uintptr, pArg uintptr) (r uintptr) { var pOld, v1 uintptr _, _ = pOld, v1 Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) pOld = (*Tsqlite3)(unsafe.Pointer(db)).FpProfileArg (*Tsqlite3)(unsafe.Pointer(db)).FxProfile = __ccgo_fp_xProfile (*Tsqlite3)(unsafe.Pointer(db)).FpProfileArg = pArg v1 = db + 94 *(*Tu8)(unsafe.Pointer(v1)) = Tu8(int32(*(*Tu8)(unsafe.Pointer(v1))) & libc.Int32FromInt32(SQLITE_TRACE_NONLEGACY_MASK)) if (*Tsqlite3)(unsafe.Pointer(db)).FxProfile != 0 { v1 = db + 94 *(*Tu8)(unsafe.Pointer(v1)) = Tu8(int32(*(*Tu8)(unsafe.Pointer(v1))) | libc.Int32FromInt32(SQLITE_TRACE_XPROFILE)) } Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) return pOld } // C documentation // // /* // ** Add new client data to a database connection. // */ func Xsqlite3_set_clientdata(tls *libc.TLS, db uintptr, zName uintptr, pData uintptr, __ccgo_fp_xDestructor uintptr) (r int32) { var n Tsize_t var p, pp uintptr _, _, _ = n, p, pp Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) pp = db + 548 p = (*Tsqlite3)(unsafe.Pointer(db)).FpDbData for { if !(p != 0 && libc.Xstrcmp(tls, p+12, zName) != 0) { break } pp = p goto _1 _1: ; p = (*TDbClientData)(unsafe.Pointer(p)).FpNext } if p != 0 { if (*TDbClientData)(unsafe.Pointer(p)).FxDestructor != 0 { (*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TDbClientData)(unsafe.Pointer(p)).FxDestructor})))(tls, (*TDbClientData)(unsafe.Pointer(p)).FpData) } if pData == uintptr(0) { **(**uintptr)(__ccgo_up(pp)) = (*TDbClientData)(unsafe.Pointer(p)).FpNext Xsqlite3_free(tls, p) Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) return SQLITE_OK } } else { if pData == uintptr(0) { Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) return SQLITE_OK } else { n = libc.Xstrlen(tls, zName) p = Xsqlite3_malloc64(tls, uint64(uint32(libc.UintptrFromInt32(0)+12)+(n+libc.Uint32FromInt32(1)))) if p == uintptr(0) { if __ccgo_fp_xDestructor != 0 { (*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_xDestructor})))(tls, pData) } Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) return int32(SQLITE_NOMEM) } libc.Xmemcpy(tls, p+12, zName, n+uint32(1)) (*TDbClientData)(unsafe.Pointer(p)).FpNext = (*Tsqlite3)(unsafe.Pointer(db)).FpDbData (*Tsqlite3)(unsafe.Pointer(db)).FpDbData = p } } (*TDbClientData)(unsafe.Pointer(p)).FpData = pData (*TDbClientData)(unsafe.Pointer(p)).FxDestructor = __ccgo_fp_xDestructor Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) return SQLITE_OK } // C documentation // // /* // ** Return 1 if the statement is an EXPLAIN and return 2 if the // ** statement is an EXPLAIN QUERY PLAN // */ func Xsqlite3_stmt_isexplain(tls *libc.TLS, pStmt uintptr) (r int32) { var v1 int32 _ = v1 if pStmt != 0 { v1 = int32(Tbft(*(*uint16)(unsafe.Pointer(pStmt + 152)) & 0xc >> 2)) } else { v1 = 0 } return v1 } // C documentation // // /* // ** Return true if the prepared statement is guaranteed to not modify the // ** database. // */ func Xsqlite3_stmt_readonly(tls *libc.TLS, pStmt uintptr) (r int32) { var v1 int32 _ = v1 if pStmt != 0 { v1 = int32(Tbft(*(*uint16)(unsafe.Pointer(pStmt + 152)) & 0x40 >> 6)) } else { v1 = int32(1) } return v1 } // C documentation // // /* Allocate and initialize a new dynamic string object */ func Xsqlite3_str_new(tls *libc.TLS, db uintptr) (r uintptr) { var p uintptr var v1 int32 _, _ = p, v1 p = Xsqlite3_malloc64(tls, uint64(24)) if p != 0 { if db != 0 { v1 = **(**int32)(__ccgo_up(db + 120)) } else { v1 = int32(SQLITE_MAX_LENGTH) } _sqlite3StrAccumInit(tls, p, uintptr(0), uintptr(0), 0, v1) } else { p = uintptr(unsafe.Pointer(&_sqlite3OomStr)) } return p } // C documentation // // /* Register a trace callback using the version-2 interface. // */ func Xsqlite3_trace_v2(tls *libc.TLS, db uintptr, mTrace uint32, __ccgo_fp_xTrace uintptr, pArg uintptr) (r int32) { Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) if mTrace == uint32(0) { __ccgo_fp_xTrace = uintptr(0) } if __ccgo_fp_xTrace == uintptr(0) { mTrace = uint32(0) } (*Tsqlite3)(unsafe.Pointer(db)).FmTrace = uint8(mTrace) *(*uintptr)(unsafe.Pointer(db + 220)) = __ccgo_fp_xTrace (*Tsqlite3)(unsafe.Pointer(db)).FpTraceArg = pArg Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex) return SQLITE_OK } // C documentation // // /* // ** Deprecated external interface. Internal/core SQLite code // ** should call sqlite3TransferBindings. // ** // ** It is misuse to call this routine with statements from different // ** database connections. But as this is a deprecated interface, we // ** will not bother to check for that condition. // ** // ** If the two statements contain a different number of bindings, then // ** an SQLITE_ERROR is returned. Nothing else can go wrong, so otherwise // ** SQLITE_OK is returned. // */ func Xsqlite3_transfer_bindings(tls *libc.TLS, pFromStmt uintptr, pToStmt uintptr) (r int32) { var pFrom, pTo uintptr _, _ = pFrom, pTo pFrom = pFromStmt pTo = pToStmt if int32((*TVdbe)(unsafe.Pointer(pFrom)).FnVar) != int32((*TVdbe)(unsafe.Pointer(pTo)).FnVar) { return int32(SQLITE_ERROR) } if (*TVdbe)(unsafe.Pointer(pTo)).Fexpmask != 0 { libc.SetBitFieldPtr16Uint32(pTo+152, libc.Uint32FromInt32(1), 0, 0x3) } if (*TVdbe)(unsafe.Pointer(pFrom)).Fexpmask != 0 { libc.SetBitFieldPtr16Uint32(pFrom+152, libc.Uint32FromInt32(1), 0, 0x3) } return _sqlite3TransferBindings(tls, pFromStmt, pToStmt) } // C documentation // // /* // ** Return the collating sequence for a constraint passed into xBestIndex. // ** // ** pIdxInfo must be an sqlite3_index_info structure passed into xBestIndex. // ** This routine depends on there being a HiddenIndexInfo structure immediately // ** following the sqlite3_index_info structure. // ** // ** Return a pointer to the collation name: // ** // ** 1. If there is an explicit COLLATE operator on the constraint, return it. // ** // ** 2. Else, if the column has an alternative collation, return that. // ** // ** 3. Otherwise, return "BINARY". // */ func Xsqlite3_vtab_collation(tls *libc.TLS, pIdxInfo uintptr, iCons int32) (r uintptr) { var iTerm int32 var pC, pHidden, pX, zRet, v1 uintptr _, _, _, _, _, _ = iTerm, pC, pHidden, pX, zRet, v1 pHidden = pIdxInfo + 1*72 zRet = uintptr(0) if iCons >= 0 && iCons < (*Tsqlite3_index_info)(unsafe.Pointer(pIdxInfo)).FnConstraint { pC = uintptr(0) iTerm = (**(**Tsqlite3_index_constraint)(__ccgo_up((*Tsqlite3_index_info)(unsafe.Pointer(pIdxInfo)).FaConstraint + uintptr(iCons)*12))).FiTermOffset pX = (*TWhereTerm)(unsafe.Pointer(_termFromWhereClause(tls, (*THiddenIndexInfo)(unsafe.Pointer(pHidden)).FpWC, iTerm))).FpExpr if (*TExpr)(unsafe.Pointer(pX)).FpLeft != 0 { pC = _sqlite3ExprCompareCollSeq(tls, (*THiddenIndexInfo)(unsafe.Pointer(pHidden)).FpParse, pX) } if pC != 0 { v1 = (*TCollSeq)(unsafe.Pointer(pC)).FzName } else { v1 = uintptr(unsafe.Pointer(&_sqlite3StrBINARY)) } zRet = v1 } return zRet } // C documentation // // /* // ** Return true if ORDER BY clause may be handled as DISTINCT. // */ func Xsqlite3_vtab_distinct(tls *libc.TLS, pIdxInfo uintptr) (r int32) { var pHidden uintptr _ = pHidden pHidden = pIdxInfo + 1*72 return (*THiddenIndexInfo)(unsafe.Pointer(pHidden)).FeDistinct } // C documentation // // /* // ** Return true if constraint iCons is really an IN(...) constraint, or // ** false otherwise. If iCons is an IN(...) constraint, set (if bHandle!=0) // ** or clear (if bHandle==0) the flag to handle it using an iterator. // */ func Xsqlite3_vtab_in(tls *libc.TLS, pIdxInfo uintptr, iCons int32, bHandle int32) (r int32) { var m Tu32 var pHidden uintptr var v1 uint32 _, _, _ = m, pHidden, v1 pHidden = pIdxInfo + 1*72 if iCons <= int32(31) { v1 = libc.Uint32FromInt32(1) << iCons } else { v1 = uint32(0) } m = v1 if m&(*THiddenIndexInfo)(unsafe.Pointer(pHidden)).FmIn != 0 { if bHandle == 0 { **(**Tu32)(__ccgo_up(pHidden + 16)) &= ^m } else { if bHandle > 0 { **(**Tu32)(__ccgo_up(pHidden + 16)) |= m } } return int32(1) } return 0 } // C documentation // // /* // ** This interface is callable from within the xBestIndex callback only. // ** // ** If possible, set (*ppVal) to point to an object containing the value // ** on the right-hand-side of constraint iCons. // */ func Xsqlite3_vtab_rhs_value(tls *libc.TLS, pIdxInfo uintptr, iCons int32, ppVal uintptr) (r int32) { var pH, pTerm, pVal uintptr var rc int32 _, _, _, _ = pH, pTerm, pVal, rc pH = pIdxInfo + 1*72 pVal = uintptr(0) rc = SQLITE_OK if iCons < 0 || iCons >= (*Tsqlite3_index_info)(unsafe.Pointer(pIdxInfo)).FnConstraint { rc = _sqlite3MisuseError(tls, int32(173448)) /* EV: R-30545-25046 */ } else { if *(*uintptr)(unsafe.Pointer(pH + 20 + uintptr(iCons)*4)) == uintptr(0) { pTerm = _termFromWhereClause(tls, (*THiddenIndexInfo)(unsafe.Pointer(pH)).FpWC, (**(**Tsqlite3_index_constraint)(__ccgo_up((*Tsqlite3_index_info)(unsafe.Pointer(pIdxInfo)).FaConstraint + uintptr(iCons)*12))).FiTermOffset) rc = _sqlite3ValueFromExpr(tls, (*TParse)(unsafe.Pointer((*THiddenIndexInfo)(unsafe.Pointer(pH)).FpParse)).Fdb, (*TExpr)(unsafe.Pointer((*TWhereTerm)(unsafe.Pointer(pTerm)).FpExpr)).FpRight, (*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer((*THiddenIndexInfo)(unsafe.Pointer(pH)).FpParse)).Fdb)).Fenc, uint8(SQLITE_AFF_BLOB), pH+20+uintptr(iCons)*4) } pVal = *(*uintptr)(unsafe.Pointer(pH + 20 + uintptr(iCons)*4)) } **(**uintptr)(__ccgo_up(ppVal)) = pVal if rc == SQLITE_OK && pVal == uintptr(0) { /* IMP: R-19933-32160 */ rc = int32(SQLITE_NOTFOUND) /* IMP: R-36424-56542 */ } return rc } // C documentation // // /* // ** Add connection db to the blocked connections list. It is assumed // ** that it is not already a part of the list. // */ func _addToBlockedList(tls *libc.TLS, db uintptr) { var pp uintptr _ = pp pp = uintptr(unsafe.Pointer(&_sqlite3BlockedList)) for { if !(**(**uintptr)(__ccgo_up(pp)) != 0 && (*Tsqlite3)(unsafe.Pointer(**(**uintptr)(__ccgo_up(pp)))).FxUnlockNotify != (*Tsqlite3)(unsafe.Pointer(db)).FxUnlockNotify) { break } goto _1 _1: ; pp = **(**uintptr)(__ccgo_up(pp)) + 576 } (*Tsqlite3)(unsafe.Pointer(db)).FpNextBlocked = **(**uintptr)(__ccgo_up(pp)) **(**uintptr)(__ccgo_up(pp)) = db } // C documentation // // /* // ** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should // ** have already been reserved using growVTrans(). // */ func _addToVTrans(tls *libc.TLS, db uintptr, pVTab uintptr) { var v1 int32 var v2 uintptr _, _ = v1, v2 /* Add pVtab to the end of sqlite3.aVTrans */ v2 = db + 400 v1 = *(*int32)(unsafe.Pointer(v2)) *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 **(**uintptr)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaVTrans + uintptr(v1)*4)) = pVTab _sqlite3VtabLock(tls, pVTab) } // C documentation // // /* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf // ** from the ReusableSpace object. Return a pointer to the allocated // ** memory on success. If insufficient memory is available in the // ** ReusableSpace object, increase the ReusableSpace.nNeeded // ** value by the amount needed and return NULL. // ** // ** If pBuf is not initially NULL, that means that the memory has already // ** been allocated by a prior call to this routine, so just return a copy // ** of pBuf and leave ReusableSpace unchanged. // ** // ** This allocator is employed to repurpose unused slots at the end of the // ** opcode array of prepared state for other memory needs of the prepared // ** statement. // */ func _allocSpace(tls *libc.TLS, p uintptr, pBuf uintptr, nByte Tsqlite3_int64) (r uintptr) { if pBuf == uintptr(0) { nByte = (nByte + libc.Int64FromInt32(7)) & int64(^libc.Int32FromInt32(7)) if nByte <= (*TReusableSpace)(unsafe.Pointer(p)).FnFree { **(**Tsqlite3_int64)(__ccgo_up(p + 8)) -= nByte pBuf = (*TReusableSpace)(unsafe.Pointer(p)).FpSpace + uintptr((*TReusableSpace)(unsafe.Pointer(p)).FnFree) } else { **(**Tsqlite3_int64)(__ccgo_up(p + 16)) += nByte } } return pBuf } // C documentation // // /* // ** Invoke the busy handler for a btree. // */ func _btreeInvokeBusyHandler(tls *libc.TLS, pArg uintptr) (r int32) { var pBt uintptr _ = pBt pBt = pArg return _sqlite3InvokeBusyHandler(tls, (*TBtShared)(unsafe.Pointer(pBt)).Fdb+464) } // C documentation // // /* // ** Release all of the apPage[] pages for a cursor. // */ func _btreeReleaseAllCursorPages(tls *libc.TLS, pCur uintptr) { var i int32 _ = i if int32((*TBtCursor)(unsafe.Pointer(pCur)).FiPage) >= 0 { i = 0 for { if !(i < int32((*TBtCursor)(unsafe.Pointer(pCur)).FiPage)) { break } _releasePageNotNull(tls, **(**uintptr)(__ccgo_up(pCur + 120 + uintptr(i)*4))) goto _1 _1: ; i = i + 1 } _releasePageNotNull(tls, (*TBtCursor)(unsafe.Pointer(pCur)).FpPage) (*TBtCursor)(unsafe.Pointer(pCur)).FiPage = int8(-int32(1)) } } // C documentation // // /* // ** Invoke the progress handler, if appropriate. Also check for an // ** interrupt. // */ func _checkProgress(tls *libc.TLS, pCheck uintptr) { var db uintptr _ = db db = (*TIntegrityCk)(unsafe.Pointer(pCheck)).Fdb if libc.AtomicLoadNInt32(db+312, libc.Int32FromInt32(__ATOMIC_RELAXED)) != 0 { (*TIntegrityCk)(unsafe.Pointer(pCheck)).Frc = int32(SQLITE_INTERRUPT) (*TIntegrityCk)(unsafe.Pointer(pCheck)).FnErr = (*TIntegrityCk)(unsafe.Pointer(pCheck)).FnErr + 1 (*TIntegrityCk)(unsafe.Pointer(pCheck)).FmxErr = 0 } if (*Tsqlite3)(unsafe.Pointer(db)).FxProgress != 0 { (*TIntegrityCk)(unsafe.Pointer(pCheck)).FnStep = (*TIntegrityCk)(unsafe.Pointer(pCheck)).FnStep + 1 if (*TIntegrityCk)(unsafe.Pointer(pCheck)).FnStep%(*Tsqlite3)(unsafe.Pointer(db)).FnProgressOps == uint32(0) && (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3)(unsafe.Pointer(db)).FxProgress})))(tls, (*Tsqlite3)(unsafe.Pointer(db)).FpProgressArg) != 0 { (*TIntegrityCk)(unsafe.Pointer(pCheck)).Frc = int32(SQLITE_INTERRUPT) (*TIntegrityCk)(unsafe.Pointer(pCheck)).FnErr = (*TIntegrityCk)(unsafe.Pointer(pCheck)).FnErr + 1 (*TIntegrityCk)(unsafe.Pointer(pCheck)).FmxErr = 0 } } } // C documentation // // /* // ** Close all cursors. // ** // ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory // ** cell array. This is necessary as the memory cell array may contain // ** pointers to VdbeFrame objects, which may in turn contain pointers to // ** open cursors. // */ func _closeAllCursors(tls *libc.TLS, p uintptr) { var pDel, pFrame uintptr _, _ = pDel, pFrame if (*TVdbe)(unsafe.Pointer(p)).FpFrame != 0 { pFrame = (*TVdbe)(unsafe.Pointer(p)).FpFrame for { if !((*TVdbeFrame)(unsafe.Pointer(pFrame)).FpParent != 0) { break } goto _1 _1: ; pFrame = (*TVdbeFrame)(unsafe.Pointer(pFrame)).FpParent } _sqlite3VdbeFrameRestore(tls, pFrame) (*TVdbe)(unsafe.Pointer(p)).FpFrame = uintptr(0) (*TVdbe)(unsafe.Pointer(p)).FnFrame = 0 } _closeCursorsInFrame(tls, p) _releaseMemArray(tls, (*TVdbe)(unsafe.Pointer(p)).FaMem, (*TVdbe)(unsafe.Pointer(p)).FnMem) for (*TVdbe)(unsafe.Pointer(p)).FpDelFrame != 0 { pDel = (*TVdbe)(unsafe.Pointer(p)).FpDelFrame (*TVdbe)(unsafe.Pointer(p)).FpDelFrame = (*TVdbeFrame)(unsafe.Pointer(pDel)).FpParent _sqlite3VdbeFrameDelete(tls, pDel) } /* Delete any auxdata allocations made by the VM */ if (*TVdbe)(unsafe.Pointer(p)).FpAuxData != 0 { _sqlite3VdbeDeleteAuxData(tls, (*TVdbe)(unsafe.Pointer(p)).Fdb, p+228, -int32(1), 0) } } // C documentation // // /* // ** Free an sqlite3_index_info structure allocated by allocateIndexInfo() // ** and possibly modified by xBestIndex methods. // */ func _freeIndexInfo(tls *libc.TLS, db uintptr, pIdxInfo uintptr) { var i int32 var pHidden uintptr _, _ = i, pHidden pHidden = pIdxInfo + 1*72 i = 0 for { if !(i < (*Tsqlite3_index_info)(unsafe.Pointer(pIdxInfo)).FnConstraint) { break } _sqlite3ValueFree(tls, *(*uintptr)(unsafe.Pointer(pHidden + 20 + uintptr(i)*4))) /* IMP: R-14553-25174 */ *(*uintptr)(unsafe.Pointer(pHidden + 20 + uintptr(i)*4)) = uintptr(0) goto _1 _1: ; i = i + 1 } _freeIdxStr(tls, pIdxInfo) _sqlite3DbFree(tls, db, pIdxInfo) } // C documentation // // /* // ** Allocate a new segment-id for the structure pStruct. The new segment // ** id must be between 1 and 65335 inclusive, and must not be used by // ** any currently existing segment. If a free segment id cannot be found, // ** SQLITE_FULL is returned. // ** // ** If an error has already occurred, this function is a no-op. 0 is // ** returned in this case. // */ func _fts5AllocateSegid(tls *libc.TLS, p uintptr, pStruct uintptr) (r int32) { bp := tls.Alloc(256) defer tls.Free(256) var i, iId, iLvl, iSeg, iSegid int32 var mask Tu32 var _ /* aUsed at bp+0 */ [63]Tu32 _, _, _, _, _, _ = i, iId, iLvl, iSeg, iSegid, mask iSegid = 0 if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK { if (*TFts5Structure)(unsafe.Pointer(pStruct)).FnSegment >= int32(FTS5_MAX_SEGMENT) { (*TFts5Index)(unsafe.Pointer(p)).Frc = int32(SQLITE_FULL) } else { libc.Xmemset(tls, bp, 0, uint32(252)) iLvl = 0 for { if !(iLvl < (*TFts5Structure)(unsafe.Pointer(pStruct)).FnLevel) { break } iSeg = 0 for { if !(iSeg < (*(*TFts5StructureLevel)(unsafe.Pointer(pStruct + 32 + uintptr(iLvl)*12))).FnSeg) { break } iId = (**(**TFts5StructureSegment)(__ccgo_up((*(*TFts5StructureLevel)(unsafe.Pointer(pStruct + 32 + uintptr(iLvl)*12))).FaSeg + uintptr(iSeg)*56))).FiSegid if iId <= int32(FTS5_MAX_SEGMENT) && iId > 0 { **(**Tu32)(__ccgo_up(bp + uintptr((iId-int32(1))/int32(32))*4)) |= libc.Uint32FromInt32(1) << ((iId - int32(1)) % int32(32)) } goto _2 _2: ; iSeg = iSeg + 1 } goto _1 _1: ; iLvl = iLvl + 1 } i = 0 for { if !((**(**[63]Tu32)(__ccgo_up(bp)))[i] == uint32(0xFFFFFFFF)) { break } goto _3 _3: ; i = i + 1 } mask = (**(**[63]Tu32)(__ccgo_up(bp)))[i] iSegid = 0 for { if !(mask&(libc.Uint32FromInt32(1)<= _sqlite3Fts5ExprPhraseCount(tls, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpExpr) { rc = int32(SQLITE_RANGE) } else { if (*TFts5Config)(unsafe.Pointer(pConfig)).FeDetail != FTS5_DETAIL_FULL && _fts5IsContentless(tls, (*TFts5Cursor)(unsafe.Pointer(pCsr)).Fbase.FpVtab, int32(1)) != 0 { **(**uintptr)(__ccgo_up(pa)) = uintptr(0) **(**int32)(__ccgo_up(pn)) = 0 return SQLITE_OK } else { if (*TFts5Cursor)(unsafe.Pointer(pCsr)).Fcsrflags&int32(FTS5CSR_REQUIRE_POSLIST) != 0 { if (*TFts5Config)(unsafe.Pointer(pConfig)).FeDetail != FTS5_DETAIL_FULL { aPopulator = _sqlite3Fts5ExprClearPoslists(tls, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpExpr, bLive) if aPopulator == uintptr(0) { rc = int32(SQLITE_NOMEM) } if rc == SQLITE_OK { rc = _fts5SeekCursor(tls, pCsr, 0) } i = 0 for { if !(i < (*TFts5Config)(unsafe.Pointer(pConfig)).FnCol && rc == SQLITE_OK) { break } **(**uintptr)(__ccgo_up(bp)) = uintptr(0) **(**int32)(__ccgo_up(bp + 4)) = 0 rc = _fts5TextFromStmt(tls, pConfig, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpStmt, i, bp, bp+4) if rc == SQLITE_OK { rc = _sqlite3Fts5ExprPopulatePoslists(tls, pConfig, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpExpr, aPopulator, i, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4))) } _sqlite3Fts5ClearLocale(tls, pConfig) goto _1 _1: ; i = i + 1 } Xsqlite3_free(tls, aPopulator) if (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpSorter != 0 { _sqlite3Fts5ExprCheckPoslists(tls, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpExpr, (*TFts5Sorter)(unsafe.Pointer((*TFts5Cursor)(unsafe.Pointer(pCsr)).FpSorter)).FiRowid) } } **(**int32)(__ccgo_up(pCsr + 60)) &= ^libc.Int32FromInt32(FTS5CSR_REQUIRE_POSLIST) } } } if rc == SQLITE_OK { if (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpSorter != 0 && (*TFts5Config)(unsafe.Pointer(pConfig)).FeDetail == FTS5_DETAIL_FULL { pSorter = (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpSorter if iPhrase == 0 { v2 = 0 } else { v2 = *(*int32)(unsafe.Pointer(pSorter + 24 + uintptr(iPhrase-int32(1))*4)) } i1 = v2 **(**int32)(__ccgo_up(pn)) = *(*int32)(unsafe.Pointer(pSorter + 24 + uintptr(iPhrase)*4)) - i1 **(**uintptr)(__ccgo_up(pa)) = (*TFts5Sorter)(unsafe.Pointer(pSorter)).FaPoslist + uintptr(i1) } else { **(**int32)(__ccgo_up(pn)) = _sqlite3Fts5ExprPoslist(tls, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpExpr, iPhrase, pa) } } else { **(**uintptr)(__ccgo_up(pa)) = uintptr(0) **(**int32)(__ccgo_up(pn)) = 0 } return rc } func _fts5CursorFirst(tls *libc.TLS, pTab uintptr, pCsr uintptr, bDesc int32) (r int32) { var pExpr uintptr var rc int32 _, _ = pExpr, rc pExpr = (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpExpr rc = _sqlite3Fts5ExprFirst(tls, pExpr, (*TFts5FullTable)(unsafe.Pointer(pTab)).Fp.FpIndex, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FiFirstRowid, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FiLastRowid, bDesc) if _sqlite3Fts5ExprEof(tls, pExpr) != 0 { **(**int32)(__ccgo_up(pCsr + 60)) |= int32(FTS5CSR_EOF) } _fts5CsrNewrow(tls, pCsr) return rc } // C documentation // // /* // ** If the REQUIRE_RESEEK flag is set on the cursor passed as the first // ** argument, close and reopen all Fts5IndexIter iterators that the cursor // ** is using. Then attempt to move the cursor to a rowid equal to or laster // ** (in the cursors sort order - ASC or DESC) than the current rowid. // ** // ** If the new rowid is not equal to the old, set output parameter *pbSkip // ** to 1 before returning. Otherwise, leave it unchanged. // ** // ** Return SQLITE_OK if successful or if no reseek was required, or an // ** error code if an error occurred. // */ func _fts5CursorReseek(tls *libc.TLS, pCsr uintptr, pbSkip uintptr) (r int32) { var bDesc, rc int32 var iRowid Ti64 var pTab uintptr _, _, _, _ = bDesc, iRowid, pTab, rc rc = SQLITE_OK if (*TFts5Cursor)(unsafe.Pointer(pCsr)).Fcsrflags&int32(FTS5CSR_REQUIRE_RESEEK) != 0 { pTab = (*TFts5Cursor)(unsafe.Pointer(pCsr)).Fbase.FpVtab bDesc = (*TFts5Cursor)(unsafe.Pointer(pCsr)).FbDesc iRowid = _sqlite3Fts5ExprRowid(tls, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpExpr) rc = _sqlite3Fts5ExprFirst(tls, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpExpr, (*TFts5FullTable)(unsafe.Pointer(pTab)).Fp.FpIndex, iRowid, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FiLastRowid, bDesc) if rc == SQLITE_OK && iRowid != _sqlite3Fts5ExprRowid(tls, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpExpr) { **(**int32)(__ccgo_up(pbSkip)) = int32(1) } **(**int32)(__ccgo_up(pCsr + 60)) &= ^libc.Int32FromInt32(FTS5CSR_REQUIRE_RESEEK) _fts5CsrNewrow(tls, pCsr) if _sqlite3Fts5ExprEof(tls, (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpExpr) != 0 { **(**int32)(__ccgo_up(pCsr + 60)) |= int32(FTS5CSR_EOF) **(**int32)(__ccgo_up(pbSkip)) = int32(1) } } return rc } func _fts5DlidxIterLast(tls *libc.TLS, p uintptr, pIter uintptr) { var i int32 var pChild, pLvl uintptr _, _, _ = i, pChild, pLvl /* Advance each level to the last entry on the last page */ i = (*TFts5DlidxIter)(unsafe.Pointer(pIter)).FnLvl - int32(1) for { if !((*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK && i >= 0) { break } pLvl = pIter + 8 + uintptr(i)*32 for _fts5DlidxLvlNext(tls, pLvl) == 0 { } (*TFts5DlidxLvl)(unsafe.Pointer(pLvl)).FbEof = 0 if i > 0 { pChild = pLvl + uintptr(-libc.Int32FromInt32(1))*32 _fts5DataRelease(tls, (*TFts5DlidxLvl)(unsafe.Pointer(pChild)).FpData) libc.Xmemset(tls, pChild, 0, uint32(32)) (*TFts5DlidxLvl)(unsafe.Pointer(pChild)).FpData = _fts5DataRead(tls, p, int64((*TFts5DlidxIter)(unsafe.Pointer(pIter)).FiSegid)<<(libc.Int32FromInt32(FTS5_DATA_PAGE_B)+libc.Int32FromInt32(FTS5_DATA_HEIGHT_B)+libc.Int32FromInt32(FTS5_DATA_DLI_B))+int64(libc.Int32FromInt32(1))<<(libc.Int32FromInt32(FTS5_DATA_PAGE_B)+libc.Int32FromInt32(FTS5_DATA_HEIGHT_B))+int64(i-libc.Int32FromInt32(1))< 0 { (*TFts5DoclistIter)(unsafe.Pointer(pIter)).FaPoslist = (*TFts5Buffer)(unsafe.Pointer(pBuf)).Fp (*TFts5DoclistIter)(unsafe.Pointer(pIter)).FaEof = (*TFts5Buffer)(unsafe.Pointer(pBuf)).Fp + uintptr((*TFts5Buffer)(unsafe.Pointer(pBuf)).Fn) _fts5DoclistIterNext(tls, pIter) } } func _fts5ExprCheckPoslists(tls *libc.TLS, pNode uintptr, iRowid Ti64) (r int32) { var bRet, i, i1 int32 _, _, _ = bRet, i, i1 (*TFts5ExprNode)(unsafe.Pointer(pNode)).FiRowid = iRowid (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbEof = 0 switch (*TFts5ExprNode)(unsafe.Pointer(pNode)).FeType { case 0: fallthrough case int32(FTS5_TERM): fallthrough case int32(FTS5_STRING): return libc.BoolInt32((*TFts5ExprPhrase)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TFts5ExprNode)(unsafe.Pointer(pNode)).FpNear + 12)))).Fposlist.Fn > 0) case int32(FTS5_AND): i = 0 for { if !(i < (*TFts5ExprNode)(unsafe.Pointer(pNode)).FnChild) { break } if _fts5ExprCheckPoslists(tls, *(*uintptr)(unsafe.Pointer(pNode + 40 + uintptr(i)*4)), iRowid) == 0 { _fts5ExprClearPoslists(tls, pNode) return 0 } goto _1 _1: ; i = i + 1 } case int32(FTS5_OR): bRet = 0 i1 = 0 for { if !(i1 < (*TFts5ExprNode)(unsafe.Pointer(pNode)).FnChild) { break } if _fts5ExprCheckPoslists(tls, *(*uintptr)(unsafe.Pointer(pNode + 40 + uintptr(i1)*4)), iRowid) != 0 { bRet = int32(1) } goto _2 _2: ; i1 = i1 + 1 } return bRet default: if 0 == _fts5ExprCheckPoslists(tls, *(*uintptr)(unsafe.Pointer(pNode + 40)), iRowid) || 0 != _fts5ExprCheckPoslists(tls, *(*uintptr)(unsafe.Pointer(pNode + 40 + 1*4)), iRowid) { _fts5ExprClearPoslists(tls, pNode) return 0 } break } return int32(1) } func _fts5ExprClearPoslists(tls *libc.TLS, pNode uintptr) { var i int32 _ = i if (*TFts5ExprNode)(unsafe.Pointer(pNode)).FeType == int32(FTS5_TERM) || (*TFts5ExprNode)(unsafe.Pointer(pNode)).FeType == int32(FTS5_STRING) { (*TFts5ExprPhrase)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TFts5ExprNode)(unsafe.Pointer(pNode)).FpNear + 12)))).Fposlist.Fn = 0 } else { i = 0 for { if !(i < (*TFts5ExprNode)(unsafe.Pointer(pNode)).FnChild) { break } _fts5ExprClearPoslists(tls, *(*uintptr)(unsafe.Pointer(pNode + 40 + uintptr(i)*4))) goto _1 _1: ; i = i + 1 } } } // C documentation // // /* // ** Set node pNode, which is part of expression pExpr, to point to the first // ** match. If there are no matches, set the Node.bEof flag to indicate EOF. // ** // ** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise. // ** It is not an error if there are no matches. // */ func _fts5ExprNodeFirst(tls *libc.TLS, pExpr uintptr, pNode uintptr) (r int32) { var i, nEof, rc int32 var pChild uintptr _, _, _, _ = i, nEof, pChild, rc rc = SQLITE_OK (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbEof = 0 (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbNomatch = 0 if (*TFts5ExprNode)(unsafe.Pointer(pNode)).FeType == int32(FTS5_TERM) || (*TFts5ExprNode)(unsafe.Pointer(pNode)).FeType == int32(FTS5_STRING) { /* Initialize all term iterators in the NEAR object. */ rc = _fts5ExprNearInitAll(tls, pExpr, pNode) } else { if (*TFts5ExprNode)(unsafe.Pointer(pNode)).FxNext == uintptr(0) { (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbEof = int32(1) } else { nEof = 0 i = 0 for { if !(i < (*TFts5ExprNode)(unsafe.Pointer(pNode)).FnChild && rc == SQLITE_OK) { break } pChild = *(*uintptr)(unsafe.Pointer(pNode + 40 + uintptr(i)*4)) rc = _fts5ExprNodeFirst(tls, pExpr, *(*uintptr)(unsafe.Pointer(pNode + 40 + uintptr(i)*4))) nEof = nEof + (*TFts5ExprNode)(unsafe.Pointer(pChild)).FbEof goto _1 _1: ; i = i + 1 } (*TFts5ExprNode)(unsafe.Pointer(pNode)).FiRowid = (*TFts5ExprNode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pNode + 40)))).FiRowid switch (*TFts5ExprNode)(unsafe.Pointer(pNode)).FeType { case int32(FTS5_AND): if nEof > 0 { _fts5ExprSetEof(tls, pNode) } case int32(FTS5_OR): if (*TFts5ExprNode)(unsafe.Pointer(pNode)).FnChild == nEof { _fts5ExprSetEof(tls, pNode) } default: (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbEof = (*TFts5ExprNode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pNode + 40)))).FbEof break } } } if rc == SQLITE_OK { rc = _fts5ExprNodeTest(tls, pExpr, pNode) } return rc } func _fts5ExprNodeNext_AND(tls *libc.TLS, pExpr uintptr, pNode uintptr, bFromValid int32, iFrom Ti64) (r int32) { var rc int32 _ = rc rc = (*(*func(*libc.TLS, uintptr, uintptr, int32, Ti64) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExprNode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pNode + 40)))).FxNext})))(tls, pExpr, *(*uintptr)(unsafe.Pointer(pNode + 40)), bFromValid, iFrom) if rc == SQLITE_OK { rc = _fts5ExprNodeTest_AND(tls, pExpr, pNode) } else { (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbNomatch = 0 } return rc } func _fts5ExprNodeNext_NOT(tls *libc.TLS, pExpr uintptr, pNode uintptr, bFromValid int32, iFrom Ti64) (r int32) { var rc int32 _ = rc rc = (*(*func(*libc.TLS, uintptr, uintptr, int32, Ti64) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExprNode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pNode + 40)))).FxNext})))(tls, pExpr, *(*uintptr)(unsafe.Pointer(pNode + 40)), bFromValid, iFrom) if rc == SQLITE_OK { rc = _fts5ExprNodeTest_NOT(tls, pExpr, pNode) } if rc != SQLITE_OK { (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbNomatch = 0 } return rc } func _fts5ExprNodeNext_OR(tls *libc.TLS, pExpr uintptr, pNode uintptr, bFromValid int32, iFrom Ti64) (r int32) { var i, rc int32 var iLast Ti64 var p1 uintptr _, _, _, _ = i, iLast, p1, rc iLast = (*TFts5ExprNode)(unsafe.Pointer(pNode)).FiRowid i = 0 for { if !(i < (*TFts5ExprNode)(unsafe.Pointer(pNode)).FnChild) { break } p1 = *(*uintptr)(unsafe.Pointer(pNode + 40 + uintptr(i)*4)) if (*TFts5ExprNode)(unsafe.Pointer(p1)).FbEof == 0 { if (*TFts5ExprNode)(unsafe.Pointer(p1)).FiRowid == iLast || bFromValid != 0 && _fts5RowidCmp(tls, pExpr, (*TFts5ExprNode)(unsafe.Pointer(p1)).FiRowid, iFrom) < 0 { rc = (*(*func(*libc.TLS, uintptr, uintptr, int32, Ti64) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExprNode)(unsafe.Pointer(p1)).FxNext})))(tls, pExpr, p1, bFromValid, iFrom) if rc != SQLITE_OK { (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbNomatch = 0 return rc } } } goto _1 _1: ; i = i + 1 } _fts5ExprNodeTest_OR(tls, pExpr, pNode) return SQLITE_OK } // C documentation // // /* // ** Argument pNode is an FTS5_AND node. // */ func _fts5ExprNodeTest_AND(tls *libc.TLS, pExpr uintptr, pAnd uintptr) (r int32) { var bMatch, cmp, iChild, rc int32 var iLast Ti64 var pChild uintptr _, _, _, _, _, _ = bMatch, cmp, iChild, iLast, pChild, rc iLast = (*TFts5ExprNode)(unsafe.Pointer(pAnd)).FiRowid rc = SQLITE_OK for cond := true; cond; cond = bMatch == 0 { (*TFts5ExprNode)(unsafe.Pointer(pAnd)).FbNomatch = 0 bMatch = int32(1) iChild = 0 for { if !(iChild < (*TFts5ExprNode)(unsafe.Pointer(pAnd)).FnChild) { break } pChild = *(*uintptr)(unsafe.Pointer(pAnd + 40 + uintptr(iChild)*4)) cmp = _fts5RowidCmp(tls, pExpr, iLast, (*TFts5ExprNode)(unsafe.Pointer(pChild)).FiRowid) if cmp > 0 { /* Advance pChild until it points to iLast or laster */ rc = (*(*func(*libc.TLS, uintptr, uintptr, int32, Ti64) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExprNode)(unsafe.Pointer(pChild)).FxNext})))(tls, pExpr, pChild, int32(1), iLast) if rc != SQLITE_OK { (*TFts5ExprNode)(unsafe.Pointer(pAnd)).FbNomatch = 0 return rc } } /* If the child node is now at EOF, so is the parent AND node. Otherwise, ** the child node is guaranteed to have advanced at least as far as ** rowid iLast. So if it is not at exactly iLast, pChild->iRowid is the ** new lastest rowid seen so far. */ if (*TFts5ExprNode)(unsafe.Pointer(pChild)).FbEof != 0 { _fts5ExprSetEof(tls, pAnd) bMatch = int32(1) break } else { if iLast != (*TFts5ExprNode)(unsafe.Pointer(pChild)).FiRowid { bMatch = 0 iLast = (*TFts5ExprNode)(unsafe.Pointer(pChild)).FiRowid } } if (*TFts5ExprNode)(unsafe.Pointer(pChild)).FbNomatch != 0 { (*TFts5ExprNode)(unsafe.Pointer(pAnd)).FbNomatch = int32(1) } goto _1 _1: ; iChild = iChild + 1 } } if (*TFts5ExprNode)(unsafe.Pointer(pAnd)).FbNomatch != 0 && pAnd != (*TFts5Expr)(unsafe.Pointer(pExpr)).FpRoot { _fts5ExprNodeZeroPoslist(tls, pAnd) } (*TFts5ExprNode)(unsafe.Pointer(pAnd)).FiRowid = iLast return SQLITE_OK } func _fts5ExprNodeTest_NOT(tls *libc.TLS, pExpr uintptr, pNode uintptr) (r int32) { var cmp, rc int32 var p1, p2 uintptr _, _, _, _ = cmp, p1, p2, rc rc = SQLITE_OK p1 = *(*uintptr)(unsafe.Pointer(pNode + 40)) p2 = *(*uintptr)(unsafe.Pointer(pNode + 40 + 1*4)) for rc == SQLITE_OK && (*TFts5ExprNode)(unsafe.Pointer(p1)).FbEof == 0 { cmp = _fts5NodeCompare(tls, pExpr, p1, p2) if cmp > 0 { rc = (*(*func(*libc.TLS, uintptr, uintptr, int32, Ti64) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExprNode)(unsafe.Pointer(p2)).FxNext})))(tls, pExpr, p2, int32(1), (*TFts5ExprNode)(unsafe.Pointer(p1)).FiRowid) cmp = _fts5NodeCompare(tls, pExpr, p1, p2) } if cmp != 0 || (*TFts5ExprNode)(unsafe.Pointer(p2)).FbNomatch != 0 { break } rc = (*(*func(*libc.TLS, uintptr, uintptr, int32, Ti64) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExprNode)(unsafe.Pointer(p1)).FxNext})))(tls, pExpr, p1, 0, int64(libc.Int32FromInt32(0))) } (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbEof = (*TFts5ExprNode)(unsafe.Pointer(p1)).FbEof (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbNomatch = (*TFts5ExprNode)(unsafe.Pointer(p1)).FbNomatch (*TFts5ExprNode)(unsafe.Pointer(pNode)).FiRowid = (*TFts5ExprNode)(unsafe.Pointer(p1)).FiRowid if (*TFts5ExprNode)(unsafe.Pointer(p1)).FbEof != 0 { _fts5ExprNodeZeroPoslist(tls, p2) } return rc } func _fts5ExprNodeTest_OR(tls *libc.TLS, pExpr uintptr, pNode uintptr) { var cmp, i int32 var pChild, pNext uintptr _, _, _, _ = cmp, i, pChild, pNext pNext = *(*uintptr)(unsafe.Pointer(pNode + 40)) i = int32(1) for { if !(i < (*TFts5ExprNode)(unsafe.Pointer(pNode)).FnChild) { break } pChild = *(*uintptr)(unsafe.Pointer(pNode + 40 + uintptr(i)*4)) cmp = _fts5NodeCompare(tls, pExpr, pNext, pChild) if cmp > 0 || cmp == 0 && (*TFts5ExprNode)(unsafe.Pointer(pChild)).FbNomatch == 0 { pNext = pChild } goto _1 _1: ; i = i + 1 } (*TFts5ExprNode)(unsafe.Pointer(pNode)).FiRowid = (*TFts5ExprNode)(unsafe.Pointer(pNext)).FiRowid (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbEof = (*TFts5ExprNode)(unsafe.Pointer(pNext)).FbEof (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbNomatch = (*TFts5ExprNode)(unsafe.Pointer(pNext)).FbNomatch } func _fts5ExprNodeZeroPoslist(tls *libc.TLS, pNode uintptr) { var i, i1 int32 var pNear, pPhrase uintptr _, _, _, _ = i, i1, pNear, pPhrase if (*TFts5ExprNode)(unsafe.Pointer(pNode)).FeType == int32(FTS5_STRING) || (*TFts5ExprNode)(unsafe.Pointer(pNode)).FeType == int32(FTS5_TERM) { pNear = (*TFts5ExprNode)(unsafe.Pointer(pNode)).FpNear i = 0 for { if !(i < (*TFts5ExprNearset)(unsafe.Pointer(pNear)).FnPhrase) { break } pPhrase = *(*uintptr)(unsafe.Pointer(pNear + 12 + uintptr(i)*4)) (*TFts5ExprPhrase)(unsafe.Pointer(pPhrase)).Fposlist.Fn = 0 goto _1 _1: ; i = i + 1 } } else { i1 = 0 for { if !(i1 < (*TFts5ExprNode)(unsafe.Pointer(pNode)).FnChild) { break } _fts5ExprNodeZeroPoslist(tls, *(*uintptr)(unsafe.Pointer(pNode + 40 + uintptr(i1)*4))) goto _2 _2: ; i1 = i1 + 1 } } } func _fts5ExprSetEof(tls *libc.TLS, pNode uintptr) { var i int32 _ = i (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbEof = int32(1) (*TFts5ExprNode)(unsafe.Pointer(pNode)).FbNomatch = 0 i = 0 for { if !(i < (*TFts5ExprNode)(unsafe.Pointer(pNode)).FnChild) { break } _fts5ExprSetEof(tls, *(*uintptr)(unsafe.Pointer(pNode + 40 + uintptr(i)*4))) goto _1 _1: ; i = i + 1 } } // C documentation // // /* // ** Allocate and return a buffer at least nByte bytes in size. // ** // ** If an OOM error is encountered, return NULL and set the error code in // ** the Fts5Index handle passed as the first argument. // */ func _fts5IdxMalloc(tls *libc.TLS, p uintptr, nByte Tsqlite3_int64) (r uintptr) { return _sqlite3Fts5MallocZero(tls, p+44, nByte) } /* ** Compare the contents of the pLeft buffer with the pRight/nRight blob. ** ** Return -ve if pLeft is smaller than pRight, 0 if they are equal or ** +ve if pRight is smaller than pLeft. In other words: ** ** res = *pLeft - *pRight */ func _fts5IndexCrisismerge(tls *libc.TLS, p uintptr, ppStruct uintptr) { bp := tls.Alloc(16) defer tls.Free(16) var iLvl, nCrisis int32 var _ /* pStruct at bp+0 */ uintptr _, _ = iLvl, nCrisis nCrisis = (*TFts5Config)(unsafe.Pointer((*TFts5Index)(unsafe.Pointer(p)).FpConfig)).FnCrisisMerge **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(ppStruct)) if **(**uintptr)(__ccgo_up(bp)) != 0 && (*TFts5Structure)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp)))).FnLevel > 0 { iLvl = 0 for (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK && (*(*TFts5StructureLevel)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp)) + 32 + uintptr(iLvl)*12))).FnSeg >= nCrisis { _fts5IndexMergeLevel(tls, p, bp, iLvl, uintptr(0)) _fts5StructurePromote(tls, p, iLvl+int32(1), **(**uintptr)(__ccgo_up(bp))) iLvl = iLvl + 1 } **(**uintptr)(__ccgo_up(ppStruct)) = **(**uintptr)(__ccgo_up(bp)) } } // C documentation // // /* // ** Do up to nPg pages of automerge work on the index. // ** // ** Return true if any changes were actually made, or false otherwise. // */ func _fts5IndexMerge(tls *libc.TLS, p uintptr, ppStruct uintptr, nPg int32, nMin int32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var bRet, iBestLvl, iLvl, nBest int32 var pLvl uintptr var _ /* nRem at bp+0 */ int32 var _ /* pStruct at bp+4 */ uintptr _, _, _, _, _ = bRet, iBestLvl, iLvl, nBest, pLvl **(**int32)(__ccgo_up(bp)) = nPg bRet = 0 **(**uintptr)(__ccgo_up(bp + 4)) = **(**uintptr)(__ccgo_up(ppStruct)) for **(**int32)(__ccgo_up(bp)) > 0 && (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK { /* To iterate through levels */ iBestLvl = 0 /* Level offering the most input segments */ nBest = 0 /* Number of input segments on best level */ /* Set iBestLvl to the level to read input segments from. Or to -1 if ** there is no level suitable to merge segments from. */ iLvl = 0 for { if !(iLvl < (*TFts5Structure)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 4)))).FnLevel) { break } pLvl = **(**uintptr)(__ccgo_up(bp + 4)) + 32 + uintptr(iLvl)*12 if (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FnMerge != 0 { if (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FnMerge > nBest { iBestLvl = iLvl nBest = nMin } break } if (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FnSeg > nBest { nBest = (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FnSeg iBestLvl = iLvl } goto _1 _1: ; iLvl = iLvl + 1 } if nBest < nMin { iBestLvl = _fts5IndexFindDeleteMerge(tls, p, **(**uintptr)(__ccgo_up(bp + 4))) } if iBestLvl < 0 { break } bRet = int32(1) _fts5IndexMergeLevel(tls, p, bp+4, iBestLvl, bp) if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK && (*(*TFts5StructureLevel)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 4)) + 32 + uintptr(iBestLvl)*12))).FnMerge == 0 { _fts5StructurePromote(tls, p, iBestLvl+int32(1), **(**uintptr)(__ccgo_up(bp + 4))) } if nMin == int32(1) { nMin = int32(2) } } **(**uintptr)(__ccgo_up(ppStruct)) = **(**uintptr)(__ccgo_up(bp + 4)) return bRet } // C documentation // // /* // ** xSetOutputs callback used by detail=col when there is a column filter // ** and there are 100 or more columns. Also called as a fallback from // ** fts5IterSetOutputs_Col100 if the column-list spans more than one page. // */ func _fts5IterSetOutputs_Col(tls *libc.TLS, pIter uintptr, pSeg uintptr) { _sqlite3Fts5BufferZero(tls, pIter+32) _fts5SegiterPoslist(tls, (*TFts5Iter)(unsafe.Pointer(pIter)).FpIndex, pSeg, (*TFts5Iter)(unsafe.Pointer(pIter)).FpColset, pIter+32) (*TFts5Iter)(unsafe.Pointer(pIter)).Fbase.FiRowid = (*TFts5SegIter)(unsafe.Pointer(pSeg)).FiRowid (*TFts5Iter)(unsafe.Pointer(pIter)).Fbase.FpData = (*TFts5Iter)(unsafe.Pointer(pIter)).Fposlist.Fp (*TFts5Iter)(unsafe.Pointer(pIter)).Fbase.FnData = (*TFts5Iter)(unsafe.Pointer(pIter)).Fposlist.Fn } // C documentation // // /* // ** xSetOutputs callback used by detail=full when there is a column filter. // */ func _fts5IterSetOutputs_Full(tls *libc.TLS, pIter uintptr, pSeg uintptr) { var a, pColset, pRc uintptr _, _, _ = a, pColset, pRc pColset = (*TFts5Iter)(unsafe.Pointer(pIter)).FpColset (*TFts5Iter)(unsafe.Pointer(pIter)).Fbase.FiRowid = (*TFts5SegIter)(unsafe.Pointer(pSeg)).FiRowid if (*TFts5SegIter)(unsafe.Pointer(pSeg)).FiLeafOffset+int64((*TFts5SegIter)(unsafe.Pointer(pSeg)).FnPos) <= int64((*TFts5Data)(unsafe.Pointer((*TFts5SegIter)(unsafe.Pointer(pSeg)).FpLeaf)).FszLeaf) { /* All data is stored on the current page. Populate the output ** variables to point into the body of the page object. */ a = (*TFts5Data)(unsafe.Pointer((*TFts5SegIter)(unsafe.Pointer(pSeg)).FpLeaf)).Fp + uintptr((*TFts5SegIter)(unsafe.Pointer(pSeg)).FiLeafOffset) pRc = (*TFts5Iter)(unsafe.Pointer(pIter)).FpIndex + 44 _sqlite3Fts5BufferZero(tls, pIter+32) _fts5IndexExtractColset(tls, pRc, pColset, a, (*TFts5SegIter)(unsafe.Pointer(pSeg)).FnPos, pIter) } else { /* The data is distributed over two or more pages. Copy it into the ** Fts5Iter.poslist buffer and then set the output pointer to point ** to this buffer. */ _sqlite3Fts5BufferZero(tls, pIter+32) _fts5SegiterPoslist(tls, (*TFts5Iter)(unsafe.Pointer(pIter)).FpIndex, pSeg, pColset, pIter+32) (*TFts5Iter)(unsafe.Pointer(pIter)).Fbase.FpData = (*TFts5Iter)(unsafe.Pointer(pIter)).Fposlist.Fp (*TFts5Iter)(unsafe.Pointer(pIter)).Fbase.FnData = (*TFts5Iter)(unsafe.Pointer(pIter)).Fposlist.Fn } } // C documentation // // /* // ** xSetOutputs callback used by detail=full and detail=col tables when no // ** column filters are specified. // */ func _fts5IterSetOutputs_Nocolset(tls *libc.TLS, pIter uintptr, pSeg uintptr) { (*TFts5Iter)(unsafe.Pointer(pIter)).Fbase.FiRowid = (*TFts5SegIter)(unsafe.Pointer(pSeg)).FiRowid (*TFts5Iter)(unsafe.Pointer(pIter)).Fbase.FnData = (*TFts5SegIter)(unsafe.Pointer(pSeg)).FnPos if (*TFts5SegIter)(unsafe.Pointer(pSeg)).FiLeafOffset+int64((*TFts5SegIter)(unsafe.Pointer(pSeg)).FnPos) <= int64((*TFts5Data)(unsafe.Pointer((*TFts5SegIter)(unsafe.Pointer(pSeg)).FpLeaf)).FszLeaf) { /* All data is stored on the current page. Populate the output ** variables to point into the body of the page object. */ (*TFts5Iter)(unsafe.Pointer(pIter)).Fbase.FpData = (*TFts5Data)(unsafe.Pointer((*TFts5SegIter)(unsafe.Pointer(pSeg)).FpLeaf)).Fp + uintptr((*TFts5SegIter)(unsafe.Pointer(pSeg)).FiLeafOffset) } else { /* The data is distributed over two or more pages. Copy it into the ** Fts5Iter.poslist buffer and then set the output pointer to point ** to this buffer. */ _sqlite3Fts5BufferZero(tls, pIter+32) _fts5SegiterPoslist(tls, (*TFts5Iter)(unsafe.Pointer(pIter)).FpIndex, pSeg, uintptr(0), pIter+32) (*TFts5Iter)(unsafe.Pointer(pIter)).Fbase.FpData = (*TFts5Iter)(unsafe.Pointer(pIter)).Fposlist.Fp } } func _fts5LookaheadReaderInit(tls *libc.TLS, a uintptr, n int32, p uintptr) (r int32) { libc.Xmemset(tls, p, 0, uint32(32)) (*TFts5LookaheadReader)(unsafe.Pointer(p)).Fa = a (*TFts5LookaheadReader)(unsafe.Pointer(p)).Fn = n _fts5LookaheadReaderNext(tls, p) return _fts5LookaheadReaderNext(tls, p) } func _fts5LookaheadReaderNext(tls *libc.TLS, p uintptr) (r int32) { (*TFts5LookaheadReader)(unsafe.Pointer(p)).FiPos = (*TFts5LookaheadReader)(unsafe.Pointer(p)).FiLookahead if _sqlite3Fts5PoslistNext64(tls, (*TFts5LookaheadReader)(unsafe.Pointer(p)).Fa, (*TFts5LookaheadReader)(unsafe.Pointer(p)).Fn, p+8, p+24) != 0 { (*TFts5LookaheadReader)(unsafe.Pointer(p)).FiLookahead = libc.Int64FromInt32(1) << libc.Int32FromInt32(62) } return libc.BoolInt32((*TFts5LookaheadReader)(unsafe.Pointer(p)).FiPos == libc.Int64FromInt32(1)<= iMinset && (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK) { break } v2 = _fts5MultiIterDoCompare(tls, pIter, i) iEq = v2 if v2 != 0 { pSeg = pIter + 80 + uintptr(iEq)*104 (*(*func(*libc.TLS, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TFts5SegIter)(unsafe.Pointer(pSeg)).FxNext})))(tls, p, pSeg, uintptr(0)) i = (*TFts5Iter)(unsafe.Pointer(pIter)).FnSeg + iEq } goto _1 _1: ; i = i / int32(2) } } // C documentation // // /* // ** Free the iterator object passed as the second argument. // */ func _fts5MultiIterFree(tls *libc.TLS, pIter uintptr) { var i int32 _ = i if pIter != 0 { i = 0 for { if !(i < (*TFts5Iter)(unsafe.Pointer(pIter)).FnSeg) { break } _fts5SegIterClear(tls, pIter+80+uintptr(i)*104) goto _1 _1: ; i = i + 1 } _sqlite3Fts5BufferFree(tls, pIter+32) Xsqlite3_free(tls, pIter) } } // C documentation // // /* // ** Return true if the iterator passed as the second argument currently // ** points to a delete marker. A delete marker is an entry with a 0 byte // ** position-list. // */ func _fts5MultiIterIsEmpty(tls *libc.TLS, p uintptr, pIter uintptr) (r int32) { var pSeg uintptr _ = pSeg pSeg = pIter + 80 + uintptr((**(**TFts5CResult)(__ccgo_up((*TFts5Iter)(unsafe.Pointer(pIter)).FaFirst + 1*4))).FiFirst)*104 return libc.BoolInt32((*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK && (*TFts5SegIter)(unsafe.Pointer(pSeg)).FpLeaf != 0 && (*TFts5SegIter)(unsafe.Pointer(pSeg)).FnPos == 0) } // C documentation // // /* // ** Allocate a new Fts5Iter object. // ** // ** The new object will be used to iterate through data in structure pStruct. // ** If iLevel is -ve, then all data in all segments is merged. Or, if iLevel // ** is zero or greater, data from the first nSegment segments on level iLevel // ** is merged. // ** // ** The iterator initially points to the first term/rowid entry in the // ** iterated data. // */ func _fts5MultiIterNew(tls *libc.TLS, p uintptr, pStruct uintptr, flags int32, pColset uintptr, pTerm uintptr, nTerm int32, iLevel int32, nSegment int32, ppOut uintptr) { var iIter, iSeg, nSeg, v1 int32 var pEnd, pIter, pIter1, pLvl, pNew, pSeg, v2 uintptr _, _, _, _, _, _, _, _, _, _, _ = iIter, iSeg, nSeg, pEnd, pIter, pIter1, pLvl, pNew, pSeg, v1, v2 nSeg = 0 /* Number of segment-iters in use */ iIter = 0 /* Allocate space for the new multi-seg-iterator. */ if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK { if iLevel < 0 { nSeg = (*TFts5Structure)(unsafe.Pointer(pStruct)).FnSegment nSeg = nSeg + libc.BoolInt32((*TFts5Index)(unsafe.Pointer(p)).FpHash != 0 && 0 == flags&int32(FTS5INDEX_QUERY_SKIPHASH)) } else { if (*(*TFts5StructureLevel)(unsafe.Pointer(pStruct + 32 + uintptr(iLevel)*12))).FnSeg < nSegment { v1 = (*(*TFts5StructureLevel)(unsafe.Pointer(pStruct + 32 + uintptr(iLevel)*12))).FnSeg } else { v1 = nSegment } nSeg = v1 } } v2 = _fts5MultiIterAlloc(tls, p, nSeg) pNew = v2 **(**uintptr)(__ccgo_up(ppOut)) = v2 if pNew == uintptr(0) { goto fts5MultiIterNew_post_check } (*TFts5Iter)(unsafe.Pointer(pNew)).FbRev = libc.BoolInt32(0 != flags&int32(FTS5INDEX_QUERY_DESC)) (*TFts5Iter)(unsafe.Pointer(pNew)).FbSkipEmpty = libc.BoolUint8(libc.Int32FromInt32(0) != flags&libc.Int32FromInt32(FTS5INDEX_QUERY_SKIPEMPTY)) (*TFts5Iter)(unsafe.Pointer(pNew)).FpColset = pColset if flags&int32(FTS5INDEX_QUERY_NOOUTPUT) == 0 { _fts5IterSetOutputCb(tls, p+44, pNew) } /* Initialize each of the component segment iterators. */ if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK { if iLevel < 0 { pEnd = pStruct + 32 + uintptr((*TFts5Structure)(unsafe.Pointer(pStruct)).FnLevel)*12 if (*TFts5Index)(unsafe.Pointer(p)).FpHash != 0 && 0 == flags&int32(FTS5INDEX_QUERY_SKIPHASH) { v1 = iIter iIter = iIter + 1 /* Add a segment iterator for the current contents of the hash table. */ pIter = pNew + 80 + uintptr(v1)*104 _fts5SegIterHashInit(tls, p, pTerm, nTerm, flags, pIter) } pLvl = pStruct + 32 for { if !(pLvl < pEnd) { break } iSeg = (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FnSeg - int32(1) for { if !(iSeg >= 0) { break } pSeg = (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FaSeg + uintptr(iSeg)*56 v1 = iIter iIter = iIter + 1 pIter1 = pNew + 80 + uintptr(v1)*104 if pTerm == uintptr(0) { _fts5SegIterInit(tls, p, pSeg, pIter1) } else { _fts5SegIterSeekInit(tls, p, pTerm, nTerm, flags, pSeg, pIter1) } goto _5 _5: ; iSeg = iSeg - 1 } goto _4 _4: ; pLvl += 12 } } else { pLvl = pStruct + 32 + uintptr(iLevel)*12 iSeg = nSeg - int32(1) for { if !(iSeg >= 0) { break } v1 = iIter iIter = iIter + 1 _fts5SegIterInit(tls, p, (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FaSeg+uintptr(iSeg)*56, pNew+80+uintptr(v1)*104) goto _7 _7: ; iSeg = iSeg - 1 } } } /* If the above was successful, each component iterator now points ** to the first entry in its segment. In this case initialize the ** aFirst[] array. Or, if an error has occurred, free the iterator ** object and set the output variable to NULL. */ if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK { _fts5MultiIterFinishSetup(tls, p, pNew) } else { _fts5MultiIterFree(tls, pNew) **(**uintptr)(__ccgo_up(ppOut)) = uintptr(0) } goto fts5MultiIterNew_post_check fts5MultiIterNew_post_check: ; return } // C documentation // // /* // ** Return the rowid of the entry that the iterator currently points // ** to. If the iterator points to EOF when this function is called the // ** results are undefined. // */ func _fts5MultiIterRowid(tls *libc.TLS, pIter uintptr) (r Ti64) { return (*(*TFts5SegIter)(unsafe.Pointer(pIter + 80 + uintptr((**(**TFts5CResult)(__ccgo_up((*TFts5Iter)(unsafe.Pointer(pIter)).FaFirst + 1*4))).FiFirst)*104))).FiRowid } // C documentation // // /* // ** Set the pIter->bEof variable based on the state of the sub-iterators. // */ func _fts5MultiIterSetEof(tls *libc.TLS, pIter uintptr) { var pSeg uintptr _ = pSeg pSeg = pIter + 80 + uintptr((**(**TFts5CResult)(__ccgo_up((*TFts5Iter)(unsafe.Pointer(pIter)).FaFirst + 1*4))).FiFirst)*104 (*TFts5Iter)(unsafe.Pointer(pIter)).Fbase.FbEof = libc.BoolUint8((*TFts5SegIter)(unsafe.Pointer(pSeg)).FpLeaf == uintptr(0)) (*TFts5Iter)(unsafe.Pointer(pIter)).FiSwitchRowid = (*TFts5SegIter)(unsafe.Pointer(pSeg)).FiRowid } /* ** The argument to this macro must be an Fts5Data structure containing a ** tombstone hash page. This macro returns the key-size of the hash-page. */ // C documentation // // /* // ** Return a pointer to a buffer containing the term associated with the // ** entry that the iterator currently points to. // */ func _fts5MultiIterTerm(tls *libc.TLS, pIter uintptr, pn uintptr) (r uintptr) { var p uintptr _ = p p = pIter + 80 + uintptr((**(**TFts5CResult)(__ccgo_up((*TFts5Iter)(unsafe.Pointer(pIter)).FaFirst + 1*4))).FiFirst)*104 **(**int32)(__ccgo_up(pn)) = (*TFts5SegIter)(unsafe.Pointer(p)).Fterm.Fn return (*TFts5SegIter)(unsafe.Pointer(p)).Fterm.Fp } // C documentation // // /* // ** Recursively apply colset pColset to expression node pNode and all of // ** its decendents. If (*ppFree) is not NULL, it contains a spare copy // ** of pColset. This function may use the spare copy and set (*ppFree) to // ** zero, or it may create copies of pColset using fts5CloneColset(). // */ func _fts5ParseSetColset(tls *libc.TLS, pParse uintptr, pNode uintptr, pColset uintptr, ppFree uintptr) { var i int32 var pNear uintptr _, _ = i, pNear if (*TFts5Parse)(unsafe.Pointer(pParse)).Frc == SQLITE_OK { if (*TFts5ExprNode)(unsafe.Pointer(pNode)).FeType == int32(FTS5_STRING) || (*TFts5ExprNode)(unsafe.Pointer(pNode)).FeType == int32(FTS5_TERM) { pNear = (*TFts5ExprNode)(unsafe.Pointer(pNode)).FpNear if (*TFts5ExprNearset)(unsafe.Pointer(pNear)).FpColset != 0 { _fts5MergeColset(tls, (*TFts5ExprNearset)(unsafe.Pointer(pNear)).FpColset, pColset) if (*TFts5Colset)(unsafe.Pointer((*TFts5ExprNearset)(unsafe.Pointer(pNear)).FpColset)).FnCol == 0 { (*TFts5ExprNode)(unsafe.Pointer(pNode)).FeType = FTS5_EOF (*TFts5ExprNode)(unsafe.Pointer(pNode)).FxNext = uintptr(0) } } else { if **(**uintptr)(__ccgo_up(ppFree)) != 0 { (*TFts5ExprNearset)(unsafe.Pointer(pNear)).FpColset = pColset **(**uintptr)(__ccgo_up(ppFree)) = uintptr(0) } else { (*TFts5ExprNearset)(unsafe.Pointer(pNear)).FpColset = _fts5CloneColset(tls, pParse+8, pColset) } } } else { i = 0 for { if !(i < (*TFts5ExprNode)(unsafe.Pointer(pNode)).FnChild) { break } _fts5ParseSetColset(tls, pParse, *(*uintptr)(unsafe.Pointer(pNode + 40 + uintptr(i)*4)), pColset, ppFree) goto _1 _1: ; i = i + 1 } } } } func _fts5PrefixMergerInsertByPosition(tls *libc.TLS, ppHead uintptr, p uintptr) { var pp uintptr _ = pp if (*TPrefixMerger)(unsafe.Pointer(p)).FiPos >= 0 { pp = ppHead for **(**uintptr)(__ccgo_up(pp)) != 0 && (*TPrefixMerger)(unsafe.Pointer(p)).FiPos > (*TPrefixMerger)(unsafe.Pointer(**(**uintptr)(__ccgo_up(pp)))).FiPos { pp = **(**uintptr)(__ccgo_up(pp)) + 48 } (*TPrefixMerger)(unsafe.Pointer(p)).FpNext = **(**uintptr)(__ccgo_up(pp)) **(**uintptr)(__ccgo_up(pp)) = p } } func _fts5PrefixMergerInsertByRowid(tls *libc.TLS, ppHead uintptr, p uintptr) { var pp uintptr _ = pp if (*TPrefixMerger)(unsafe.Pointer(p)).Fiter.FaPoslist != 0 { pp = ppHead for **(**uintptr)(__ccgo_up(pp)) != 0 && (*TPrefixMerger)(unsafe.Pointer(p)).Fiter.FiRowid > (*TPrefixMerger)(unsafe.Pointer(**(**uintptr)(__ccgo_up(pp)))).Fiter.FiRowid { pp = **(**uintptr)(__ccgo_up(pp)) + 48 } (*TPrefixMerger)(unsafe.Pointer(p)).FpNext = **(**uintptr)(__ccgo_up(pp)) **(**uintptr)(__ccgo_up(pp)) = p } } // C documentation // // /* // ** Zero the iterator passed as the only argument. // */ func _fts5SegIterClear(tls *libc.TLS, pIter uintptr) { _sqlite3Fts5BufferFree(tls, pIter+72) _fts5DataRelease(tls, (*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf) _fts5DataRelease(tls, (*TFts5SegIter)(unsafe.Pointer(pIter)).FpNextLeaf) _fts5TombstoneArrayDelete(tls, (*TFts5SegIter)(unsafe.Pointer(pIter)).FpTombArray) _fts5DlidxIterFree(tls, (*TFts5SegIter)(unsafe.Pointer(pIter)).FpDlidx) Xsqlite3_free(tls, (*TFts5SegIter)(unsafe.Pointer(pIter)).FaRowidOffset) libc.Xmemset(tls, pIter, 0, uint32(104)) } // C documentation // // /* // ** Initialize the iterator object pIter to iterate through the entries in // ** segment pSeg. The iterator is left pointing to the first entry when // ** this function returns. // ** // ** If an error occurs, Fts5Index.rc is set to an appropriate error code. If // ** an error has already occurred when this function is called, it is a no-op. // */ func _fts5SegIterInit(tls *libc.TLS, p uintptr, pSeg uintptr, pIter uintptr) { if (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoFirst == 0 { /* This happens if the segment is being used as an input to an incremental ** merge and all data has already been "trimmed". See function ** fts5TrimSegments() for details. In this case leave the iterator empty. ** The caller will see the (pIter->pLeaf==0) and assume the iterator is ** at EOF already. */ return } if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK { libc.Xmemset(tls, pIter, 0, uint32(104)) _fts5SegIterSetNext(tls, p, pIter) (*TFts5SegIter)(unsafe.Pointer(pIter)).FpSeg = pSeg (*TFts5SegIter)(unsafe.Pointer(pIter)).FiLeafPgno = (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoFirst - int32(1) for cond := true; cond; cond = (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK && (*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf != 0 && (*TFts5Data)(unsafe.Pointer((*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf)).Fnn == int32(4) { _fts5SegIterNextPage(tls, p, pIter) } } if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK && (*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf != 0 { (*TFts5SegIter)(unsafe.Pointer(pIter)).FiLeafOffset = int64(4) (*TFts5SegIter)(unsafe.Pointer(pIter)).FiPgidxOff = (*TFts5Data)(unsafe.Pointer((*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf)).FszLeaf + int32(1) _fts5SegIterLoadTerm(tls, p, pIter, 0) _fts5SegIterLoadNPos(tls, p, pIter) _fts5SegIterAllocTombstone(tls, p, pIter) } } // C documentation // // /* // ** This is similar to fts5SegIterSeekInit(), except that it initializes // ** the segment iterator to point to the first term following the page // ** with pToken/nToken on it. // */ func _fts5SegIterNextInit(tls *libc.TLS, p uintptr, pTerm uintptr, nTerm int32, pSeg uintptr, pIter uintptr) { bp := tls.Alloc(16) defer tls.Free(16) var a, pSel uintptr var bDlidx, iPg int32 var val Ti64 var _ /* iTermOff at bp+0 */ int32 _, _, _, _, _ = a, bDlidx, iPg, pSel, val iPg = -int32(1) /* Page of segment to open */ bDlidx = 0 pSel = uintptr(0) /* SELECT to find iPg */ pSel = _fts5IdxNextStmt(tls, p) if pSel != 0 { Xsqlite3_bind_int(tls, pSel, int32(1), (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FiSegid) Xsqlite3_bind_blob(tls, pSel, int32(2), pTerm, nTerm, libc.UintptrFromInt32(0)) if Xsqlite3_step(tls, pSel) == int32(SQLITE_ROW) { val = Xsqlite3_column_int64(tls, pSel, 0) iPg = int32(val >> libc.Int32FromInt32(1)) bDlidx = int32(val & libc.Int64FromInt32(0x0001)) } (*TFts5Index)(unsafe.Pointer(p)).Frc = Xsqlite3_reset(tls, pSel) Xsqlite3_bind_null(tls, pSel, int32(2)) if (*TFts5Index)(unsafe.Pointer(p)).Frc != 0 { return } } libc.Xmemset(tls, pIter, 0, uint32(104)) (*TFts5SegIter)(unsafe.Pointer(pIter)).FpSeg = pSeg **(**int32)(__ccgo_up(pIter + 4)) |= int32(FTS5_SEGITER_ONETERM) if iPg >= 0 { (*TFts5SegIter)(unsafe.Pointer(pIter)).FiLeafPgno = iPg - int32(1) _fts5SegIterNextPage(tls, p, pIter) _fts5SegIterSetNext(tls, p, pIter) } if (*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf != 0 { a = (*TFts5Data)(unsafe.Pointer((*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf)).Fp **(**int32)(__ccgo_up(bp)) = 0 (*TFts5SegIter)(unsafe.Pointer(pIter)).FiPgidxOff = (*TFts5Data)(unsafe.Pointer((*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf)).FszLeaf **(**int32)(__ccgo_up(pIter + 48)) += _sqlite3Fts5GetVarint32(tls, a+uintptr((*TFts5SegIter)(unsafe.Pointer(pIter)).FiPgidxOff), bp) (*TFts5SegIter)(unsafe.Pointer(pIter)).FiLeafOffset = int64(**(**int32)(__ccgo_up(bp))) _fts5SegIterLoadTerm(tls, p, pIter, 0) _fts5SegIterLoadNPos(tls, p, pIter) if bDlidx != 0 { _fts5SegIterLoadDlidx(tls, p, pIter) } } } // C documentation // // /* // ** Load the next leaf page into the segment iterator. // */ func _fts5SegIterNextPage(tls *libc.TLS, p uintptr, pIter uintptr) { var pLeaf, pSeg uintptr _, _ = pLeaf, pSeg pSeg = (*TFts5SegIter)(unsafe.Pointer(pIter)).FpSeg _fts5DataRelease(tls, (*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf) (*TFts5SegIter)(unsafe.Pointer(pIter)).FiLeafPgno = (*TFts5SegIter)(unsafe.Pointer(pIter)).FiLeafPgno + 1 if (*TFts5SegIter)(unsafe.Pointer(pIter)).FpNextLeaf != 0 { (*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf = (*TFts5SegIter)(unsafe.Pointer(pIter)).FpNextLeaf (*TFts5SegIter)(unsafe.Pointer(pIter)).FpNextLeaf = uintptr(0) } else { if (*TFts5SegIter)(unsafe.Pointer(pIter)).FiLeafPgno <= (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoLast { (*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf = _fts5LeafRead(tls, p, int64((*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FiSegid)<<(libc.Int32FromInt32(FTS5_DATA_PAGE_B)+libc.Int32FromInt32(FTS5_DATA_HEIGHT_B)+libc.Int32FromInt32(FTS5_DATA_DLI_B))+int64(libc.Int32FromInt32(0))<<(libc.Int32FromInt32(FTS5_DATA_PAGE_B)+libc.Int32FromInt32(FTS5_DATA_HEIGHT_B))+int64(libc.Int32FromInt32(0))<= (*TFts5Data)(unsafe.Pointer(pLeaf)).Fnn { (*TFts5SegIter)(unsafe.Pointer(pIter)).FiEndofDoclist = (*TFts5Data)(unsafe.Pointer(pLeaf)).Fnn + int32(1) } else { **(**int32)(__ccgo_up(pIter + 48)) += _sqlite3Fts5GetVarint32(tls, (*TFts5Data)(unsafe.Pointer(pLeaf)).Fp+uintptr((*TFts5SegIter)(unsafe.Pointer(pIter)).FiPgidxOff), pIter+52) } } } // C documentation // // /* // ** Advance iterator pIter to the next entry. // ** // ** This version of fts5SegIterNext() is only used by reverse iterators. // */ func _fts5SegIterNext_Reverse(tls *libc.TLS, p uintptr, pIter uintptr, pbUnused uintptr) { bp := tls.Alloc(16) defer tls.Free(16) var a, v1 uintptr var iOff int32 var _ /* iDelta at bp+0 */ Tu64 _, _, _ = a, iOff, v1 _ = pbUnused if (*TFts5SegIter)(unsafe.Pointer(pIter)).FiRowidOffset > 0 { a = (*TFts5Data)(unsafe.Pointer((*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf)).Fp (*TFts5SegIter)(unsafe.Pointer(pIter)).FiRowidOffset = (*TFts5SegIter)(unsafe.Pointer(pIter)).FiRowidOffset - 1 (*TFts5SegIter)(unsafe.Pointer(pIter)).FiLeafOffset = int64(**(**int32)(__ccgo_up((*TFts5SegIter)(unsafe.Pointer(pIter)).FaRowidOffset + uintptr((*TFts5SegIter)(unsafe.Pointer(pIter)).FiRowidOffset)*4))) _fts5SegIterLoadNPos(tls, p, pIter) iOff = int32((*TFts5SegIter)(unsafe.Pointer(pIter)).FiLeafOffset) if (*TFts5Config)(unsafe.Pointer((*TFts5Index)(unsafe.Pointer(p)).FpConfig)).FeDetail != int32(FTS5_DETAIL_NONE) { iOff = iOff + (*TFts5SegIter)(unsafe.Pointer(pIter)).FnPos } _sqlite3Fts5GetVarint(tls, a+uintptr(iOff), bp) v1 = pIter + 88 *(*Ti64)(unsafe.Pointer(v1)) = Ti64(uint64(*(*Ti64)(unsafe.Pointer(v1))) - **(**Tu64)(__ccgo_up(bp))) } else { _fts5SegIterReverseNewPage(tls, p, pIter) } } // C documentation // // /* // ** Initialize the object pIter to point to term pTerm/nTerm within segment // ** pSeg. If there is no such term in the index, the iterator is set to EOF. // ** // ** If an error occurs, Fts5Index.rc is set to an appropriate error code. If // ** an error has already occurred when this function is called, it is a no-op. // */ func _fts5SegIterSeekInit(tls *libc.TLS, p uintptr, pTerm uintptr, nTerm int32, flags int32, pSeg uintptr, pIter uintptr) { var bDlidx, bGe, iPg int32 var pIdxSelect uintptr var val Ti64 _, _, _, _, _ = bDlidx, bGe, iPg, pIdxSelect, val iPg = int32(1) bGe = flags & int32(FTS5INDEX_QUERY_SCAN) bDlidx = 0 /* True if there is a doclist-index */ pIdxSelect = uintptr(0) libc.Xmemset(tls, pIter, 0, uint32(104)) (*TFts5SegIter)(unsafe.Pointer(pIter)).FpSeg = pSeg /* This block sets stack variable iPg to the leaf page number that may ** contain term (pTerm/nTerm), if it is present in the segment. */ pIdxSelect = _fts5IdxSelectStmt(tls, p) if (*TFts5Index)(unsafe.Pointer(p)).Frc != 0 { return } Xsqlite3_bind_int(tls, pIdxSelect, int32(1), (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FiSegid) Xsqlite3_bind_blob(tls, pIdxSelect, int32(2), pTerm, nTerm, libc.UintptrFromInt32(0)) if int32(SQLITE_ROW) == Xsqlite3_step(tls, pIdxSelect) { val = int64(Xsqlite3_column_int(tls, pIdxSelect, 0)) iPg = int32(val >> libc.Int32FromInt32(1)) bDlidx = int32(val & libc.Int64FromInt32(0x0001)) } (*TFts5Index)(unsafe.Pointer(p)).Frc = Xsqlite3_reset(tls, pIdxSelect) Xsqlite3_bind_null(tls, pIdxSelect, int32(2)) if iPg < (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoFirst { iPg = (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoFirst bDlidx = 0 } (*TFts5SegIter)(unsafe.Pointer(pIter)).FiLeafPgno = iPg - int32(1) _fts5SegIterNextPage(tls, p, pIter) if (*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf != 0 { _fts5LeafSeek(tls, p, bGe, pIter, pTerm, nTerm) } if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK && (bGe == 0 || flags&int32(FTS5INDEX_QUERY_SCANONETERM) != 0) { **(**int32)(__ccgo_up(pIter + 4)) |= int32(FTS5_SEGITER_ONETERM) if (*TFts5SegIter)(unsafe.Pointer(pIter)).FpLeaf != 0 { if flags&int32(FTS5INDEX_QUERY_DESC) != 0 { **(**int32)(__ccgo_up(pIter + 4)) |= int32(FTS5_SEGITER_REVERSE) } if bDlidx != 0 { _fts5SegIterLoadDlidx(tls, p, pIter) } if flags&int32(FTS5INDEX_QUERY_DESC) != 0 { _fts5SegIterReverse(tls, p, pIter) } } } _fts5SegIterSetNext(tls, p, pIter) if 0 == flags&int32(FTS5INDEX_QUERY_SCANONETERM) { _fts5SegIterAllocTombstone(tls, p, pIter) } /* Either: ** ** 1) an error has occurred, or ** 2) the iterator points to EOF, or ** 3) the iterator points to an entry with term (pTerm/nTerm), or ** 4) the FTS5INDEX_QUERY_SCAN flag was set and the iterator points ** to an entry with a term greater than or equal to (pTerm/nTerm). */ } // C documentation // // /* // ** Set the SQLITE_INDEX_SCAN_UNIQUE flag in pIdxInfo->flags. Unless this // ** extension is currently being used by a version of SQLite too old to // ** support index-info flags. In that case this function is a no-op. // */ func _fts5SetUniqueFlag(tls *libc.TLS, pIdxInfo uintptr) { **(**int32)(__ccgo_up(pIdxInfo + 56)) |= int32(SQLITE_INDEX_SCAN_UNIQUE) } func _fts5SorterNext(tls *libc.TLS, pCsr uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var a, aBlob, pSorter, v1 uintptr var i, iOff, nBlob, rc int32 var _ /* iVal at bp+0 */ int32 _, _, _, _, _, _, _, _ = a, aBlob, i, iOff, nBlob, pSorter, rc, v1 pSorter = (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpSorter rc = Xsqlite3_step(tls, (*TFts5Sorter)(unsafe.Pointer(pSorter)).FpStmt) if rc == int32(SQLITE_DONE) { rc = SQLITE_OK **(**int32)(__ccgo_up(pCsr + 60)) |= libc.Int32FromInt32(FTS5CSR_EOF) | libc.Int32FromInt32(FTS5CSR_REQUIRE_CONTENT) } else { if rc == int32(SQLITE_ROW) { iOff = 0 rc = SQLITE_OK (*TFts5Sorter)(unsafe.Pointer(pSorter)).FiRowid = Xsqlite3_column_int64(tls, (*TFts5Sorter)(unsafe.Pointer(pSorter)).FpStmt, 0) nBlob = Xsqlite3_column_bytes(tls, (*TFts5Sorter)(unsafe.Pointer(pSorter)).FpStmt, int32(1)) v1 = Xsqlite3_column_blob(tls, (*TFts5Sorter)(unsafe.Pointer(pSorter)).FpStmt, int32(1)) a = v1 aBlob = v1 /* nBlob==0 in detail=none mode. */ if nBlob > 0 { i = 0 for { if !(i < (*TFts5Sorter)(unsafe.Pointer(pSorter)).FnIdx-int32(1)) { break } a = a + uintptr(_sqlite3Fts5GetVarint32(tls, a, bp)) iOff = iOff + **(**int32)(__ccgo_up(bp)) *(*int32)(unsafe.Pointer(pSorter + 24 + uintptr(i)*4)) = iOff goto _2 _2: ; i = i + 1 } *(*int32)(unsafe.Pointer(pSorter + 24 + uintptr(i)*4)) = t__predefined_ptrdiff_t(aBlob+uintptr(nBlob)) - int32(a) (*TFts5Sorter)(unsafe.Pointer(pSorter)).FaPoslist = a } _fts5CsrNewrow(tls, pCsr) } } return rc } // C documentation // // /* // ** Load the contents of the "averages" record from disk into the // ** p->nTotalRow and p->aTotalSize[] variables. If successful, and if // ** argument bCache is true, set the p->bTotalsValid flag to indicate // ** that the contents of aTotalSize[] and nTotalRow are valid until // ** further notice. // ** // ** Return SQLITE_OK if successful, or an SQLite error code if an error // ** occurs. // */ func _fts5StorageLoadTotals(tls *libc.TLS, p uintptr, bCache int32) (r int32) { var rc int32 _ = rc rc = SQLITE_OK if (*TFts5Storage)(unsafe.Pointer(p)).FbTotalsValid == 0 { rc = _sqlite3Fts5IndexGetAverages(tls, (*TFts5Storage)(unsafe.Pointer(p)).FpIndex, p+16, (*TFts5Storage)(unsafe.Pointer(p)).FaTotalSize) (*TFts5Storage)(unsafe.Pointer(p)).FbTotalsValid = bCache } return rc } // C documentation // // /* // ** A new segment has just been written to level iLvl of index structure // ** pStruct. This function determines if any segments should be promoted // ** as a result. Segments are promoted in two scenarios: // ** // ** a) If the segment just written is smaller than one or more segments // ** within the previous populated level, it is promoted to the previous // ** populated level. // ** // ** b) If the segment just written is larger than the newest segment on // ** the next populated level, then that segment, and any other adjacent // ** segments that are also smaller than the one just written, are // ** promoted. // ** // ** If one or more segments are promoted, the structure object is updated // ** to reflect this. // */ func _fts5StructurePromote(tls *libc.TLS, p uintptr, iLvl int32, pStruct uintptr) { var i, iPromote, iTst, nSeg, sz, szMax, szPromote, szSeg int32 var pSeg, pTst uintptr _, _, _, _, _, _, _, _, _, _ = i, iPromote, iTst, nSeg, pSeg, pTst, sz, szMax, szPromote, szSeg if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK { iPromote = -int32(1) szPromote = 0 /* Size of segment just written */ nSeg = (*(*TFts5StructureLevel)(unsafe.Pointer(pStruct + 32 + uintptr(iLvl)*12))).FnSeg if nSeg == 0 { return } pSeg = (*(*TFts5StructureLevel)(unsafe.Pointer(pStruct + 32 + uintptr(iLvl)*12))).FaSeg + uintptr((*(*TFts5StructureLevel)(unsafe.Pointer(pStruct + 32 + uintptr(iLvl)*12))).FnSeg-int32(1))*56 szSeg = int32(1) + (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoLast - (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoFirst /* Check for condition (a) */ iTst = iLvl - int32(1) for { if !(iTst >= 0 && (*(*TFts5StructureLevel)(unsafe.Pointer(pStruct + 32 + uintptr(iTst)*12))).FnSeg == 0) { break } goto _1 _1: ; iTst = iTst - 1 } if iTst >= 0 { szMax = 0 pTst = pStruct + 32 + uintptr(iTst)*12 i = 0 for { if !(i < (*TFts5StructureLevel)(unsafe.Pointer(pTst)).FnSeg) { break } sz = (**(**TFts5StructureSegment)(__ccgo_up((*TFts5StructureLevel)(unsafe.Pointer(pTst)).FaSeg + uintptr(i)*56))).FpgnoLast - (**(**TFts5StructureSegment)(__ccgo_up((*TFts5StructureLevel)(unsafe.Pointer(pTst)).FaSeg + uintptr(i)*56))).FpgnoFirst + int32(1) if sz > szMax { szMax = sz } goto _2 _2: ; i = i + 1 } if szMax >= szSeg { /* Condition (a) is true. Promote the newest segment on level ** iLvl to level iTst. */ iPromote = iTst szPromote = szMax } } /* If condition (a) is not met, assume (b) is true. StructurePromoteTo() ** is a no-op if it is not. */ if iPromote < 0 { iPromote = iLvl szPromote = szSeg } _fts5StructurePromoteTo(tls, p, iPromote, szPromote, pStruct) } } // C documentation // // /* // ** Return a copy of index structure pStruct. Except, promote as many // ** segments as possible to level iPromote. If an OOM occurs, NULL is // ** returned. // */ func _fts5StructurePromoteTo(tls *libc.TLS, p uintptr, iPromote int32, szPromote int32, pStruct uintptr) { var il, is, sz int32 var pLvl, pOut uintptr _, _, _, _, _ = il, is, pLvl, pOut, sz pOut = pStruct + 32 + uintptr(iPromote)*12 if (*TFts5StructureLevel)(unsafe.Pointer(pOut)).FnMerge == 0 { il = iPromote + int32(1) for { if !(il < (*TFts5Structure)(unsafe.Pointer(pStruct)).FnLevel) { break } pLvl = pStruct + 32 + uintptr(il)*12 if (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FnMerge != 0 { return } is = (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FnSeg - int32(1) for { if !(is >= 0) { break } sz = _fts5SegmentSize(tls, (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FaSeg+uintptr(is)*56) if sz > szPromote { return } _fts5StructureExtendLevel(tls, p+44, pStruct, iPromote, int32(1), int32(1)) if (*TFts5Index)(unsafe.Pointer(p)).Frc != 0 { return } libc.Xmemcpy(tls, (*TFts5StructureLevel)(unsafe.Pointer(pOut)).FaSeg, (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FaSeg+uintptr(is)*56, uint32(56)) (*TFts5StructureLevel)(unsafe.Pointer(pOut)).FnSeg = (*TFts5StructureLevel)(unsafe.Pointer(pOut)).FnSeg + 1 (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FnSeg = (*TFts5StructureLevel)(unsafe.Pointer(pLvl)).FnSeg - 1 goto _2 _2: ; is = is - 1 } goto _1 _1: ; il = il + 1 } } } // C documentation // // /* // ** Release a reference to an Fts5Structure object returned by an earlier // ** call to fts5StructureRead() or fts5StructureDecode(). // */ func _fts5StructureRelease(tls *libc.TLS, pStruct uintptr) { var i, v1 int32 var v2 uintptr var v3 bool _, _, _, _ = i, v1, v2, v3 if v3 = pStruct != 0; v3 { v2 = pStruct *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) } if v3 && 0 >= v1 { i = 0 for { if !(i < (*TFts5Structure)(unsafe.Pointer(pStruct)).FnLevel) { break } Xsqlite3_free(tls, (*(*TFts5StructureLevel)(unsafe.Pointer(pStruct + 32 + uintptr(i)*12))).FaSeg) goto _4 _4: ; i = i + 1 } Xsqlite3_free(tls, pStruct) } } // C documentation // // /* // ** If the segment-iterator passed as the first argument is at EOF, then // ** set pIter->term to a copy of buffer pTerm. // */ func _fts5TokendataSetTermIfEof(tls *libc.TLS, pIter uintptr, pTerm uintptr) { if pIter != 0 && (*(*TFts5SegIter)(unsafe.Pointer(pIter + 80))).FpLeaf == uintptr(0) { _sqlite3Fts5BufferSet(tls, (*TFts5Iter)(unsafe.Pointer(pIter)).FpIndex+44, pIter+80+72, (*TFts5Buffer)(unsafe.Pointer(pTerm)).Fn, (*TFts5Buffer)(unsafe.Pointer(pTerm)).Fp) } } // C documentation // // /* // ** Set the FTS5CSR_REQUIRE_RESEEK flag on all FTS5_PLAN_MATCH cursors // ** open on table pTab. // */ func _fts5TripCursors(tls *libc.TLS, pTab uintptr) { var pCsr uintptr _ = pCsr pCsr = (*TFts5Global)(unsafe.Pointer((*TFts5FullTable)(unsafe.Pointer(pTab)).FpGlobal)).FpCsr for { if !(pCsr != 0) { break } if (*TFts5Cursor)(unsafe.Pointer(pCsr)).FePlan == int32(FTS5_PLAN_MATCH) && (*TFts5Cursor)(unsafe.Pointer(pCsr)).Fbase.FpVtab == pTab { **(**int32)(__ccgo_up(pCsr + 60)) |= int32(FTS5CSR_REQUIRE_RESEEK) } goto _1 _1: ; pCsr = (*TFts5Cursor)(unsafe.Pointer(pCsr)).FpNext } } func _fts5VocabInstanceNext(tls *libc.TLS, pCsr uintptr) (r int32) { var eDetail, rc int32 var pIter, po, pp uintptr _, _, _, _, _ = eDetail, pIter, po, pp, rc eDetail = (*TFts5Config)(unsafe.Pointer((*TFts5Table)(unsafe.Pointer((*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FpFts5)).FpConfig)).FeDetail rc = SQLITE_OK pIter = (*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FpIter pp = pCsr + 72 po = pCsr + 80 for eDetail == int32(FTS5_DETAIL_NONE) || _sqlite3Fts5PoslistNext64(tls, (*TFts5IndexIter)(unsafe.Pointer(pIter)).FpData, (*TFts5IndexIter)(unsafe.Pointer(pIter)).FnData, po, pp) != 0 { (*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FiInstPos = 0 (*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FiInstOff = 0 rc = _sqlite3Fts5IterNextScan(tls, (*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FpIter) if rc == SQLITE_OK { rc = _fts5VocabInstanceNewTerm(tls, pCsr) if (*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FbEof != 0 || eDetail == int32(FTS5_DETAIL_NONE) { break } } if rc != 0 { (*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FbEof = int32(1) break } } return rc } // C documentation // // /* // ** This function is called when flushing a leaf page that contains no // ** terms at all to disk. // */ func _fts5WriteBtreeNoTerm(tls *libc.TLS, p uintptr, pWriter uintptr) { var pDlidx uintptr _ = pDlidx /* If there were no rowids on the leaf page either and the doclist-index ** has already been started, append an 0x00 byte to it. */ if (*TFts5SegWriter)(unsafe.Pointer(pWriter)).FbFirstRowidInPage != 0 && (**(**TFts5DlidxWriter)(__ccgo_up((*TFts5SegWriter)(unsafe.Pointer(pWriter)).FaDlidx))).Fbuf.Fn > 0 { pDlidx = (*TFts5SegWriter)(unsafe.Pointer(pWriter)).FaDlidx _sqlite3Fts5BufferAppendVarint(tls, p+44, pDlidx+16, 0) } /* Increment the "number of sequential leaves without a term" counter. */ (*TFts5SegWriter)(unsafe.Pointer(pWriter)).FnEmpty = (*TFts5SegWriter)(unsafe.Pointer(pWriter)).FnEmpty + 1 } // C documentation // // /* // ** This is called once for each leaf page except the first that contains // ** at least one term. Argument (nTerm/pTerm) is the split-key - a term that // ** is larger than all terms written to earlier leaves, and equal to or // ** smaller than the first term on the new leaf. // ** // ** If an error occurs, an error code is left in Fts5Index.rc. If an error // ** has already occurred when this function is called, it is a no-op. // */ func _fts5WriteBtreeTerm(tls *libc.TLS, p uintptr, pWriter uintptr, nTerm int32, pTerm uintptr) { _fts5WriteFlushBtree(tls, p, pWriter) if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK { _sqlite3Fts5BufferSet(tls, p+44, pWriter+76, nTerm, pTerm) (*TFts5SegWriter)(unsafe.Pointer(pWriter)).FiBtPage = (*TFts5SegWriter)(unsafe.Pointer(pWriter)).Fwriter.Fpgno } } // C documentation // // /* // ** Flush any data cached by the writer object to the database. Free any // ** allocations associated with the writer. // */ func _fts5WriteFinish(tls *libc.TLS, p uintptr, pWriter uintptr, pnLeaf uintptr) { var i int32 var pLeaf uintptr _, _ = i, pLeaf pLeaf = pWriter + 4 if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK { if (*TFts5PageWriter)(unsafe.Pointer(pLeaf)).Fbuf.Fn > int32(4) { _fts5WriteFlushLeaf(tls, p, pWriter) } **(**int32)(__ccgo_up(pnLeaf)) = (*TFts5PageWriter)(unsafe.Pointer(pLeaf)).Fpgno - int32(1) if (*TFts5PageWriter)(unsafe.Pointer(pLeaf)).Fpgno > int32(1) { _fts5WriteFlushBtree(tls, p, pWriter) } } _sqlite3Fts5BufferFree(tls, pLeaf+32) _sqlite3Fts5BufferFree(tls, pLeaf+8) _sqlite3Fts5BufferFree(tls, pLeaf+20) _sqlite3Fts5BufferFree(tls, pWriter+76) i = 0 for { if !(i < (*TFts5SegWriter)(unsafe.Pointer(pWriter)).FnDlidx) { break } _sqlite3Fts5BufferFree(tls, (*TFts5SegWriter)(unsafe.Pointer(pWriter)).FaDlidx+uintptr(i)*32+16) goto _1 _1: ; i = i + 1 } Xsqlite3_free(tls, (*TFts5SegWriter)(unsafe.Pointer(pWriter)).FaDlidx) } // C documentation // // /* // ** Add a single segment and its associated events. // */ func _geopolyAddOneSegment(tls *libc.TLS, p uintptr, x0 TGeoCoord, y0 TGeoCoord, x1 TGeoCoord, y1 TGeoCoord, side uint8, idx uint32) { var pEvent, pSeg uintptr var t TGeoCoord _, _, _ = pEvent, pSeg, t if x0 == x1 { return } /* Ignore vertical segments */ if x0 > x1 { t = x0 x0 = x1 x1 = t t = y0 y0 = y1 y1 = t } pSeg = (*TGeoOverlap)(unsafe.Pointer(p)).FaSegment + uintptr((*TGeoOverlap)(unsafe.Pointer(p)).FnSegment)*40 (*TGeoOverlap)(unsafe.Pointer(p)).FnSegment = (*TGeoOverlap)(unsafe.Pointer(p)).FnSegment + 1 (*TGeoSegment)(unsafe.Pointer(pSeg)).FC = float64((y1 - y0) / (x1 - x0)) (*TGeoSegment)(unsafe.Pointer(pSeg)).FB = float64(y1) - float64(float64(x1)*(*TGeoSegment)(unsafe.Pointer(pSeg)).FC) (*TGeoSegment)(unsafe.Pointer(pSeg)).Fy0 = y0 (*TGeoSegment)(unsafe.Pointer(pSeg)).Fside = side (*TGeoSegment)(unsafe.Pointer(pSeg)).Fidx = idx pEvent = (*TGeoOverlap)(unsafe.Pointer(p)).FaEvent + uintptr((*TGeoOverlap)(unsafe.Pointer(p)).FnEvent)*24 (*TGeoOverlap)(unsafe.Pointer(p)).FnEvent = (*TGeoOverlap)(unsafe.Pointer(p)).FnEvent + 1 (*TGeoEvent)(unsafe.Pointer(pEvent)).Fx = float64(x0) (*TGeoEvent)(unsafe.Pointer(pEvent)).FeType = 0 (*TGeoEvent)(unsafe.Pointer(pEvent)).FpSeg = pSeg pEvent = (*TGeoOverlap)(unsafe.Pointer(p)).FaEvent + uintptr((*TGeoOverlap)(unsafe.Pointer(p)).FnEvent)*24 (*TGeoOverlap)(unsafe.Pointer(p)).FnEvent = (*TGeoOverlap)(unsafe.Pointer(p)).FnEvent + 1 (*TGeoEvent)(unsafe.Pointer(pEvent)).Fx = float64(x1) (*TGeoEvent)(unsafe.Pointer(pEvent)).FeType = int32(1) (*TGeoEvent)(unsafe.Pointer(pEvent)).FpSeg = pSeg } // C documentation // // /* // ** Sort an array of nEvent event objects into a list. // */ func _geopolySortEventsByX(tls *libc.TLS, aEvent uintptr, nEvent int32) (r uintptr) { var a [50]uintptr var i, j, mx int32 var p uintptr _, _, _, _, _ = a, i, j, mx, p mx = 0 i = 0 for { if !(i < nEvent) { break } p = aEvent + uintptr(i)*24 (*TGeoEvent)(unsafe.Pointer(p)).FpNext = uintptr(0) j = 0 for { if !(j < mx && a[j] != 0) { break } p = _geopolyEventMerge(tls, a[j], p) a[j] = uintptr(0) goto _2 _2: ; j = j + 1 } a[j] = p if j >= mx { mx = j + int32(1) } goto _1 _1: ; i = i + 1 } p = uintptr(0) i = 0 for { if !(i < mx) { break } p = _geopolyEventMerge(tls, a[i], p) goto _3 _3: ; i = i + 1 } return p } // C documentation // // /* // ** Flush the contents of memory to a real file on disk. // */ func _memjrnlCreateFile(tls *libc.TLS, p uintptr) (r int32) { var copy1 TMemJournal var iOff Ti64 var nChunk, rc int32 var pIter, pReal uintptr _, _, _, _, _, _ = copy1, iOff, nChunk, pIter, pReal, rc pReal = p copy1 = **(**TMemJournal)(__ccgo_up(p)) libc.Xmemset(tls, p, 0, uint32(64)) rc = _sqlite3OsOpen(tls, copy1.FpVfs, copy1.FzJournal, pReal, copy1.Fflags, uintptr(0)) if rc == SQLITE_OK { nChunk = copy1.FnChunkSize iOff = 0 pIter = copy1.FpFirst for { if !(pIter != 0) { break } if iOff+int64(nChunk) > copy1.Fendpoint.FiOffset { nChunk = int32(copy1.Fendpoint.FiOffset - iOff) } rc = _sqlite3OsWrite(tls, pReal, pIter+4, nChunk, iOff) if rc != 0 { break } iOff = iOff + int64(nChunk) goto _1 _1: ; pIter = (*TFileChunk)(unsafe.Pointer(pIter)).FpNext } if rc == SQLITE_OK { /* No error has occurred. Free the in-memory buffers. */ _memjrnlFreeChunks(tls, copy1.FpFirst) } } if rc != SQLITE_OK { /* If an error occurred while creating or writing to the file, restore ** the original before returning. This way, SQLite uses the in-memory ** journal data to roll back changes made to the internal page-cache ** before this function was called. */ _sqlite3OsClose(tls, pReal) **(**TMemJournal)(__ccgo_up(p)) = copy1 } return rc } // C documentation // // /* // ** Move the cursor up to the parent page. // ** // ** pCur->idx is set to the cell index that contains the pointer // ** to the page we are coming from. If we are coming from the // ** right-most child page then pCur->idx is set to one more than // ** the largest cell index. // */ func _moveToParent(tls *libc.TLS, pCur uintptr) { var pLeaf, v1 uintptr var v2 Ti8 _, _, _ = pLeaf, v1, v2 (*TBtCursor)(unsafe.Pointer(pCur)).Finfo.FnSize = uint16(0) v1 = pCur + 1 *(*Tu8)(unsafe.Pointer(v1)) = Tu8(int32(*(*Tu8)(unsafe.Pointer(v1))) & ^(libc.Int32FromInt32(BTCF_ValidNKey) | libc.Int32FromInt32(BTCF_ValidOvfl))) (*TBtCursor)(unsafe.Pointer(pCur)).Fix = **(**Tu16)(__ccgo_up(pCur + 72 + uintptr(int32((*TBtCursor)(unsafe.Pointer(pCur)).FiPage)-int32(1))*2)) pLeaf = (*TBtCursor)(unsafe.Pointer(pCur)).FpPage v1 = pCur + 68 *(*Ti8)(unsafe.Pointer(v1)) = *(*Ti8)(unsafe.Pointer(v1)) - 1 v2 = *(*Ti8)(unsafe.Pointer(v1)) (*TBtCursor)(unsafe.Pointer(pCur)).FpPage = **(**uintptr)(__ccgo_up(pCur + 120 + uintptr(v2)*4)) _releasePageNotNull(tls, pLeaf) } // C documentation // // /* // ** Remove node pNode from the node hash table. // */ func _nodeHashDelete(tls *libc.TLS, pRtree uintptr, pNode uintptr) { var pp uintptr _ = pp if (*TRtreeNode)(unsafe.Pointer(pNode)).FiNode != 0 { pp = pRtree + 120 + uintptr(_nodeHash(tls, (*TRtreeNode)(unsafe.Pointer(pNode)).FiNode))*4 for { if !(**(**uintptr)(__ccgo_up(pp)) != pNode) { break } goto _1 _1: ; pp = **(**uintptr)(__ccgo_up(pp)) + 28 } **(**uintptr)(__ccgo_up(pp)) = (*TRtreeNode)(unsafe.Pointer(pNode)).FpNext (*TRtreeNode)(unsafe.Pointer(pNode)).FpNext = uintptr(0) } } // C documentation // // /* // ** Search the node hash table for node iNode. If found, return a pointer // ** to it. Otherwise, return 0. // */ func _nodeHashLookup(tls *libc.TLS, pRtree uintptr, iNode Ti64) (r uintptr) { var p uintptr _ = p p = **(**uintptr)(__ccgo_up(pRtree + 120 + uintptr(_nodeHash(tls, iNode))*4)) for { if !(p != 0 && (*TRtreeNode)(unsafe.Pointer(p)).FiNode != iNode) { break } goto _1 _1: ; p = (*TRtreeNode)(unsafe.Pointer(p)).FpNext } return p } // C documentation // // /* // ** Write page pPg onto the end of the rollback journal. // */ func _pagerAddPageToRollbackJournal(tls *libc.TLS, pPg uintptr) (r int32) { var cksum Tu32 var iOff Ti64 var pData2, pPager, v1 uintptr var rc int32 _, _, _, _, _, _ = cksum, iOff, pData2, pPager, rc, v1 pPager = (*TPgHdr)(unsafe.Pointer(pPg)).FpPager iOff = (*TPager)(unsafe.Pointer(pPager)).FjournalOff /* We should never write to the journal file the page that ** contains the database locks. The following assert verifies ** that we do not. */ pData2 = (*TPgHdr)(unsafe.Pointer(pPg)).FpData cksum = _pager_cksum(tls, pPager, pData2) /* Even if an IO or diskfull error occurs while journalling the ** page in the block above, set the need-sync flag for the page. ** Otherwise, when the transaction is rolled back, the logic in ** playback_one_page() will think that the page needs to be restored ** in the database file. And if an IO error occurs while doing so, ** then corruption may follow. */ v1 = pPg + 28 *(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) | libc.Int32FromInt32(PGHDR_NEED_SYNC)) rc = _write32bits(tls, (*TPager)(unsafe.Pointer(pPager)).Fjfd, iOff, (*TPgHdr)(unsafe.Pointer(pPg)).Fpgno) if rc != SQLITE_OK { return rc } rc = _sqlite3OsWrite(tls, (*TPager)(unsafe.Pointer(pPager)).Fjfd, pData2, int32((*TPager)(unsafe.Pointer(pPager)).FpageSize), iOff+int64(4)) if rc != SQLITE_OK { return rc } rc = _write32bits(tls, (*TPager)(unsafe.Pointer(pPager)).Fjfd, iOff+(*TPager)(unsafe.Pointer(pPager)).FpageSize+int64(4), cksum) if rc != SQLITE_OK { return rc } **(**Ti64)(__ccgo_up(pPager + 80)) += int64(8) + (*TPager)(unsafe.Pointer(pPager)).FpageSize (*TPager)(unsafe.Pointer(pPager)).FnRec = (*TPager)(unsafe.Pointer(pPager)).FnRec + 1 rc = _sqlite3BitvecSet(tls, (*TPager)(unsafe.Pointer(pPager)).FpInJournal, (*TPgHdr)(unsafe.Pointer(pPg)).Fpgno) rc = rc | _addToSavepointBitvecs(tls, pPager, (*TPgHdr)(unsafe.Pointer(pPg)).Fpgno) return rc } // C documentation // // /* // ** This function is called before attempting a hot-journal rollback. It // ** syncs the journal file to disk, then sets pPager->journalHdr to the // ** size of the journal file so that the pager_playback() routine knows // ** that the entire journal file has been synced. // ** // ** Syncing a hot-journal to disk before attempting to roll it back ensures // ** that if a power-failure occurs during the rollback, the process that // ** attempts rollback following system recovery sees the same journal // ** content as this process. // ** // ** If everything goes as planned, SQLITE_OK is returned. Otherwise, // ** an SQLite error code. // */ func _pagerSyncHotJournal(tls *libc.TLS, pPager uintptr) (r int32) { var rc int32 _ = rc rc = SQLITE_OK if !((*TPager)(unsafe.Pointer(pPager)).FnoSync != 0) { rc = _sqlite3OsSync(tls, (*TPager)(unsafe.Pointer(pPager)).Fjfd, int32(SQLITE_SYNC_NORMAL)) } if rc == SQLITE_OK { rc = _sqlite3OsFileSize(tls, (*TPager)(unsafe.Pointer(pPager)).Fjfd, pPager+88) } return rc } // C documentation // // /* // ** This routine is called to increment the value of the database file // ** change-counter, stored as a 4-byte big-endian integer starting at // ** byte offset 24 of the pager file. The secondary change counter at // ** 92 is also updated, as is the SQLite version number at offset 96. // ** // ** But this only happens if the pPager->changeCountDone flag is false. // ** To avoid excess churning of page 1, the update only happens once. // ** See also the pager_write_changecounter() routine that does an // ** unconditional update of the change counters. // ** // ** If the isDirectMode flag is zero, then this is done by calling // ** sqlite3PagerWrite() on page 1, then modifying the contents of the // ** page data. In this case the file will be updated when the current // ** transaction is committed. // ** // ** The isDirectMode flag may only be non-zero if the library was compiled // ** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case, // ** if isDirect is non-zero, then the database file is updated directly // ** by writing an updated version of page 1 using a call to the // ** sqlite3OsWrite() function. // */ func _pager_incr_changecounter(tls *libc.TLS, pPager uintptr, isDirectMode int32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var pCopy, zBuf uintptr var rc int32 var _ /* pPgHdr at bp+0 */ uintptr _, _, _ = pCopy, rc, zBuf rc = SQLITE_OK /* Declare and initialize constant integer 'isDirect'. If the ** atomic-write optimization is enabled in this build, then isDirect ** is initialized to the value passed as the isDirectMode parameter ** to this function. Otherwise, it is always set to zero. ** ** The idea is that if the atomic-write optimization is not ** enabled at compile time, the compiler can omit the tests of ** 'isDirect' below, as well as the block enclosed in the ** "if( isDirect )" condition. */ _ = isDirectMode if !((*TPager)(unsafe.Pointer(pPager)).FchangeCountDone != 0) && (*TPager)(unsafe.Pointer(pPager)).FdbSize > uint32(0) { /* Reference to page 1 */ /* Open page 1 of the file for writing. */ rc = _sqlite3PagerGet(tls, pPager, uint32(1), bp, 0) /* If page one was fetched successfully, and this function is not ** operating in direct-mode, make page 1 writable. When not in ** direct mode, page 1 is always held in cache and hence the PagerGet() ** above is always successful - hence the ALWAYS on rc==SQLITE_OK. */ if libc.Bool(!(libc.Int32FromInt32(DIRECT_MODE) != 0)) && rc == SQLITE_OK { rc = _sqlite3PagerWrite(tls, **(**uintptr)(__ccgo_up(bp))) } if rc == SQLITE_OK { /* Actually do the update of the change counter */ _pager_write_changecounter(tls, **(**uintptr)(__ccgo_up(bp))) /* If running in direct mode, write the contents of page 1 to the file. */ if DIRECT_MODE != 0 { zBuf = (*TPgHdr)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp)))).FpData if rc == SQLITE_OK { rc = _sqlite3OsWrite(tls, (*TPager)(unsafe.Pointer(pPager)).Ffd, zBuf, int32((*TPager)(unsafe.Pointer(pPager)).FpageSize), 0) **(**Tu32)(__ccgo_up(pPager + 200 + 2*4)) = **(**Tu32)(__ccgo_up(pPager + 200 + 2*4)) + 1 } if rc == SQLITE_OK { /* Update the pager's copy of the change-counter. Otherwise, the ** next time a read transaction is opened the cache will be ** flushed (as the change-counter values will not match). */ pCopy = zBuf + 24 libc.Xmemcpy(tls, pPager+112, pCopy, uint32(16)) (*TPager)(unsafe.Pointer(pPager)).FchangeCountDone = uint8(1) } } else { (*TPager)(unsafe.Pointer(pPager)).FchangeCountDone = uint8(1) } } /* Release the page reference. */ _sqlite3PagerUnref(tls, **(**uintptr)(__ccgo_up(bp))) } return rc } // C documentation // // /* // ** Update the value of the change-counter at offsets 24 and 92 in // ** the header and the sqlite version number at offset 96. // ** // ** This is an unconditional update. See also the pager_incr_changecounter() // ** routine which only updates the change-counter if the update is actually // ** needed, as determined by the pPager->changeCountDone state variable. // */ func _pager_write_changecounter(tls *libc.TLS, pPg uintptr) { var change_counter Tu32 _ = change_counter if pPg == uintptr(0) { return } /* Increment the value just read and write it back to byte 24. */ change_counter = _sqlite3Get4byte(tls, (*TPgHdr)(unsafe.Pointer(pPg)).FpPager+112) + uint32(1) _sqlite3Put4byte(tls, (*TPgHdr)(unsafe.Pointer(pPg)).FpData+uintptr(24), change_counter) /* Also store the SQLite version number in bytes 96..99 and in ** bytes 92..95 store the change counter for which the version number ** is valid. */ _sqlite3Put4byte(tls, (*TPgHdr)(unsafe.Pointer(pPg)).FpData+uintptr(92), change_counter) _sqlite3Put4byte(tls, (*TPgHdr)(unsafe.Pointer(pPg)).FpData+uintptr(96), uint32(SQLITE_VERSION_NUMBER)) } // C documentation // // /* Return an integer that is the maximum allowed stack size */ func _parserStackSizeLimit(tls *libc.TLS, pParse uintptr) (r int32) { return **(**int32)(__ccgo_up((*TParse)(unsafe.Pointer(pParse)).Fdb + 120 + 12*4)) } // C documentation // // /* // ** Allocate and return an RBU handle with all fields zeroed except for the // ** error code, which is set to SQLITE_MISUSE. // */ func _rbuMisuseError(tls *libc.TLS) (r uintptr) { var pRet uintptr _ = pRet pRet = Xsqlite3_malloc64(tls, uint64(264)) if pRet != 0 { libc.Xmemset(tls, pRet, 0, uint32(264)) (*Tsqlite3rbu)(unsafe.Pointer(pRet)).Frc = int32(SQLITE_MISUSE) } return pRet } func _rbuTmpInsertFunc(tls *libc.TLS, pCtx uintptr, nVal int32, apVal uintptr) { var i, rc int32 var p uintptr _, _, _ = i, p, rc p = Xsqlite3_user_data(tls, pCtx) rc = SQLITE_OK if Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(apVal))) != 0 { **(**Ti64)(__ccgo_up(p + 184)) += int64((*Tsqlite3rbu)(unsafe.Pointer(p)).Fobjiter.FnIndex) } i = 0 for { if !(rc == SQLITE_OK && i < nVal) { break } rc = Xsqlite3_bind_value(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).Fobjiter.FpTmpInsert, i+int32(1), **(**uintptr)(__ccgo_up(apVal + uintptr(i)*4))) goto _1 _1: ; i = i + 1 } if rc == SQLITE_OK { Xsqlite3_step(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).Fobjiter.FpTmpInsert) rc = Xsqlite3_reset(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).Fobjiter.FpTmpInsert) } if rc != SQLITE_OK { Xsqlite3_result_error_code(tls, pCtx, rc) } } // C documentation // // /* // */ func _rbuUpdateTempSize(tls *libc.TLS, pFd uintptr, nNew Tsqlite3_int64) (r int32) { var nDiff Ti64 var pRbu uintptr _, _ = nDiff, pRbu pRbu = (*Trbu_file)(unsafe.Pointer(pFd)).FpRbu nDiff = nNew - (*Trbu_file)(unsafe.Pointer(pFd)).Fsz **(**Ti64)(__ccgo_up(pRbu + 240)) += nDiff (*Trbu_file)(unsafe.Pointer(pFd)).Fsz = nNew if (*Tsqlite3rbu)(unsafe.Pointer(pRbu)).FszTempLimit != 0 && (*Tsqlite3rbu)(unsafe.Pointer(pRbu)).FszTemp > (*Tsqlite3rbu)(unsafe.Pointer(pRbu)).FszTempLimit { return int32(SQLITE_FULL) } return SQLITE_OK } // C documentation // // /* // ** Remove connection db from the blocked connections list. If connection // ** db is not currently a part of the list, this function is a no-op. // */ func _removeFromBlockedList(tls *libc.TLS, db uintptr) { var pp uintptr _ = pp pp = uintptr(unsafe.Pointer(&_sqlite3BlockedList)) for { if !(**(**uintptr)(__ccgo_up(pp)) != 0) { break } if **(**uintptr)(__ccgo_up(pp)) == db { **(**uintptr)(__ccgo_up(pp)) = (*Tsqlite3)(unsafe.Pointer(**(**uintptr)(__ccgo_up(pp)))).FpNextBlocked break } goto _1 _1: ; pp = **(**uintptr)(__ccgo_up(pp)) + 576 } } // C documentation // // /* // ** Reset a cursor back to its initial state. // */ func _resetCursor(tls *libc.TLS, pCsr uintptr) { var i, ii int32 var pInfo, pRtree, pStmt uintptr _, _, _, _, _ = i, ii, pInfo, pRtree, pStmt pRtree = (*TRtreeCursor)(unsafe.Pointer(pCsr)).Fbase.FpVtab if (*TRtreeCursor)(unsafe.Pointer(pCsr)).FaConstraint != 0 { /* Used to iterate through constraint array */ i = 0 for { if !(i < (*TRtreeCursor)(unsafe.Pointer(pCsr)).FnConstraint) { break } pInfo = (**(**TRtreeConstraint)(__ccgo_up((*TRtreeCursor)(unsafe.Pointer(pCsr)).FaConstraint + uintptr(i)*24))).FpInfo if pInfo != 0 { if (*Tsqlite3_rtree_query_info)(unsafe.Pointer(pInfo)).FxDelUser != 0 { (*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3_rtree_query_info)(unsafe.Pointer(pInfo)).FxDelUser})))(tls, (*Tsqlite3_rtree_query_info)(unsafe.Pointer(pInfo)).FpUser) } Xsqlite3_free(tls, pInfo) } goto _1 _1: ; i = i + 1 } Xsqlite3_free(tls, (*TRtreeCursor)(unsafe.Pointer(pCsr)).FaConstraint) (*TRtreeCursor)(unsafe.Pointer(pCsr)).FaConstraint = uintptr(0) } ii = 0 for { if !(ii < int32(RTREE_CACHE_SZ)) { break } _nodeRelease(tls, pRtree, **(**uintptr)(__ccgo_up(pCsr + 64 + uintptr(ii)*4))) goto _2 _2: ; ii = ii + 1 } Xsqlite3_free(tls, (*TRtreeCursor)(unsafe.Pointer(pCsr)).FaPoint) pStmt = (*TRtreeCursor)(unsafe.Pointer(pCsr)).FpReadAux libc.Xmemset(tls, pCsr, 0, uint32(256)) (*TRtreeCursor)(unsafe.Pointer(pCsr)).Fbase.FpVtab = pRtree (*TRtreeCursor)(unsafe.Pointer(pCsr)).FpReadAux = pStmt /* The following will only fail if the previous sqlite3_step() call failed, ** in which case the error has already been caught. This statement never ** encounters an error within an sqlite3_column_xxx() function, as it ** calls sqlite3_column_value(), which does not use malloc(). So it is safe ** to ignore the error code here. */ Xsqlite3_reset(tls, pStmt) } // C documentation // // /* // ** Rtree virtual table module xOpen method. // */ func _rtreeOpen(tls *libc.TLS, pVTab uintptr, ppCursor uintptr) (r int32) { var pCsr, pRtree uintptr var rc int32 _, _, _ = pCsr, pRtree, rc rc = int32(SQLITE_NOMEM) pRtree = pVTab pCsr = Xsqlite3_malloc64(tls, uint64(256)) if pCsr != 0 { libc.Xmemset(tls, pCsr, 0, uint32(256)) (*TRtreeCursor)(unsafe.Pointer(pCsr)).Fbase.FpVtab = pVTab rc = SQLITE_OK (*TRtree)(unsafe.Pointer(pRtree)).FnCursor = (*TRtree)(unsafe.Pointer(pRtree)).FnCursor + 1 } **(**uintptr)(__ccgo_up(ppCursor)) = pCsr return rc } // C documentation // // /* // ** Decrement the r-tree reference count. When the reference count reaches // ** zero the structure is deleted. // */ func _rtreeRelease(tls *libc.TLS, pRtree uintptr) { var i int32 var pNext uintptr _, _ = i, pNext (*TRtree)(unsafe.Pointer(pRtree)).FnBusy = (*TRtree)(unsafe.Pointer(pRtree)).FnBusy - 1 if (*TRtree)(unsafe.Pointer(pRtree)).FnBusy == uint32(0) { (*TRtree)(unsafe.Pointer(pRtree)).FinWrTrans = uint8(0) _nodeBlobReset(tls, pRtree) if (*TRtree)(unsafe.Pointer(pRtree)).FnNodeRef != 0 { i = 0 for { if !(i < int32(HASHSIZE)) { break } for **(**uintptr)(__ccgo_up(pRtree + 120 + uintptr(i)*4)) != 0 { pNext = (*TRtreeNode)(unsafe.Pointer(**(**uintptr)(__ccgo_up(pRtree + 120 + uintptr(i)*4)))).FpNext Xsqlite3_free(tls, **(**uintptr)(__ccgo_up(pRtree + 120 + uintptr(i)*4))) **(**uintptr)(__ccgo_up(pRtree + 120 + uintptr(i)*4)) = pNext } goto _1 _1: ; i = i + 1 } } Xsqlite3_finalize(tls, (*TRtree)(unsafe.Pointer(pRtree)).FpWriteNode) Xsqlite3_finalize(tls, (*TRtree)(unsafe.Pointer(pRtree)).FpDeleteNode) Xsqlite3_finalize(tls, (*TRtree)(unsafe.Pointer(pRtree)).FpReadRowid) Xsqlite3_finalize(tls, (*TRtree)(unsafe.Pointer(pRtree)).FpWriteRowid) Xsqlite3_finalize(tls, (*TRtree)(unsafe.Pointer(pRtree)).FpDeleteRowid) Xsqlite3_finalize(tls, (*TRtree)(unsafe.Pointer(pRtree)).FpReadParent) Xsqlite3_finalize(tls, (*TRtree)(unsafe.Pointer(pRtree)).FpWriteParent) Xsqlite3_finalize(tls, (*TRtree)(unsafe.Pointer(pRtree)).FpDeleteParent) Xsqlite3_finalize(tls, (*TRtree)(unsafe.Pointer(pRtree)).FpWriteAux) Xsqlite3_free(tls, (*TRtree)(unsafe.Pointer(pRtree)).FzReadAuxSql) Xsqlite3_free(tls, pRtree) } } // C documentation // // /* // ** Interchange two search points in a cursor. // */ func _rtreeSearchPointSwap(tls *libc.TLS, p uintptr, i int32, j int32) { var pTemp uintptr var t TRtreeSearchPoint _, _ = pTemp, t t = **(**TRtreeSearchPoint)(__ccgo_up((*TRtreeCursor)(unsafe.Pointer(p)).FaPoint + uintptr(i)*24)) **(**TRtreeSearchPoint)(__ccgo_up((*TRtreeCursor)(unsafe.Pointer(p)).FaPoint + uintptr(i)*24)) = **(**TRtreeSearchPoint)(__ccgo_up((*TRtreeCursor)(unsafe.Pointer(p)).FaPoint + uintptr(j)*24)) **(**TRtreeSearchPoint)(__ccgo_up((*TRtreeCursor)(unsafe.Pointer(p)).FaPoint + uintptr(j)*24)) = t i = i + 1 j = j + 1 if i < int32(RTREE_CACHE_SZ) { if j >= int32(RTREE_CACHE_SZ) { _nodeRelease(tls, (*TRtreeCursor)(unsafe.Pointer(p)).Fbase.FpVtab, **(**uintptr)(__ccgo_up(p + 64 + uintptr(i)*4))) **(**uintptr)(__ccgo_up(p + 64 + uintptr(i)*4)) = uintptr(0) } else { pTemp = **(**uintptr)(__ccgo_up(p + 64 + uintptr(i)*4)) **(**uintptr)(__ccgo_up(p + 64 + uintptr(i)*4)) = **(**uintptr)(__ccgo_up(p + 64 + uintptr(j)*4)) **(**uintptr)(__ccgo_up(p + 64 + uintptr(j)*4)) = pTemp } } } // C documentation // // /* // ** Field iChng of the index being scanned has changed. So at this point // ** p->current contains a sample that reflects the previous row of the // ** index. The value of anEq[iChng] and subsequent anEq[] elements are // ** correct at this point. // */ func _samplePushPrevious(tls *libc.TLS, p uintptr, iChng int32) { var i, j, j1 int32 var pBest uintptr _, _, _, _ = i, j, j1, pBest /* Check if any samples from the aBest[] array should be pushed ** into IndexSample.a[] at this point. */ i = (*TStatAccum)(unsafe.Pointer(p)).FnCol - int32(2) for { if !(i >= iChng) { break } pBest = (*TStatAccum)(unsafe.Pointer(p)).FaBest + uintptr(i)*40 **(**TtRowcnt)(__ccgo_up((*TStatSample)(unsafe.Pointer(pBest)).FanEq + uintptr(i)*8)) = **(**TtRowcnt)(__ccgo_up((*TStatAccum)(unsafe.Pointer(p)).Fcurrent.FanEq + uintptr(i)*8)) if (*TStatAccum)(unsafe.Pointer(p)).FnSample < (*TStatAccum)(unsafe.Pointer(p)).FmxSample || _sampleIsBetter(tls, p, pBest, (*TStatAccum)(unsafe.Pointer(p)).Fa+uintptr((*TStatAccum)(unsafe.Pointer(p)).FiMin)*40) != 0 { _sampleInsert(tls, p, pBest, i) } goto _1 _1: ; i = i - 1 } /* Check that no sample contains an anEq[] entry with an index of ** p->nMaxEqZero or greater set to zero. */ i = (*TStatAccum)(unsafe.Pointer(p)).FnSample - int32(1) for { if !(i >= 0) { break } j = (*TStatAccum)(unsafe.Pointer(p)).FnMaxEqZero for { if !(j < (*TStatAccum)(unsafe.Pointer(p)).FnCol) { break } goto _3 _3: ; j = j + 1 } goto _2 _2: ; i = i - 1 } /* Update the anEq[] fields of any samples already collected. */ if iChng < (*TStatAccum)(unsafe.Pointer(p)).FnMaxEqZero { i = (*TStatAccum)(unsafe.Pointer(p)).FnSample - int32(1) for { if !(i >= 0) { break } j1 = iChng for { if !(j1 < (*TStatAccum)(unsafe.Pointer(p)).FnCol) { break } if **(**TtRowcnt)(__ccgo_up((**(**TStatSample)(__ccgo_up((*TStatAccum)(unsafe.Pointer(p)).Fa + uintptr(i)*40))).FanEq + uintptr(j1)*8)) == uint64(0) { **(**TtRowcnt)(__ccgo_up((**(**TStatSample)(__ccgo_up((*TStatAccum)(unsafe.Pointer(p)).Fa + uintptr(i)*40))).FanEq + uintptr(j1)*8)) = **(**TtRowcnt)(__ccgo_up((*TStatAccum)(unsafe.Pointer(p)).Fcurrent.FanEq + uintptr(j1)*8)) } goto _5 _5: ; j1 = j1 + 1 } goto _4 _4: ; i = i - 1 } (*TStatAccum)(unsafe.Pointer(p)).FnMaxEqZero = iChng } } // C documentation // // /* Initialize the INTEGER value of a ROWID. // */ func _sampleSetRowidInt64(tls *libc.TLS, db uintptr, p uintptr, iRowid Ti64) { if (*TStatSample)(unsafe.Pointer(p)).FnRowid != 0 { _sqlite3DbFree(tls, db, *(*uintptr)(unsafe.Pointer(&(*TStatSample)(unsafe.Pointer(p)).Fu))) } (*TStatSample)(unsafe.Pointer(p)).FnRowid = uint32(0) *(*Ti64)(unsafe.Pointer(p + 16)) = iRowid } // C documentation // // /* // ** Look through the list of open database files in db->aDb[] and if // ** any have been closed, remove them from the list. Reallocate the // ** db->aDb[] structure to a smaller size, if possible. // ** // ** Entry 0 (the "main" database) and entry 1 (the "temp" database) // ** are never candidates for being collapsed. // */ func _sqlite3CollapseDatabaseArray(tls *libc.TLS, db uintptr) { var i, j, v2 int32 var pDb uintptr _, _, _, _ = i, j, pDb, v2 v2 = libc.Int32FromInt32(2) j = v2 i = v2 for { if !(i < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) { break } pDb = (*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16 if (*TDb)(unsafe.Pointer(pDb)).FpBt == uintptr(0) { _sqlite3DbFree(tls, db, (*TDb)(unsafe.Pointer(pDb)).FzDbSName) (*TDb)(unsafe.Pointer(pDb)).FzDbSName = uintptr(0) goto _1 } if j < i { **(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(j)*16)) = **(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16)) } j = j + 1 goto _1 _1: ; i = i + 1 } (*Tsqlite3)(unsafe.Pointer(db)).FnDb = j if (*Tsqlite3)(unsafe.Pointer(db)).FnDb <= int32(2) && (*Tsqlite3)(unsafe.Pointer(db)).FaDb != db+476 { libc.Xmemcpy(tls, db+476, (*Tsqlite3)(unsafe.Pointer(db)).FaDb, libc.Uint32FromInt32(2)*libc.Uint32FromInt64(16)) _sqlite3DbFree(tls, db, (*Tsqlite3)(unsafe.Pointer(db)).FaDb) (*Tsqlite3)(unsafe.Pointer(db)).FaDb = db + 476 } } func _sqlite3DbMallocRawNN(tls *libc.TLS, db uintptr, n Tu64) (r uintptr) { var pBuf, v1 uintptr _, _ = pBuf, v1 if n > uint64((*Tsqlite3)(unsafe.Pointer(db)).Flookaside.Fsz) { if !((*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FbDisable != 0) { **(**Tu32)(__ccgo_up(db + 320 + 16 + 1*4)) = **(**Tu32)(__ccgo_up(db + 320 + 16 + 1*4)) + 1 } else { if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 { return uintptr(0) } } return _dbMallocRawFinish(tls, db, n) } if n <= uint64(LOOKASIDE_SMALL) { v1 = (*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FpSmallFree pBuf = v1 if v1 != uintptr(0) { (*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FpSmallFree = (*TLookasideSlot)(unsafe.Pointer(pBuf)).FpNext **(**Tu32)(__ccgo_up(db + 320 + 16)) = **(**Tu32)(__ccgo_up(db + 320 + 16)) + 1 return pBuf } else { v1 = (*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FpSmallInit pBuf = v1 if v1 != uintptr(0) { (*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FpSmallInit = (*TLookasideSlot)(unsafe.Pointer(pBuf)).FpNext **(**Tu32)(__ccgo_up(db + 320 + 16)) = **(**Tu32)(__ccgo_up(db + 320 + 16)) + 1 return pBuf } } } v1 = (*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FpFree pBuf = v1 if v1 != uintptr(0) { (*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FpFree = (*TLookasideSlot)(unsafe.Pointer(pBuf)).FpNext **(**Tu32)(__ccgo_up(db + 320 + 16)) = **(**Tu32)(__ccgo_up(db + 320 + 16)) + 1 return pBuf } else { v1 = (*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FpInit pBuf = v1 if v1 != uintptr(0) { (*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FpInit = (*TLookasideSlot)(unsafe.Pointer(pBuf)).FpNext **(**Tu32)(__ccgo_up(db + 320 + 16)) = **(**Tu32)(__ccgo_up(db + 320 + 16)) + 1 return pBuf } else { **(**Tu32)(__ccgo_up(db + 320 + 16 + 2*4)) = **(**Tu32)(__ccgo_up(db + 320 + 16 + 2*4)) + 1 } } return _dbMallocRawFinish(tls, db, n) } func _sqlite3Fts5IndexOptimize(tls *libc.TLS, p uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var iLvl int32 var pStruct uintptr var _ /* nRem at bp+4 */ int32 var _ /* pNew at bp+0 */ uintptr _, _ = iLvl, pStruct **(**uintptr)(__ccgo_up(bp)) = uintptr(0) _fts5IndexFlush(tls, p) pStruct = _fts5StructureRead(tls, p) _fts5StructureInvalidate(tls, p) if pStruct != 0 { **(**uintptr)(__ccgo_up(bp)) = _fts5IndexOptimizeStruct(tls, p, pStruct) } _fts5StructureRelease(tls, pStruct) if **(**uintptr)(__ccgo_up(bp)) != 0 { iLvl = 0 for { if !((*(*TFts5StructureLevel)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp)) + 32 + uintptr(iLvl)*12))).FnSeg == 0) { break } goto _1 _1: ; iLvl = iLvl + 1 } for (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK && (*(*TFts5StructureLevel)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp)) + 32 + uintptr(iLvl)*12))).FnSeg > 0 { **(**int32)(__ccgo_up(bp + 4)) = int32(FTS5_OPT_WORK_UNIT) _fts5IndexMergeLevel(tls, p, bp, iLvl, bp+4) } _fts5StructureWrite(tls, p, **(**uintptr)(__ccgo_up(bp))) _fts5StructureRelease(tls, **(**uintptr)(__ccgo_up(bp))) } return _fts5IndexReturn(tls, p) } // C documentation // // /* // ** This is used by xInstToken() to access the token at offset iOff, column // ** iCol of row iRowid. The token is returned via output variables *ppOut // ** and *pnOut. The iterator passed as the first argument must be a tokendata=1 // ** iterator (pIter->pTokenDataIter!=0). // ** // ** pToken/nToken: // */ func _sqlite3Fts5IterToken(tls *libc.TLS, pIndexIter uintptr, pToken uintptr, nToken int32, iRowid Ti64, iCol int32, iOff int32, ppOut uintptr, pnOut uintptr) (r int32) { var aMap, p, pIter, pMap, pT uintptr var i1, i2, iTest, rc int32 var iPos Ti64 _, _, _, _, _, _, _, _, _, _ = aMap, i1, i2, iPos, iTest, p, pIter, pMap, pT, rc pIter = pIndexIter pT = (*TFts5Iter)(unsafe.Pointer(pIter)).FpTokenDataIter iPos = int64(iCol)< i1 { iTest = (i1 + i2) / int32(2) if (**(**TFts5TokenDataMap)(__ccgo_up(aMap + uintptr(iTest)*24))).FiRowid < iRowid { i1 = iTest + int32(1) } else { if (**(**TFts5TokenDataMap)(__ccgo_up(aMap + uintptr(iTest)*24))).FiRowid > iRowid { i2 = iTest } else { if (**(**TFts5TokenDataMap)(__ccgo_up(aMap + uintptr(iTest)*24))).FiPos < iPos { if (**(**TFts5TokenDataMap)(__ccgo_up(aMap + uintptr(iTest)*24))).FiPos < 0 { break } i1 = iTest + int32(1) } else { if (**(**TFts5TokenDataMap)(__ccgo_up(aMap + uintptr(iTest)*24))).FiPos > iPos { i2 = iTest } else { break } } } } } if i2 > i1 { if (*TFts5Iter)(unsafe.Pointer(pIter)).FnSeg == 0 { pMap = *(*uintptr)(unsafe.Pointer(pT + 56 + uintptr((**(**TFts5TokenDataMap)(__ccgo_up(aMap + uintptr(iTest)*24))).FiIter)*4)) **(**uintptr)(__ccgo_up(ppOut)) = (*(*TFts5SegIter)(unsafe.Pointer(pMap + 80))).Fterm.Fp + uintptr(1) **(**int32)(__ccgo_up(pnOut)) = (*(*TFts5SegIter)(unsafe.Pointer(pMap + 80))).Fterm.Fn - int32(1) } else { p = aMap + uintptr(iTest)*24 **(**uintptr)(__ccgo_up(ppOut)) = (*TFts5TokenDataIter)(unsafe.Pointer(pT)).Fterms.Fp + uintptr((*TFts5TokenDataMap)(unsafe.Pointer(p)).FiIter) **(**int32)(__ccgo_up(pnOut)) = (**(**TFts5TokenDataMap)(__ccgo_up(aMap + uintptr(iTest)*24))).FnByte } } return SQLITE_OK } // C documentation // // /* // ** Free the expression node object passed as the only argument. // */ func _sqlite3Fts5ParseNodeFree(tls *libc.TLS, p uintptr) { var i int32 _ = i if p != 0 { i = 0 for { if !(i < (*TFts5ExprNode)(unsafe.Pointer(p)).FnChild) { break } _sqlite3Fts5ParseNodeFree(tls, *(*uintptr)(unsafe.Pointer(p + 40 + uintptr(i)*4))) goto _1 _1: ; i = i + 1 } _sqlite3Fts5ParseNearsetFree(tls, (*TFts5ExprNode)(unsafe.Pointer(p)).FpNear) Xsqlite3_free(tls, p) } } // C documentation // // /* // ** Obtain an SQLite statement handle that may be used to read data from the // ** %_content table. // */ func _sqlite3Fts5StorageStmt(tls *libc.TLS, p uintptr, eStmt int32, pp uintptr, pzErrMsg uintptr) (r int32) { var rc int32 _ = rc rc = _fts5StorageGetStmt(tls, p, eStmt, pp, pzErrMsg) if rc == SQLITE_OK { **(**uintptr)(__ccgo_up(p + 32 + uintptr(eStmt)*4)) = uintptr(0) } return rc } // C documentation // // /* // ** Release an SQLite statement handle obtained via an earlier call to // ** sqlite3Fts5StorageStmt(). The eStmt parameter passed to this function // ** must match that passed to the sqlite3Fts5StorageStmt() call. // */ func _sqlite3Fts5StorageStmtRelease(tls *libc.TLS, p uintptr, eStmt int32, pStmt uintptr) { if **(**uintptr)(__ccgo_up(p + 32 + uintptr(eStmt)*4)) == uintptr(0) { Xsqlite3_reset(tls, pStmt) **(**uintptr)(__ccgo_up(p + 32 + uintptr(eStmt)*4)) = pStmt } else { Xsqlite3_finalize(tls, pStmt) } } // C documentation // // /* // ** Return the number of bytes required to store a JournalFile that uses vfs // ** pVfs to create the underlying on-disk files. // */ func _sqlite3JournalSize(tls *libc.TLS, pVfs uintptr) (r int32) { var v1 int32 _ = v1 if (*Tsqlite3_vfs)(unsafe.Pointer(pVfs)).FszOsFile > libc.Int32FromInt64(64) { v1 = (*Tsqlite3_vfs)(unsafe.Pointer(pVfs)).FszOsFile } else { v1 = libc.Int32FromInt64(64) } return v1 } /************** End of memjournal.c ******************************************/ /************** Begin file walker.c ******************************************/ /* ** 2008 August 16 ** ** 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 contains routines used for walking the parser tree for ** an SQL statement. */ /* #include "sqliteInt.h" */ /* #include */ /* #include */ // C documentation // // /* // ** Deinitialize the memory allocation subsystem. // */ func _sqlite3MallocEnd(tls *libc.TLS) { if _sqlite3Config.Fm.FxShutdown != 0 { (*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_sqlite3Config.Fm.FxShutdown})))(tls, _sqlite3Config.Fm.FpAppData) } libc.Xmemset(tls, uintptr(unsafe.Pointer(&_mem0)), 0, uint32(32)) } // C documentation // // /* // ** Initialize the memory allocation subsystem. // */ func _sqlite3MallocInit(tls *libc.TLS) (r int32) { var rc int32 _ = rc if _sqlite3Config.Fm.FxMalloc == uintptr(0) { _sqlite3MemSetDefault(tls) } _mem0.Fmutex = _sqlite3MutexAlloc(tls, int32(SQLITE_MUTEX_STATIC_MEM)) if _sqlite3Config.FpPage == uintptr(0) || _sqlite3Config.FszPage < int32(512) || _sqlite3Config.FnPage <= 0 { _sqlite3Config.FpPage = uintptr(0) _sqlite3Config.FszPage = 0 } rc = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{_sqlite3Config.Fm.FxInit})))(tls, _sqlite3Config.Fm.FpAppData) if rc != SQLITE_OK { libc.Xmemset(tls, uintptr(unsafe.Pointer(&_mem0)), 0, uint32(32)) } return rc } // C documentation // // /* // ** Return a pointer to the pPager->pBackup variable. The backup module // ** in backup.c maintains the content of this variable. This module // ** uses it opaquely as an argument to sqlite3BackupRestart() and // ** sqlite3BackupUpdate() only. // */ func _sqlite3PagerBackupPtr(tls *libc.TLS, pPager uintptr) (r uintptr) { return pPager + 96 } // C documentation // // /* // ** Parameter eStat must be one of SQLITE_DBSTATUS_CACHE_HIT, _MISS, _WRITE, // ** or _WRITE+1. The SQLITE_DBSTATUS_CACHE_WRITE+1 case is a translation // ** of SQLITE_DBSTATUS_CACHE_SPILL. The _SPILL case is not contiguous because // ** it was added later. // ** // ** Before returning, *pnVal is incremented by the // ** current cache hit or miss count, according to the value of eStat. If the // ** reset parameter is non-zero, the cache hit or miss count is zeroed before // ** returning. // */ func _sqlite3PagerCacheStat(tls *libc.TLS, pPager uintptr, eStat int32, reset int32, pnVal uintptr) { eStat = eStat - int32(SQLITE_DBSTATUS_CACHE_HIT) **(**Tu64)(__ccgo_up(pnVal)) += uint64(**(**Tu32)(__ccgo_up(pPager + 200 + uintptr(eStat)*4))) if reset != 0 { **(**Tu32)(__ccgo_up(pPager + 200 + uintptr(eStat)*4)) = uint32(0) } } // C documentation // // /* // ** Set the busy handler function. // ** // ** The pager invokes the busy-handler if sqlite3OsLock() returns // ** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock, // ** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE // ** lock. It does *not* invoke the busy handler when upgrading from // ** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE // ** (which occurs during hot-journal rollback). Summary: // ** // ** Transition | Invokes xBusyHandler // ** -------------------------------------------------------- // ** NO_LOCK -> SHARED_LOCK | Yes // ** SHARED_LOCK -> RESERVED_LOCK | No // ** SHARED_LOCK -> EXCLUSIVE_LOCK | No // ** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes // ** // ** If the busy-handler callback returns non-zero, the lock is // ** retried. If it returns zero, then the SQLITE_BUSY error is // ** returned to the caller of the pager API function. // */ func _sqlite3PagerSetBusyHandler(tls *libc.TLS, pPager uintptr, __ccgo_fp_xBusyHandler uintptr, pBusyHandlerArg uintptr) { var ap uintptr _ = ap (*TPager)(unsafe.Pointer(pPager)).FxBusyHandler = __ccgo_fp_xBusyHandler (*TPager)(unsafe.Pointer(pPager)).FpBusyHandlerArg = pBusyHandlerArg ap = pPager + 192 _sqlite3OsFileControlHint(tls, (*TPager)(unsafe.Pointer(pPager)).Ffd, int32(SQLITE_FCNTL_BUSYHANDLER), ap) } // C documentation // // /* // ** Return the size in bytes of a PCache object. // */ func _sqlite3PcacheSize(tls *libc.TLS) (r int32) { return int32(56) } // C documentation // // /* // ** Check for interrupts and invoke progress callback. // */ func _sqlite3ProgressCheck(tls *libc.TLS, p uintptr) { var db, v2 uintptr var v1 Tu32 _, _, _ = db, v1, v2 db = (*TParse)(unsafe.Pointer(p)).Fdb if libc.AtomicLoadNInt32(db+312, libc.Int32FromInt32(__ATOMIC_RELAXED)) != 0 { (*TParse)(unsafe.Pointer(p)).FnErr = (*TParse)(unsafe.Pointer(p)).FnErr + 1 (*TParse)(unsafe.Pointer(p)).Frc = int32(SQLITE_INTERRUPT) } if (*Tsqlite3)(unsafe.Pointer(db)).FxProgress != 0 { if (*TParse)(unsafe.Pointer(p)).Frc == int32(SQLITE_INTERRUPT) { (*TParse)(unsafe.Pointer(p)).FnProgressSteps = uint32(0) } else { v2 = p + 104 *(*Tu32)(unsafe.Pointer(v2)) = *(*Tu32)(unsafe.Pointer(v2)) + 1 v1 = *(*Tu32)(unsafe.Pointer(v2)) if v1 >= (*Tsqlite3)(unsafe.Pointer(db)).FnProgressOps { if (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3)(unsafe.Pointer(db)).FxProgress})))(tls, (*Tsqlite3)(unsafe.Pointer(db)).FpProgressArg) != 0 { (*TParse)(unsafe.Pointer(p)).FnErr = (*TParse)(unsafe.Pointer(p)).FnErr + 1 (*TParse)(unsafe.Pointer(p)).Frc = int32(SQLITE_INTERRUPT) } (*TParse)(unsafe.Pointer(p)).FnProgressSteps = uint32(0) } } } } // C documentation // // /* // ** Resolve names in expressions that can only reference a single table // ** or which cannot reference any tables at all. Examples: // ** // ** "type" flag // ** ------------ // ** (1) CHECK constraints NC_IsCheck // ** (2) WHERE clauses on partial indices NC_PartIdx // ** (3) Expressions in indexes on expressions NC_IdxExpr // ** (4) Expression arguments to VACUUM INTO. 0 // ** (5) GENERATED ALWAYS as expressions NC_GenCol // ** // ** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN // ** nodes of the expression is set to -1 and the Expr.iColumn value is // ** set to the column number. In case (4), TK_COLUMN nodes cause an error. // ** // ** Any errors cause an error message to be set in pParse. // */ func _sqlite3ResolveSelfReference(tls *libc.TLS, pParse uintptr, pTab uintptr, type1 int32, pExpr uintptr, pList uintptr) (r int32) { bp := tls.Alloc(96) defer tls.Free(96) var pSrc uintptr var rc, v1 int32 var _ /* sNC at bp+0 */ TNameContext var _ /* uSrc at bp+40 */ struct { F__ccgo_align [0]uint32 FsrcSpace [0][56]Tu8 FsSrc TSrcList F__ccgo_pad2 [48]byte } _, _, _ = pSrc, rc, v1 libc.Xmemset(tls, bp, 0, uint32(36)) libc.Xmemset(tls, bp+40, 0, uint32(56)) pSrc = bp + 40 if pTab != 0 { (*TSrcList)(unsafe.Pointer(pSrc)).FnSrc = int32(1) (*(*TSrcItem)(unsafe.Pointer(pSrc + 8))).FzName = (*TTable)(unsafe.Pointer(pTab)).FzName (*(*TSrcItem)(unsafe.Pointer(pSrc + 8))).FpSTab = pTab (*(*TSrcItem)(unsafe.Pointer(pSrc + 8))).FiCursor = -int32(1) if (*TTable)(unsafe.Pointer(pTab)).FpSchema != (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer(pParse)).Fdb)).FaDb + 1*16))).FpSchema { /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP ** schema elements */ type1 = type1 | int32(NC_FromDDL) } } (**(**TNameContext)(__ccgo_up(bp))).FpParse = pParse (**(**TNameContext)(__ccgo_up(bp))).FpSrcList = pSrc (**(**TNameContext)(__ccgo_up(bp))).FncFlags = type1 | int32(NC_IsDDL) v1 = _sqlite3ResolveExprNames(tls, bp, pExpr) rc = v1 if v1 != SQLITE_OK { return rc } if pList != 0 { rc = _sqlite3ResolveExprListNames(tls, bp, pList) } return rc } // C documentation // // /* // ** Return the current time for a statement. If the current time // ** is requested more than once within the same run of a single prepared // ** statement, the exact same time is returned for each invocation regardless // ** of the amount of time that elapses between invocations. In other words, // ** the time returned is always the time of the first call. // */ func _sqlite3StmtCurrentTime(tls *libc.TLS, p uintptr) (r Tsqlite3_int64) { bp := tls.Alloc(16) defer tls.Free(16) var piTime, v1 uintptr var rc int32 var _ /* iTime at bp+0 */ Tsqlite3_int64 _, _, _ = piTime, rc, v1 **(**Tsqlite3_int64)(__ccgo_up(bp)) = 0 if (*Tsqlite3_context)(unsafe.Pointer(p)).FpVdbe != uintptr(0) { v1 = (*Tsqlite3_context)(unsafe.Pointer(p)).FpVdbe + 56 } else { v1 = bp } piTime = v1 if **(**Tsqlite3_int64)(__ccgo_up(piTime)) == 0 { rc = _sqlite3OsCurrentTimeInt64(tls, (*Tsqlite3)(unsafe.Pointer((*TMem)(unsafe.Pointer((*Tsqlite3_context)(unsafe.Pointer(p)).FpOut)).Fdb)).FpVfs, piTime) if rc != 0 { **(**Tsqlite3_int64)(__ccgo_up(piTime)) = 0 } } return **(**Tsqlite3_int64)(__ccgo_up(piTime)) } // C documentation // // /* // ** Set a flag in the vdbe to update the change counter when it is finalised // ** or reset. // */ func _sqlite3VdbeCountChanges(tls *libc.TLS, v uintptr) { libc.SetBitFieldPtr16Uint32(v+152, libc.Uint32FromInt32(1), 4, 0x10) } // C documentation // // /* // ** Create a new virtual database engine. // */ func _sqlite3VdbeCreate(tls *libc.TLS, pParse uintptr) (r uintptr) { var db, p uintptr _, _ = db, p db = (*TParse)(unsafe.Pointer(pParse)).Fdb p = _sqlite3DbMallocRawNN(tls, db, uint64(232)) if p == uintptr(0) { return uintptr(0) } libc.Xmemset(tls, p+104, 0, libc.Uint32FromInt64(232)-uint32(libc.UintptrFromInt32(0)+104)) (*TVdbe)(unsafe.Pointer(p)).Fdb = db if (*Tsqlite3)(unsafe.Pointer(db)).FpVdbe != 0 { (*TVdbe)(unsafe.Pointer((*Tsqlite3)(unsafe.Pointer(db)).FpVdbe)).FppVPrev = p + 8 } (*TVdbe)(unsafe.Pointer(p)).FpVNext = (*Tsqlite3)(unsafe.Pointer(db)).FpVdbe (*TVdbe)(unsafe.Pointer(p)).FppVPrev = db + 4 (*Tsqlite3)(unsafe.Pointer(db)).FpVdbe = p (*TVdbe)(unsafe.Pointer(p)).FpParse = pParse (*TParse)(unsafe.Pointer(pParse)).FpVdbe = p _sqlite3VdbeAddOp2(tls, p, int32(OP_Init), 0, int32(1)) return p } // C documentation // // /* // ** Copy the values stored in the VdbeFrame structure to its Vdbe. This // ** is used, for example, when a trigger sub-program is halted to restore // ** control to the main program. // */ func _sqlite3VdbeFrameRestore(tls *libc.TLS, pFrame uintptr) (r int32) { var v uintptr _ = v v = (*TVdbeFrame)(unsafe.Pointer(pFrame)).Fv _closeCursorsInFrame(tls, v) (*TVdbe)(unsafe.Pointer(v)).FaOp = (*TVdbeFrame)(unsafe.Pointer(pFrame)).FaOp (*TVdbe)(unsafe.Pointer(v)).FnOp = (*TVdbeFrame)(unsafe.Pointer(pFrame)).FnOp (*TVdbe)(unsafe.Pointer(v)).FaMem = (*TVdbeFrame)(unsafe.Pointer(pFrame)).FaMem (*TVdbe)(unsafe.Pointer(v)).FnMem = (*TVdbeFrame)(unsafe.Pointer(pFrame)).FnMem (*TVdbe)(unsafe.Pointer(v)).FapCsr = (*TVdbeFrame)(unsafe.Pointer(pFrame)).FapCsr (*TVdbe)(unsafe.Pointer(v)).FnCursor = (*TVdbeFrame)(unsafe.Pointer(pFrame)).FnCursor (*Tsqlite3)(unsafe.Pointer((*TVdbe)(unsafe.Pointer(v)).Fdb)).FlastRowid = (*TVdbeFrame)(unsafe.Pointer(pFrame)).FlastRowid (*TVdbe)(unsafe.Pointer(v)).FnChange = (*TVdbeFrame)(unsafe.Pointer(pFrame)).FnChange (*Tsqlite3)(unsafe.Pointer((*TVdbe)(unsafe.Pointer(v)).Fdb)).FnChange = (*TVdbeFrame)(unsafe.Pointer(pFrame)).FnDbChange _sqlite3VdbeDeleteAuxData(tls, (*TVdbe)(unsafe.Pointer(v)).Fdb, v+228, -int32(1), 0) (*TVdbe)(unsafe.Pointer(v)).FpAuxData = (*TVdbeFrame)(unsafe.Pointer(pFrame)).FpAuxData (*TVdbeFrame)(unsafe.Pointer(pFrame)).FpAuxData = uintptr(0) return (*TVdbeFrame)(unsafe.Pointer(pFrame)).Fpc } // C documentation // // /* // ** Memory cell pMem contains the context of an aggregate function. // ** This routine calls the finalize method for that function. The // ** result of the aggregate is stored back into pMem. // ** // ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK // ** otherwise. // */ func _sqlite3VdbeMemFinalize(tls *libc.TLS, pMem uintptr, pFunc uintptr) (r int32) { bp := tls.Alloc(80) defer tls.Free(80) var _ /* ctx at bp+0 */ Tsqlite3_context var _ /* t at bp+32 */ TMem libc.Xmemset(tls, bp, 0, uint32(28)) libc.Xmemset(tls, bp+32, 0, uint32(40)) (**(**TMem)(__ccgo_up(bp + 32))).Fflags = uint16(MEM_Null) (**(**TMem)(__ccgo_up(bp + 32))).Fdb = (*TMem)(unsafe.Pointer(pMem)).Fdb (**(**Tsqlite3_context)(__ccgo_up(bp))).FpOut = bp + 32 (**(**Tsqlite3_context)(__ccgo_up(bp))).FpMem = pMem (**(**Tsqlite3_context)(__ccgo_up(bp))).FpFunc = pFunc (**(**Tsqlite3_context)(__ccgo_up(bp))).Fenc = (*Tsqlite3)(unsafe.Pointer((**(**TMem)(__ccgo_up(bp + 32))).Fdb)).Fenc (*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TFuncDef)(unsafe.Pointer(pFunc)).FxFinalize})))(tls, bp) /* IMP: R-24505-23230 */ if (*TMem)(unsafe.Pointer(pMem)).FszMalloc > 0 { _sqlite3DbFreeNN(tls, (*TMem)(unsafe.Pointer(pMem)).Fdb, (*TMem)(unsafe.Pointer(pMem)).FzMalloc) } libc.Xmemcpy(tls, pMem, bp+32, uint32(40)) return (**(**Tsqlite3_context)(__ccgo_up(bp))).FisError } // C documentation // // /* // ** This routine sets the value to be returned by subsequent calls to // ** sqlite3_changes() on the database handle 'db'. // */ func _sqlite3VdbeSetChanges(tls *libc.TLS, db uintptr, nChange Ti64) { (*Tsqlite3)(unsafe.Pointer(db)).FnChange = nChange **(**Ti64)(__ccgo_up(db + 112)) += nChange } // C documentation // // /* // ** Configure SQL variable iVar so that binding a new value to it signals // ** to sqlite3_reoptimize() that re-preparing the statement may result // ** in a better query plan. // */ func _sqlite3VdbeSetVarmask(tls *libc.TLS, v uintptr, iVar int32) { if iVar >= int32(32) { **(**Tu32)(__ccgo_up(v + 220)) |= uint32(0x80000000) } else { **(**Tu32)(__ccgo_up(v + 220)) |= libc.Uint32FromInt32(1) << (iVar - libc.Int32FromInt32(1)) } } // C documentation // // /* // ** Swap byte-code between two VDBE structures. // ** // ** This happens after pB was previously run and returned // ** SQLITE_SCHEMA. The statement was then reprepared in pA. // ** This routine transfers the new bytecode in pA over to pB // ** so that pB can be run again. The old pB byte code is // ** moved back to pA so that it will be cleaned up when pA is // ** finalized. // */ func _sqlite3VdbeSwap(tls *libc.TLS, pA uintptr, pB uintptr) { var pTmp, ppTmp, zTmp uintptr var tmp TVdbe _, _, _, _ = pTmp, ppTmp, tmp, zTmp tmp = **(**TVdbe)(__ccgo_up(pA)) **(**TVdbe)(__ccgo_up(pA)) = **(**TVdbe)(__ccgo_up(pB)) **(**TVdbe)(__ccgo_up(pB)) = tmp pTmp = (*TVdbe)(unsafe.Pointer(pA)).FpVNext (*TVdbe)(unsafe.Pointer(pA)).FpVNext = (*TVdbe)(unsafe.Pointer(pB)).FpVNext (*TVdbe)(unsafe.Pointer(pB)).FpVNext = pTmp ppTmp = (*TVdbe)(unsafe.Pointer(pA)).FppVPrev (*TVdbe)(unsafe.Pointer(pA)).FppVPrev = (*TVdbe)(unsafe.Pointer(pB)).FppVPrev (*TVdbe)(unsafe.Pointer(pB)).FppVPrev = ppTmp zTmp = (*TVdbe)(unsafe.Pointer(pA)).FzSql (*TVdbe)(unsafe.Pointer(pA)).FzSql = (*TVdbe)(unsafe.Pointer(pB)).FzSql (*TVdbe)(unsafe.Pointer(pB)).FzSql = zTmp (*TVdbe)(unsafe.Pointer(pB)).Fexpmask = (*TVdbe)(unsafe.Pointer(pA)).Fexpmask (*TVdbe)(unsafe.Pointer(pB)).FprepFlags = (*TVdbe)(unsafe.Pointer(pA)).FprepFlags libc.Xmemcpy(tls, pB+164, pA+164, uint32(36)) **(**Tu32)(__ccgo_up(pB + 164 + 5*4)) = **(**Tu32)(__ccgo_up(pB + 164 + 5*4)) + 1 } // C documentation // // /* // ** Declare to the Vdbe that the BTree object at db->aDb[i] is used. // ** // ** The prepared statements need to know in advance the complete set of // ** attached databases that will be use. A mask of these databases // ** is maintained in p->btreeMask. The p->lockMask value is the subset of // ** p->btreeMask of databases that will require a lock. // */ func _sqlite3VdbeUsesBtree(tls *libc.TLS, p uintptr, i int32) { **(**TyDbMask)(__ccgo_up(p + 156)) |= libc.Uint32FromInt32(1) << i if i != int32(1) && _sqlite3BtreeSharable(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer((*TVdbe)(unsafe.Pointer(p)).Fdb)).FaDb + uintptr(i)*16))).FpBt) != 0 { **(**TyDbMask)(__ccgo_up(p + 160)) |= libc.Uint32FromInt32(1) << i } } // C documentation // // /* // ** Invoke either the xSavepoint, xRollbackTo or xRelease method of all // ** virtual tables that currently have an open transaction. Pass iSavepoint // ** as the second argument to the virtual table method invoked. // ** // ** If op is SAVEPOINT_BEGIN, the xSavepoint method is invoked. If it is // ** SAVEPOINT_ROLLBACK, the xRollbackTo method. Otherwise, if op is // ** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with // ** an open transaction is invoked. // ** // ** If any virtual table method returns an error code other than SQLITE_OK, // ** processing is abandoned and the error returned to the caller of this // ** function immediately. If all calls to virtual table methods are successful, // ** SQLITE_OK is returned. // */ func _sqlite3VtabSavepoint(tls *libc.TLS, db uintptr, op int32, iSavepoint int32) (r int32) { var i, rc int32 var pMod, pVTab, xMethod uintptr var savedFlags Tu64 _, _, _, _, _, _ = i, pMod, pVTab, rc, savedFlags, xMethod rc = SQLITE_OK if (*Tsqlite3)(unsafe.Pointer(db)).FaVTrans != 0 { i = 0 for { if !(rc == SQLITE_OK && i < (*Tsqlite3)(unsafe.Pointer(db)).FnVTrans) { break } pVTab = **(**uintptr)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaVTrans + uintptr(i)*4)) pMod = (*TModule)(unsafe.Pointer((*TVTable)(unsafe.Pointer(pVTab)).FpMod)).FpModule if (*TVTable)(unsafe.Pointer(pVTab)).FpVtab != 0 && (*Tsqlite3_module)(unsafe.Pointer(pMod)).FiVersion >= int32(2) { _sqlite3VtabLock(tls, pVTab) switch op { case SAVEPOINT_BEGIN: xMethod = (*Tsqlite3_module)(unsafe.Pointer(pMod)).FxSavepoint (*TVTable)(unsafe.Pointer(pVTab)).FiSavepoint = iSavepoint + int32(1) case int32(SAVEPOINT_ROLLBACK): xMethod = (*Tsqlite3_module)(unsafe.Pointer(pMod)).FxRollbackTo default: xMethod = (*Tsqlite3_module)(unsafe.Pointer(pMod)).FxRelease break } if xMethod != 0 && (*TVTable)(unsafe.Pointer(pVTab)).FiSavepoint > iSavepoint { savedFlags = (*Tsqlite3)(unsafe.Pointer(db)).Fflags & libc.Uint64FromInt32(SQLITE_Defensive) **(**Tu64)(__ccgo_up(db + 32)) &= ^libc.Uint64FromInt32(SQLITE_Defensive) rc = (*(*func(*libc.TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{xMethod})))(tls, (*TVTable)(unsafe.Pointer(pVTab)).FpVtab, iSavepoint) **(**Tu64)(__ccgo_up(db + 32)) |= savedFlags } _sqlite3VtabUnlock(tls, pVTab) } goto _1 _1: ; i = i + 1 } } return rc } func _sqlite3WhereRealloc(tls *libc.TLS, pWInfo uintptr, pOld uintptr, nByte Tu64) (r uintptr) { var pNew, pOldBlk uintptr _, _ = pNew, pOldBlk pNew = _sqlite3WhereMalloc(tls, pWInfo, nByte) if pNew != 0 && pOld != 0 { pOldBlk = pOld pOldBlk -= 16 libc.Xmemcpy(tls, pNew, pOld, uint32((*TWhereMemBlock)(unsafe.Pointer(pOldBlk)).Fsz)) } return pNew } // C documentation // // /* // ** Reclaim all memory of a StatAccum structure. // */ func _statAccumDestructor(tls *libc.TLS, pOld uintptr) { var i int32 var p uintptr _, _ = i, p p = pOld if (*TStatAccum)(unsafe.Pointer(p)).FmxSample != 0 { i = 0 for { if !(i < (*TStatAccum)(unsafe.Pointer(p)).FnCol) { break } _sampleClear(tls, (*TStatAccum)(unsafe.Pointer(p)).Fdb, (*TStatAccum)(unsafe.Pointer(p)).FaBest+uintptr(i)*40) goto _1 _1: ; i = i + 1 } i = 0 for { if !(i < (*TStatAccum)(unsafe.Pointer(p)).FmxSample) { break } _sampleClear(tls, (*TStatAccum)(unsafe.Pointer(p)).Fdb, (*TStatAccum)(unsafe.Pointer(p)).Fa+uintptr(i)*40) goto _2 _2: ; i = i + 1 } _sampleClear(tls, (*TStatAccum)(unsafe.Pointer(p)).Fdb, p+40) } _sqlite3DbFree(tls, (*TStatAccum)(unsafe.Pointer(p)).Fdb, p) } // C documentation // // /* // ** Free all resources associated with the IncrMerger object indicated by // ** the first argument. // */ func _vdbeIncrFree(tls *libc.TLS, pIncr uintptr) { if pIncr != 0 { if (*TIncrMerger)(unsafe.Pointer(pIncr)).FbUseThread != 0 { _vdbeSorterJoinThread(tls, (*TIncrMerger)(unsafe.Pointer(pIncr)).FpTask) if (**(**TSorterFile)(__ccgo_up(pIncr + 32))).FpFd != 0 { _sqlite3OsCloseFree(tls, (**(**TSorterFile)(__ccgo_up(pIncr + 32))).FpFd) } if (**(**TSorterFile)(__ccgo_up(pIncr + 32 + 1*16))).FpFd != 0 { _sqlite3OsCloseFree(tls, (**(**TSorterFile)(__ccgo_up(pIncr + 32 + 1*16))).FpFd) } } _vdbeMergeEngineFree(tls, (*TIncrMerger)(unsafe.Pointer(pIncr)).FpMerger) Xsqlite3_free(tls, pIncr) } } // C documentation // // /* // ** Allocate and return a new IncrMerger object to read data from pMerger. // ** // ** If an OOM condition is encountered, return NULL. In this case free the // ** pMerger argument before returning. // */ func _vdbeIncrMergerNew(tls *libc.TLS, pTask uintptr, pMerger uintptr, ppOut uintptr) (r int32) { var pIncr, v1, v2 uintptr var rc, v3 int32 _, _, _, _, _ = pIncr, rc, v1, v2, v3 rc = SQLITE_OK if _sqlite3FaultSim(tls, int32(100)) != 0 { v2 = uintptr(0) } else { v2 = _sqlite3MallocZero(tls, uint64(64)) } v1 = v2 **(**uintptr)(__ccgo_up(ppOut)) = v1 pIncr = v1 if pIncr != 0 { (*TIncrMerger)(unsafe.Pointer(pIncr)).FpMerger = pMerger (*TIncrMerger)(unsafe.Pointer(pIncr)).FpTask = pTask if (*TVdbeSorter)(unsafe.Pointer((*TSortSubtask)(unsafe.Pointer(pTask)).FpSorter)).FmxKeysize+int32(9) > (*TVdbeSorter)(unsafe.Pointer((*TSortSubtask)(unsafe.Pointer(pTask)).FpSorter)).FmxPmaSize/int32(2) { v3 = (*TVdbeSorter)(unsafe.Pointer((*TSortSubtask)(unsafe.Pointer(pTask)).FpSorter)).FmxKeysize + int32(9) } else { v3 = (*TVdbeSorter)(unsafe.Pointer((*TSortSubtask)(unsafe.Pointer(pTask)).FpSorter)).FmxPmaSize / int32(2) } (*TIncrMerger)(unsafe.Pointer(pIncr)).FmxSz = v3 (*TSortSubtask)(unsafe.Pointer(pTask)).Ffile2.FiEof += int64((*TIncrMerger)(unsafe.Pointer(pIncr)).FmxSz) } else { _vdbeMergeEngineFree(tls, pMerger) rc = int32(SQLITE_NOMEM) } return rc } // C documentation // // /* // ** This function is called when the PmaReader corresponding to pIncr has // ** finished reading the contents of aFile[0]. Its purpose is to "refill" // ** aFile[0] such that the PmaReader should start rereading it from the // ** beginning. // ** // ** For single-threaded objects, this is accomplished by literally reading // ** keys from pIncr->pMerger and repopulating aFile[0]. // ** // ** For multi-threaded objects, all that is required is to wait until the // ** background thread is finished (if it is not already) and then swap // ** aFile[0] and aFile[1] in place. If the contents of pMerger have not // ** been exhausted, this function also launches a new background thread // ** to populate the new aFile[1]. // ** // ** SQLITE_OK is returned on success, or an SQLite error code otherwise. // */ func _vdbeIncrSwap(tls *libc.TLS, pIncr uintptr) (r int32) { var f0 TSorterFile var rc int32 _, _ = f0, rc rc = SQLITE_OK if (*TIncrMerger)(unsafe.Pointer(pIncr)).FbUseThread != 0 { rc = _vdbeSorterJoinThread(tls, (*TIncrMerger)(unsafe.Pointer(pIncr)).FpTask) if rc == SQLITE_OK { f0 = **(**TSorterFile)(__ccgo_up(pIncr + 32)) **(**TSorterFile)(__ccgo_up(pIncr + 32)) = **(**TSorterFile)(__ccgo_up(pIncr + 32 + 1*16)) **(**TSorterFile)(__ccgo_up(pIncr + 32 + 1*16)) = f0 } if rc == SQLITE_OK { if (**(**TSorterFile)(__ccgo_up(pIncr + 32))).FiEof == (*TIncrMerger)(unsafe.Pointer(pIncr)).FiStartOff { (*TIncrMerger)(unsafe.Pointer(pIncr)).FbEof = int32(1) } else { rc = _vdbeIncrBgPopulate(tls, pIncr) } } } else { rc = _vdbeIncrPopulate(tls, pIncr) **(**TSorterFile)(__ccgo_up(pIncr + 32)) = **(**TSorterFile)(__ccgo_up(pIncr + 32 + 1*16)) if (**(**TSorterFile)(__ccgo_up(pIncr + 32))).FiEof == (*TIncrMerger)(unsafe.Pointer(pIncr)).FiStartOff { (*TIncrMerger)(unsafe.Pointer(pIncr)).FbEof = int32(1) } } return rc } // C documentation // // /* // ** Recompute pMerger->aTree[iOut] by comparing the next keys on the // ** two PmaReaders that feed that entry. Neither of the PmaReaders // ** are advanced. This routine merely does the comparison. // */ func _vdbeMergeEngineCompare(tls *libc.TLS, pMerger uintptr, iOut int32) { bp := tls.Alloc(16) defer tls.Free(16) var i1, i2, iRes, res int32 var p1, p2, pTask uintptr var _ /* bCached at bp+0 */ int32 _, _, _, _, _, _, _ = i1, i2, iRes, p1, p2, pTask, res if iOut >= (*TMergeEngine)(unsafe.Pointer(pMerger)).FnTree/int32(2) { i1 = (iOut - (*TMergeEngine)(unsafe.Pointer(pMerger)).FnTree/int32(2)) * int32(2) i2 = i1 + int32(1) } else { i1 = **(**int32)(__ccgo_up((*TMergeEngine)(unsafe.Pointer(pMerger)).FaTree + uintptr(iOut*int32(2))*4)) i2 = **(**int32)(__ccgo_up((*TMergeEngine)(unsafe.Pointer(pMerger)).FaTree + uintptr(iOut*int32(2)+int32(1))*4)) } p1 = (*TMergeEngine)(unsafe.Pointer(pMerger)).FaReadr + uintptr(i1)*56 p2 = (*TMergeEngine)(unsafe.Pointer(pMerger)).FaReadr + uintptr(i2)*56 if (*TPmaReader)(unsafe.Pointer(p1)).FpFd == uintptr(0) { iRes = i2 } else { if (*TPmaReader)(unsafe.Pointer(p2)).FpFd == uintptr(0) { iRes = i1 } else { pTask = (*TMergeEngine)(unsafe.Pointer(pMerger)).FpTask **(**int32)(__ccgo_up(bp)) = 0 /* from vdbeSortSubtaskMain() */ res = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*TSortSubtask)(unsafe.Pointer(pTask)).FxCompare})))(tls, pTask, bp, (*TPmaReader)(unsafe.Pointer(p1)).FaKey, (*TPmaReader)(unsafe.Pointer(p1)).FnKey, (*TPmaReader)(unsafe.Pointer(p2)).FaKey, (*TPmaReader)(unsafe.Pointer(p2)).FnKey) if res <= 0 { iRes = i1 } else { iRes = i2 } } } **(**int32)(__ccgo_up((*TMergeEngine)(unsafe.Pointer(pMerger)).FaTree + uintptr(iOut)*4)) = iRes } // C documentation // // /* // ** Free the MergeEngine object passed as the only argument. // */ func _vdbeMergeEngineFree(tls *libc.TLS, pMerger uintptr) { var i int32 _ = i if pMerger != 0 { i = 0 for { if !(i < (*TMergeEngine)(unsafe.Pointer(pMerger)).FnTree) { break } _vdbePmaReaderClear(tls, (*TMergeEngine)(unsafe.Pointer(pMerger)).FaReadr+uintptr(i)*56) goto _1 _1: ; i = i + 1 } } Xsqlite3_free(tls, pMerger) } // C documentation // // /* // ** Allocate a new MergeEngine object to merge the contents of nPMA level-0 // ** PMAs from pTask->file. If no error occurs, set *ppOut to point to // ** the new object and return SQLITE_OK. Or, if an error does occur, set *ppOut // ** to NULL and return an SQLite error code. // ** // ** When this function is called, *piOffset is set to the offset of the // ** first PMA to read from pTask->file. Assuming no error occurs, it is // ** set to the offset immediately following the last byte of the last // ** PMA before returning. If an error does occur, then the final value of // ** *piOffset is undefined. // */ func _vdbeMergeEngineLevel0(tls *libc.TLS, pTask uintptr, nPMA int32, piOffset uintptr, ppOut uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var i, rc int32 var iOff Ti64 var pNew, pReadr, v1 uintptr var _ /* nDummy at bp+0 */ Ti64 _, _, _, _, _, _ = i, iOff, pNew, pReadr, rc, v1 /* Merge engine to return */ iOff = **(**Ti64)(__ccgo_up(piOffset)) rc = SQLITE_OK v1 = _vdbeMergeEngineNew(tls, nPMA) pNew = v1 **(**uintptr)(__ccgo_up(ppOut)) = v1 if pNew == uintptr(0) { rc = int32(SQLITE_NOMEM) } i = 0 for { if !(i < nPMA && rc == SQLITE_OK) { break } **(**Ti64)(__ccgo_up(bp)) = 0 pReadr = (*TMergeEngine)(unsafe.Pointer(pNew)).FaReadr + uintptr(i)*56 rc = _vdbePmaReaderInit(tls, pTask, pTask+48, iOff, pReadr, bp) iOff = (*TPmaReader)(unsafe.Pointer(pReadr)).FiEof goto _2 _2: ; i = i + 1 } if rc != SQLITE_OK { _vdbeMergeEngineFree(tls, pNew) **(**uintptr)(__ccgo_up(ppOut)) = uintptr(0) } **(**Ti64)(__ccgo_up(piOffset)) = iOff return rc } // C documentation // // /* // ** Free all memory belonging to the PmaReader object passed as the // ** argument. All structure fields are set to zero before returning. // */ func _vdbePmaReaderClear(tls *libc.TLS, pReadr uintptr) { Xsqlite3_free(tls, (*TPmaReader)(unsafe.Pointer(pReadr)).FaAlloc) Xsqlite3_free(tls, (*TPmaReader)(unsafe.Pointer(pReadr)).FaBuffer) if (*TPmaReader)(unsafe.Pointer(pReadr)).FaMap != 0 { _sqlite3OsUnfetch(tls, (*TPmaReader)(unsafe.Pointer(pReadr)).FpFd, 0, (*TPmaReader)(unsafe.Pointer(pReadr)).FaMap) } _vdbeIncrFree(tls, (*TPmaReader)(unsafe.Pointer(pReadr)).FpIncr) libc.Xmemset(tls, pReadr, 0, uint32(56)) } // C documentation // // /* // ** The PmaReader passed as the first argument is guaranteed to be an // ** incremental-reader (pReadr->pIncr!=0). This function serves to open // ** and/or initialize the temp file related fields of the IncrMerge // ** object at (pReadr->pIncr). // ** // ** If argument eMode is set to INCRINIT_NORMAL, then all PmaReaders // ** in the sub-tree headed by pReadr are also initialized. Data is then // ** loaded into the buffers belonging to pReadr and it is set to point to // ** the first key in its range. // ** // ** If argument eMode is set to INCRINIT_TASK, then pReadr is guaranteed // ** to be a multi-threaded PmaReader and this function is being called in a // ** background thread. In this case all PmaReaders in the sub-tree are // ** initialized as for INCRINIT_NORMAL and the aFile[1] buffer belonging to // ** pReadr is populated. However, pReadr itself is not set up to point // ** to its first key. A call to vdbePmaReaderNext() is still required to do // ** that. // ** // ** The reason this function does not call vdbePmaReaderNext() immediately // ** in the INCRINIT_TASK case is that vdbePmaReaderNext() assumes that it has // ** to block on thread (pTask->thread) before accessing aFile[1]. But, since // ** this entire function is being run by thread (pTask->thread), that will // ** lead to the current background thread attempting to join itself. // ** // ** Finally, if argument eMode is set to INCRINIT_ROOT, it may be assumed // ** that pReadr->pIncr is a multi-threaded IncrMerge objects, and that all // ** child-trees have already been initialized using IncrInit(INCRINIT_TASK). // ** In this case vdbePmaReaderNext() is called on all child PmaReaders and // ** the current PmaReader set to point to the first key in its range. // ** // ** SQLITE_OK is returned if successful, or an SQLite error code otherwise. // */ func _vdbePmaReaderIncrMergeInit(tls *libc.TLS, pReadr uintptr, eMode int32) (r int32) { var db, pIncr, pTask uintptr var mxSz, rc int32 _, _, _, _, _ = db, mxSz, pIncr, pTask, rc rc = SQLITE_OK pIncr = (*TPmaReader)(unsafe.Pointer(pReadr)).FpIncr pTask = (*TIncrMerger)(unsafe.Pointer(pIncr)).FpTask db = (*TVdbeSorter)(unsafe.Pointer((*TSortSubtask)(unsafe.Pointer(pTask)).FpSorter)).Fdb /* eMode is always INCRINIT_NORMAL in single-threaded mode */ rc = _vdbeMergeEngineInit(tls, pTask, (*TIncrMerger)(unsafe.Pointer(pIncr)).FpMerger, eMode) /* Set up the required files for pIncr. A multi-threaded IncrMerge object ** requires two temp files to itself, whereas a single-threaded object ** only requires a region of pTask->file2. */ if rc == SQLITE_OK { mxSz = (*TIncrMerger)(unsafe.Pointer(pIncr)).FmxSz if (*TIncrMerger)(unsafe.Pointer(pIncr)).FbUseThread != 0 { rc = _vdbeSorterOpenTempFile(tls, db, int64(mxSz), pIncr+32) if rc == SQLITE_OK { rc = _vdbeSorterOpenTempFile(tls, db, int64(mxSz), pIncr+32+1*16) } } else { /*if( !pIncr->bUseThread )*/ if (*TSortSubtask)(unsafe.Pointer(pTask)).Ffile2.FpFd == uintptr(0) { rc = _vdbeSorterOpenTempFile(tls, db, (*TSortSubtask)(unsafe.Pointer(pTask)).Ffile2.FiEof, pTask+64) (*TSortSubtask)(unsafe.Pointer(pTask)).Ffile2.FiEof = 0 } if rc == SQLITE_OK { (**(**TSorterFile)(__ccgo_up(pIncr + 32 + 1*16))).FpFd = (*TSortSubtask)(unsafe.Pointer(pTask)).Ffile2.FpFd (*TIncrMerger)(unsafe.Pointer(pIncr)).FiStartOff = (*TSortSubtask)(unsafe.Pointer(pTask)).Ffile2.FiEof (*TSortSubtask)(unsafe.Pointer(pTask)).Ffile2.FiEof += int64(mxSz) } } } if rc == SQLITE_OK && (*TIncrMerger)(unsafe.Pointer(pIncr)).FbUseThread != 0 { /* Use the current thread to populate aFile[1], even though this ** PmaReader is multi-threaded. If this is an INCRINIT_TASK object, ** then this function is already running in background thread ** pIncr->pTask->thread. ** ** If this is the INCRINIT_ROOT object, then it is running in the ** main VDBE thread. But that is Ok, as that thread cannot return ** control to the VDBE or proceed with anything useful until the ** first results are ready from this merger object anyway. */ rc = _vdbeIncrPopulate(tls, pIncr) } if rc == SQLITE_OK && (libc.Bool(false) || eMode != int32(INCRINIT_TASK)) { rc = _vdbePmaReaderNext(tls, pReadr) } return rc } // C documentation // // /* // ** Free all resources owned by the object indicated by argument pTask. All // ** fields of *pTask are zeroed before returning. // */ func _vdbeSortSubtaskCleanup(tls *libc.TLS, db uintptr, pTask uintptr) { _sqlite3DbFree(tls, db, (*TSortSubtask)(unsafe.Pointer(pTask)).FpUnpacked) /* pTask->list.aMemory can only be non-zero if it was handed memory ** from the main thread. That only occurs SQLITE_MAX_WORKER_THREADS>0 */ if (*TSortSubtask)(unsafe.Pointer(pTask)).Flist.FaMemory != 0 { Xsqlite3_free(tls, (*TSortSubtask)(unsafe.Pointer(pTask)).Flist.FaMemory) } else { _vdbeSorterRecordFree(tls, uintptr(0), (*TSortSubtask)(unsafe.Pointer(pTask)).Flist.FpList) } if (*TSortSubtask)(unsafe.Pointer(pTask)).Ffile.FpFd != 0 { _sqlite3OsCloseFree(tls, (*TSortSubtask)(unsafe.Pointer(pTask)).Ffile.FpFd) } if (*TSortSubtask)(unsafe.Pointer(pTask)).Ffile2.FpFd != 0 { _sqlite3OsCloseFree(tls, (*TSortSubtask)(unsafe.Pointer(pTask)).Ffile2.FpFd) } libc.Xmemset(tls, pTask, 0, uint32(88)) } // C documentation // // /* // ** pRoot is the root of an incremental merge-tree with depth nDepth (according // ** to vdbeSorterTreeDepth()). pLeaf is the iSeq'th leaf to be added to the // ** tree, counting from zero. This function adds pLeaf to the tree. // ** // ** If successful, SQLITE_OK is returned. If an error occurs, an SQLite error // ** code is returned and pLeaf is freed. // */ func _vdbeSorterAddToTree(tls *libc.TLS, pTask uintptr, nDepth int32, iSeq int32, pRoot uintptr, pLeaf uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var i, iIter, nDiv, rc int32 var p, pNew, pReadr uintptr var _ /* pIncr at bp+0 */ uintptr _, _, _, _, _, _, _ = i, iIter, nDiv, p, pNew, pReadr, rc rc = SQLITE_OK nDiv = int32(1) p = pRoot rc = _vdbeIncrMergerNew(tls, pTask, pLeaf, bp) i = int32(1) for { if !(i < nDepth) { break } nDiv = nDiv * int32(SORTER_MAX_MERGE_COUNT) goto _1 _1: ; i = i + 1 } i = int32(1) for { if !(i < nDepth && rc == SQLITE_OK) { break } iIter = iSeq / nDiv % int32(SORTER_MAX_MERGE_COUNT) pReadr = (*TMergeEngine)(unsafe.Pointer(p)).FaReadr + uintptr(iIter)*56 if (*TPmaReader)(unsafe.Pointer(pReadr)).FpIncr == uintptr(0) { pNew = _vdbeMergeEngineNew(tls, int32(SORTER_MAX_MERGE_COUNT)) if pNew == uintptr(0) { rc = int32(SQLITE_NOMEM) } else { rc = _vdbeIncrMergerNew(tls, pTask, pNew, pReadr+48) } } if rc == SQLITE_OK { p = (*TIncrMerger)(unsafe.Pointer((*TPmaReader)(unsafe.Pointer(pReadr)).FpIncr)).FpMerger nDiv = nDiv / int32(SORTER_MAX_MERGE_COUNT) } goto _2 _2: ; i = i + 1 } if rc == SQLITE_OK { (**(**TPmaReader)(__ccgo_up((*TMergeEngine)(unsafe.Pointer(p)).FaReadr + uintptr(iSeq%int32(SORTER_MAX_MERGE_COUNT))*56))).FpIncr = **(**uintptr)(__ccgo_up(bp)) } else { _vdbeIncrFree(tls, **(**uintptr)(__ccgo_up(bp))) } return rc } // C documentation // // /* // ** The main routine for background threads that write level-0 PMAs. // */ func _vdbeSorterFlushThread(tls *libc.TLS, pCtx uintptr) (r uintptr) { var pTask uintptr var rc int32 _, _ = pTask, rc pTask = pCtx /* Return code */ rc = _vdbeSorterListToPMA(tls, pTask, pTask+24) (*TSortSubtask)(unsafe.Pointer(pTask)).FbDone = int32(1) return uintptr(rc) } // C documentation // // /* // ** Return a pointer to a buffer owned by the sorter that contains the // ** current key. // */ func _vdbeSorterRowkey(tls *libc.TLS, pSorter uintptr, pnKey uintptr) (r uintptr) { var pKey, pReader uintptr _, _ = pKey, pReader if (*TVdbeSorter)(unsafe.Pointer(pSorter)).FbUsePMA != 0 { if (*TVdbeSorter)(unsafe.Pointer(pSorter)).FbUseThreads != 0 { pReader = (*TVdbeSorter)(unsafe.Pointer(pSorter)).FpReader } else { /*if( !pSorter->bUseThreads )*/ pReader = (*TMergeEngine)(unsafe.Pointer((*TVdbeSorter)(unsafe.Pointer(pSorter)).FpMerger)).FaReadr + uintptr(**(**int32)(__ccgo_up((*TMergeEngine)(unsafe.Pointer((*TVdbeSorter)(unsafe.Pointer(pSorter)).FpMerger)).FaTree + 1*4)))*56 } **(**int32)(__ccgo_up(pnKey)) = (*TPmaReader)(unsafe.Pointer(pReader)).FnKey pKey = (*TPmaReader)(unsafe.Pointer(pReader)).FaKey } else { **(**int32)(__ccgo_up(pnKey)) = (*TSorterRecord)(unsafe.Pointer((*TVdbeSorter)(unsafe.Pointer(pSorter)).Flist.FpList)).FnVal pKey = (*TVdbeSorter)(unsafe.Pointer(pSorter)).Flist.FpList + libc.UintptrFromInt32(1)*8 } return pKey } // C documentation // // /* // ** Free a WhereInfo structure // */ func _whereInfoFree(tls *libc.TLS, db uintptr, pWInfo uintptr) { var p, pNext uintptr _, _ = p, pNext _sqlite3WhereClauseClear(tls, pWInfo+80) for (*TWhereInfo)(unsafe.Pointer(pWInfo)).FpLoops != 0 { p = (*TWhereInfo)(unsafe.Pointer(pWInfo)).FpLoops (*TWhereInfo)(unsafe.Pointer(pWInfo)).FpLoops = (*TWhereLoop)(unsafe.Pointer(p)).FpNextLoop _whereLoopDelete(tls, db, p) } for (*TWhereInfo)(unsafe.Pointer(pWInfo)).FpMemToFree != 0 { pNext = (*TWhereMemBlock)(unsafe.Pointer((*TWhereInfo)(unsafe.Pointer(pWInfo)).FpMemToFree)).FpNext _sqlite3DbNNFreeNN(tls, db, (*TWhereInfo)(unsafe.Pointer(pWInfo)).FpMemToFree) (*TWhereInfo)(unsafe.Pointer(pWInfo)).FpMemToFree = pNext } _sqlite3DbNNFreeNN(tls, db, pWInfo) } // C documentation // // /* // ** Move the content of pSrc into pDest // */ func _whereOrMove(tls *libc.TLS, pDest uintptr, pSrc uintptr) { (*TWhereOrSet)(unsafe.Pointer(pDest)).Fn = (*TWhereOrSet)(unsafe.Pointer(pSrc)).Fn libc.Xmemcpy(tls, pDest+8, pSrc+8, uint32((*TWhereOrSet)(unsafe.Pointer(pDest)).Fn)*uint32(16)) }