Lines Matching defs:void
327 ** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)).
333 # define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))
336 # define SQLITE_INT_TO_PTR(X) ((void*)(X))
340 # define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X])
452 SQLITE_PRIVATE void sqlite3Coverage(int);
669 SQLITE_API const char *sqlite3_libversion(void);
670 SQLITE_API const char *sqlite3_sourceid(void);
671 SQLITE_API int sqlite3_libversion_number(void);
709 SQLITE_API int sqlite3_threadsafe(void);
794 typedef int (*sqlite3_callback)(void*,int,char**, char**);
860 int (*callback)(void*,int,char**,char**), /* Callback function */
861 void *, /* 1st argument to callback */
1146 int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
1147 int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
1154 int (*xFileControl)(sqlite3_file*, int op, void *pArg);
1328 void *pAppData; /* Pointer to application-specific data */
1334 void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
1335 void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
1336 void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);
1337 void (*xDlClose)(sqlite3_vfs*, void*);
1438 SQLITE_API int sqlite3_initialize(void);
1439 SQLITE_API int sqlite3_shutdown(void);
1440 SQLITE_API int sqlite3_os_init(void);
1441 SQLITE_API int sqlite3_os_end(void);
1571 void *(*xMalloc)(int); /* Memory allocation function */
1572 void (*xFree)(void*); /* Free a prior allocation */
1573 void *(*xRealloc)(void*,int); /* Resize an allocation */
1574 int (*xSize)(void*); /* Return the size of an allocation */
1576 int (*xInit)(void*); /* Initialize the memory allocator */
1577 void (*xShutdown)(void*); /* Deinitialize the memory allocator */
1578 void *pAppData; /* Argument to xInit() and xShutdown() */
1776 #define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */
1777 #define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */
1778 #define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */
1820 #define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */
1994 SQLITE_API void sqlite3_interrupt(sqlite3*);
2030 SQLITE_API int sqlite3_complete16(const void *sql);
2043 ** ^The first argument to the busy handler is a copy of the void* pointer which
2096 SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
2195 SQLITE_API void sqlite3_free_table(char **result);
2361 SQLITE_API void *sqlite3_malloc(int);
2362 SQLITE_API void *sqlite3_realloc(void*, int);
2363 SQLITE_API void sqlite3_free(void*);
2388 SQLITE_API sqlite3_int64 sqlite3_memory_used(void);
2409 SQLITE_API void sqlite3_randomness(int N, void *P);
2493 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
2494 void *pUserData
2583 SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
2584 SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
2585 void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
2606 SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
2702 const void *filename, /* Database filename (UTF-16) */
2748 SQLITE_API const void *sqlite3_errmsg16(sqlite3*);
2969 const void *zSql, /* SQL statement, UTF-16 encoded */
2972 const void **pzTail /* OUT: Pointer to unused portion of zSql */
2976 const void *zSql, /* SQL statement, UTF-16 encoded */
2979 const void **pzTail /* OUT: Pointer to unused portion of zSql */
3123 SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
3128 SQLITE_API int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
3129 SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
3239 SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);
3285 SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
3287 SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
3289 SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
3321 SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
3584 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
3591 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
3724 void *pApp,
3725 void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
3726 void (*xStep)(sqlite3_context*,int,sqlite3_value**),
3727 void (*xFinal)(sqlite3_context*)
3731 const void *zFunctionName,
3734 void *pApp,
3735 void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
3736 void (*xStep)(sqlite3_context*,int,sqlite3_value**),
3737 void (*xFinal)(sqlite3_context*)
3767 SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void);
3768 SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void);
3769 SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64);
3817 SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
3824 SQLITE_API const void *sqlite3_value_text16(sqlite3_value*);
3825 SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*);
3826 SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*);
3869 SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
3883 SQLITE_API void *sqlite3_user_data(sqlite3_context*);
3938 SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
3939 SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
3956 typedef void (*sqlite3_destructor_type)(void*);
4065 SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
4066 SQLITE_API void sqlite3_result_double(sqlite3_context*, double);
4067 SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int);
4068 SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int);
4069 SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*);
4070 SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*);
4071 SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int);
4072 SQLITE_API void sqlite3_result_int(sqlite3_context*, int);
4073 SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
4074 SQLITE_API void sqlite3_result_null(sqlite3_context*);
4075 SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
4076 SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
4077 SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
4078 SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
4079 SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
4080 SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);
4107 ** as its first parameter a copy of the void* passed as the fourth argument
4120 ** destroyed and is passed a copy of the fourth parameter void* pointer
4132 void*,
4133 int(*xCompare)(void*,int,const void*,int,const void*)
4139 void*,
4140 int(*xCompare)(void*,int,const void*,int,const void*),
4141 void(*xDestroy)(void*)
4145 const void *zName,
4147 void*,
4148 int(*xCompare)(void*,int,const void*,int,const void*)
4179 void*,
4180 void(*)(void*,sqlite3*,int eTextRep,const char*)
4184 void*,
4185 void(*)(void*,sqlite3*,int eTextRep,const void*)
4197 const void *pKey, int nKey /* The key */
4210 const void *pKey, int nKey /* The new key */
4356 SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
4357 SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
4405 SQLITE_API void *sqlite3_update_hook(
4407 void(*)(void *,int ,char const *,char const *,sqlite3_int64),
4408 void*
4482 SQLITE_API void sqlite3_soft_heap_limit(int);
4624 SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));
4635 SQLITE_API void sqlite3_reset_auto_extension(void);
4675 int (*xCreate)(sqlite3*, void *pAux,
4678 int (*xConnect)(sqlite3*, void *pAux,
4698 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
4699 void **ppArg);
4814 void *pClientData /* Client data for xCreate/xConnect */
4820 void *pClientData, /* Client data for xCreate/xConnect */
4821 void(*xDestroy)(void*) /* Module destructor function */
5060 SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
5098 SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
5248 SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*);
5249 SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*);
5251 SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
5321 int (*xMutexInit)(void);
5322 int (*xMutexEnd)(void);
5324 void (*xMutexFree)(sqlite3_mutex *);
5325 void (*xMutexEnter)(sqlite3_mutex *);
5327 void (*xMutexLeave)(sqlite3_mutex *);
5423 SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
5827 void *pArg;
5828 int (*xInit)(void*);
5829 void (*xShutdown)(void*);
5831 void (*xCachesize)(sqlite3_pcache*, int nCachesize);
5833 void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
5834 void (*xUnpin)(sqlite3_pcache*, void*, int discard);
5835 void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey);
5836 void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
5837 void (*xDestroy)(sqlite3_pcache*);
6100 ** single void* pointer that is passed to the callback when it is invoked.
6102 ** it an array of void* context pointers. The first argument passed to
6103 ** an unlock-notify callback is a pointer to an array of void* pointers,
6110 ** multiple times, it is invoked once with the set of void* context pointers
6158 void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */
6159 void *pNotifyArg /* Argument to pass to xNotify */
6252 void *data; /* Data associated with this element */
6259 SQLITE_PRIVATE void sqlite3HashInit(Hash*);
6260 SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData);
6261 SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey, int nKey);
6262 SQLITE_PRIVATE void sqlite3HashClear(Hash*);
6671 int (*xFunc)(void *,int); /* The busy callback */
6672 void *pArg; /* First arg to busy callback */
6722 #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
6725 SQLITE_API void *sqlite3_wsd_find(void *K, int L);
6748 #define UNUSED_PARAMETER(x) (void)(x)
6899 SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *, int, void(*)(void *));
6919 SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree*, int);
6921 SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue);
6952 SQLITE_PRIVATE int sqlite3BtreeCursorSize(void);
6953 SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor*);
6965 SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey,
6966 const void *pData, int nData,
6974 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*);
6975 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt);
6976 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt);
6978 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*);
6979 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor*, sqlite3_int64);
6985 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*);
6986 SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *);
6987 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *);
6999 SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*);
7008 SQLITE_PRIVATE void sqlite3BtreeEnter(Btree*);
7009 SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*);
7016 SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*);
7017 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor*);
7018 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor*);
7019 SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3*);
7020 SQLITE_PRIVATE void sqlite3BtreeMutexArrayEnter(BtreeMutexArray*);
7021 SQLITE_PRIVATE void sqlite3BtreeMutexArrayLeave(BtreeMutexArray*);
7022 SQLITE_PRIVATE void sqlite3BtreeMutexArrayInsert(BtreeMutexArray*, Btree*);
7099 void *p; /* Generic pointer */
7132 void *token; /* id that may be used to recursive triggers */
7408 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1);
7409 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2);
7410 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3);
7411 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5);
7412 SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr);
7413 SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe*, int addr, int N);
7414 SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N);
7415 SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int);
7418 SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*);
7419 SQLITE_PRIVATE void sqlite3VdbeMakeReady(Vdbe*,int,int,int,int,int,int);
7421 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int);
7425 SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe*,FILE*);
7427 SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*);
7429 SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int);
7430 SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*));
7431 SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*);
7433 SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, int);
7434 SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*);
7436 SQLITE_PRIVATE void sqlite3VdbeProgramDelete(sqlite3 *, SubProgram *, int);
7438 SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int);
7443 SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,char*,int);
7444 SQLITE_PRIVATE void sqlite3VdbeDeleteUnpackedRecord(UnpackedRecord*);
7445 SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*);
7449 SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe*, const char*, ...);
7451 SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe*, const char*, ...);
7557 void(*)(DbPage*)
7563 SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(Pager*, int(*)(void *), void *);
7566 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int);
7567 SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager*,int,int);
7577 SQLITE_PRIVATE void sqlite3PagerRef(DbPage*);
7578 SQLITE_PRIVATE void sqlite3PagerUnref(DbPage*);
7582 SQLITE_PRIVATE void sqlite3PagerDontWrite(DbPage*);
7585 SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *);
7586 SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *);
7607 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*);
7611 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno);
7620 SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*);
7621 void disable_simulated_io_errors(void);
7622 void enable_simulated_io_errors(void);
7659 void *pData; /* Content of this page */
7660 void *pExtra; /* Extra content */
7689 SQLITE_PRIVATE int sqlite3PcacheInitialize(void);
7690 SQLITE_PRIVATE void sqlite3PcacheShutdown(void);
7695 SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *, int sz, int n);
7701 SQLITE_PRIVATE void sqlite3PcacheOpen(
7705 int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */
7706 void *pStress, /* Argument to xStress */
7711 SQLITE_PRIVATE void sqlite3PcacheSetPageSize(PCache *, int);
7716 SQLITE_PRIVATE int sqlite3PcacheSize(void);
7722 SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr*);
7724 SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr*); /* Remove page from cache */
7725 SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr*); /* Make sure page is marked dirty */
7726 SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*); /* Mark a single page as clean */
7727 SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */
7730 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno);
7733 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x);
7739 SQLITE_PRIVATE void sqlite3PcacheClose(PCache*);
7742 SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *);
7745 SQLITE_PRIVATE void sqlite3PcacheClear(PCache*);
7751 SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr*);
7763 SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *));
7772 SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *, int);
7783 SQLITE_PRIVATE void sqlite3PcacheStats(int*,int*,int*,int*);
7786 SQLITE_PRIVATE void sqlite3PCacheSetDefault(void);
8022 SQLITE_PRIVATE int sqlite3OsInit(void);
8028 SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset);
8029 SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset);
8036 SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file*,int,void*);
8049 SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *, const char *);
8050 SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *, int, char *);
8051 SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *, void *, const char *))(void);
8052 SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *, void *);
8245 void *pStart; /* First byte of available memory space */
8246 void *pEnd; /* First byte past end of available space */
8318 void **aExtension; /* Array of shared library handles */
8322 void (*xTrace)(void*,const char*); /* Trace function */
8323 void *pTraceArg; /* Argument to the trace function */
8324 void (*xProfile)(void*,const char*,u64); /* Profiling function */
8325 void *pProfileArg; /* Argument to profile function */
8326 void *pCommitArg; /* Argument to xCommitCallback() */
8327 int (*xCommitCallback)(void*); /* Invoked at every commit. */
8328 void *pRollbackArg; /* Argument to xRollbackCallback() */
8329 void (*xRollbackCallback)(void*); /* Invoked at every commit. */
8330 void *pUpdateArg;
8331 void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);
8332 void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);
8333 void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);
8334 void *pCollNeededArg;
8344 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
8346 void *pAuthArg; /* 1st argument to the access auth function */
8349 int (*xProgress)(void *); /* The progress callback */
8350 void *pProgressArg; /* Argument to the progress callback */
8384 void *pUnlockArg; /* Argument to xUnlockNotify */
8385 void (*xUnlockNotify)(void **, int); /* Unlock notify callback */
8455 void *pUserData; /* User data parameter */
8457 void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */
8458 void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */
8459 void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */
8482 ** value passed as iArg is cast to a (void*) and made available
8495 ** function likeFunc. Argument pArg is cast to a (void *) and made
8507 {nArg, SQLITE_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0}
8541 void *pAux; /* pAux passed to create_module() */
8542 void (*xDestroy)(void *); /* Module destructor function */
8588 void *pUser; /* First argument to xCmp() */
8589 int (*xCmp)(void*,int, const void*, int, const void*);
8590 void (*xDel)(void*); /* Destructor for pUser */
9858 void *pHeap; /* Heap storage space */
9861 void *pScratch; /* Scratch memory */
9864 void *pPage; /* Page cache memory */
9925 SQLITE_PRIVATE int sqlite3Corrupt(void);
9971 SQLITE_PRIVATE int sqlite3MallocInit(void);
9972 SQLITE_PRIVATE void sqlite3MallocEnd(void);
9973 SQLITE_PRIVATE void *sqlite3Malloc(int);
9974 SQLITE_PRIVATE void *sqlite3MallocZero(int);
9975 SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3*, int);
9976 SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3*, int);
9979 SQLITE_PRIVATE void *sqlite3Realloc(void*, int);
9980 SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *, void *, int);
9981 SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *, void *, int);
9982 SQLITE_PRIVATE void sqlite3DbFree(sqlite3*, void*);
9983 SQLITE_PRIVATE int sqlite3MallocSize(void*);
9984 SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3*, void*);
9985 SQLITE_PRIVATE void *sqlite3ScratchMalloc(int);
9986 SQLITE_PRIVATE void sqlite3ScratchFree(void*);
9987 SQLITE_PRIVATE void *sqlite3PageMalloc(int);
9988 SQLITE_PRIVATE void sqlite3PageFree(void*);
9989 SQLITE_PRIVATE void sqlite3MemSetDefault(void);
9990 SQLITE_PRIVATE void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
9991 SQLITE_PRIVATE int sqlite3MemoryAlarm(void (*)(void*, sqlite3_int64, int), void*, sqlite3_int64);
10012 SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
10015 SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void);
10020 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void);
10022 SQLITE_PRIVATE int sqlite3MutexInit(void);
10023 SQLITE_PRIVATE int sqlite3MutexEnd(void);
10027 SQLITE_PRIVATE void sqlite3StatusAdd(int, int);
10028 SQLITE_PRIVATE void sqlite3StatusSet(int, int);
10032 SQLITE_PRIVATE void sqlite3VXPrintf(StrAccum*, int, const char*, va_list);
10034 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum*, const char*, ...);
10040 SQLITE_PRIVATE void sqlite3DebugPrintf(const char*, ...);
10043 SQLITE_PRIVATE void *sqlite3TestTextToPtr(const char*);
10045 SQLITE_PRIVATE void sqlite3SetString(char **, sqlite3*, const char*, ...);
10046 SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...);
10047 SQLITE_PRIVATE void sqlite3ErrorClear(Parse*);
10051 SQLITE_PRIVATE void sqlite3FinishCoding(Parse*);
10053 SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse*,int);
10055 SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse*,int,int);
10058 SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*);
10062 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse*, Expr*);
10063 SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3*, Expr*);
10065 SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int);
10066 SQLITE_PRIVATE void sqlite3ExprListSetSpan(Parse*,ExprList*,ExprSpan*);
10067 SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3*, ExprList*);
10069 SQLITE_PRIVATE int sqlite3InitCallback(void*, int, char**, char**);
10070 SQLITE_PRIVATE void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);
10071 SQLITE_PRIVATE void sqlite3ResetInternalSchema(sqlite3*, int);
10072 SQLITE_PRIVATE void sqlite3BeginParse(Parse*,int);
10073 SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*);
10075 SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *, int);
10076 SQLITE_PRIVATE void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int);
10077 SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token*);
10078 SQLITE_PRIVATE void sqlite3AddNotNull(Parse*, int);
10079 SQLITE_PRIVATE void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int);
10080 SQLITE_PRIVATE void sqlite3AddCheckConstraint(Parse*, Expr*);
10081 SQLITE_PRIVATE void sqlite3AddColumnType(Parse*,Token*);
10082 SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse*,ExprSpan*);
10083 SQLITE_PRIVATE void sqlite3AddCollateType(Parse*, Token*);
10084 SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,Select*);
10089 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec*, u32, void*);
10090 SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec*);
10094 SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3*, void*, unsigned int);
10095 SQLITE_PRIVATE void sqlite3RowSetClear(RowSet*);
10096 SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet*, i64);
10100 SQLITE_PRIVATE void sqlite3CreateView(Parse*,Token*,Token*,Token*,Select*,int,int);
10108 SQLITE_PRIVATE void sqlite3DropTable(Parse*, SrcList*, int, int);
10109 SQLITE_PRIVATE void sqlite3DeleteTable(Table*);
10111 SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse);
10112 SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse);
10117 SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, ExprList*, Select*, IdList*, int);
10118 SQLITE_PRIVATE void *sqlite3ArrayAllocate(sqlite3*,void*,int,int,int*,int*,int*);
10125 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *);
10127 SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList*);
10128 SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse*, SrcList*);
10129 SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3*, IdList*);
10130 SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3*, SrcList*);
10133 SQLITE_PRIVATE void sqlite3DropIndex(Parse*, SrcList*, int);
10137 SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3*, Select*);
10140 SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
10144 SQLITE_PRIVATE void sqlite3DeleteFrom(Parse*, SrcList*, Expr*);
10145 SQLITE_PRIVATE void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*, int);
10147 SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo*);
10149 SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int);
10150 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse*, int, int, int);
10151 SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse*, int, int, int);
10152 SQLITE_PRIVATE void sqlite3ExprCachePush(Parse*);
10153 SQLITE_PRIVATE void sqlite3ExprCachePop(Parse*, int);
10154 SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse*, int, int);
10155 SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse*);
10156 SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse*, int, int);
10157 SQLITE_PRIVATE void sqlite3ExprHardCopy(Parse*,int,int);
10162 SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse*, Expr*);
10164 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse*, Expr*, int, int);
10165 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse*, Expr*, int, int);
10169 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*);
10170 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*);
10171 SQLITE_PRIVATE void sqlite3Vacuum(Parse*);
10175 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
10176 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
10178 SQLITE_PRIVATE void sqlite3PrngSaveState(void);
10179 SQLITE_PRIVATE void sqlite3PrngRestoreState(void);
10180 SQLITE_PRIVATE void sqlite3PrngResetState(void);
10181 SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3*);
10182 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse*, int);
10183 SQLITE_PRIVATE void sqlite3BeginTransaction(Parse*, int);
10184 SQLITE_PRIVATE void sqlite3CommitTransaction(Parse*);
10185 SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse*);
10186 SQLITE_PRIVATE void sqlite3Savepoint(Parse*, int, Token*);
10187 SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *);
10193 SQLITE_PRIVATE void sqlite3ExprCodeIsNullJump(Vdbe*, const Expr*, int, int);
10196 SQLITE_PRIVATE void sqlite3GenerateRowDelete(Parse*, Table*, int, int, int, Trigger *, int);
10197 SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int*);
10199 SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int,int,
10201 SQLITE_PRIVATE void sqlite3CompleteInsertion(Parse*, Table*, int, int, int*, int, int, int);
10203 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse*, int, int);
10204 SQLITE_PRIVATE void sqlite3MultiWrite(Parse*);
10205 SQLITE_PRIVATE void sqlite3MayAbort(Parse*);
10206 SQLITE_PRIVATE void sqlite3HaltConstraint(Parse*, int, char*, int);
10212 SQLITE_PRIVATE void sqlite3FuncDefInsert(FuncDefHash*, FuncDef*);
10214 SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3*);
10215 SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void);
10216 SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void);
10226 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse*, int);
10229 SQLITE_PRIVATE void sqlite3MaterializeView(Parse*, Table*, Expr*, int);
10233 SQLITE_PRIVATE void sqlite3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*,
10235 SQLITE_PRIVATE void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*);
10236 SQLITE_PRIVATE void sqlite3DropTrigger(Parse*, SrcList*, int);
10237 SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse*, Trigger*);
10240 SQLITE_PRIVATE void sqlite3CodeRowTrigger(Parse*, Trigger *, int, ExprList*, int, Table *,
10242 SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int);
10243 void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*);
10244 SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*);
10250 SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3*, Trigger*);
10251 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*);
10267 SQLITE_PRIVATE void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int);
10268 SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse*, int);
10270 SQLITE_PRIVATE void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*);
10272 SQLITE_PRIVATE void sqlite3AuthContextPush(Parse*, AuthContext*, const char*);
10273 SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext*);
10279 # define sqlite3AuthContextPop(a) ((void)(a))
10281 SQLITE_PRIVATE void sqlite3Attach(Parse*, Expr*, Expr*, Expr*);
10282 SQLITE_PRIVATE void sqlite3Detach(Parse*, Expr*);
10294 SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar);
10335 SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *, Table *);
10340 SQLITE_PRIVATE void sqlite3Error(sqlite3*, int, const char*,...);
10341 SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
10351 SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, int);
10353 SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value*, u8);
10355 SQLITE_PRIVATE void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
10356 void(*)(void*));
10357 SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value*);
10359 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int);
10364 SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
10373 SQLITE_PRIVATE void sqlite3RootPageMoved(Db*, int, int);
10374 SQLITE_PRIVATE void sqlite3Reindex(Parse*, Token*, Token*);
10375 SQLITE_PRIVATE void sqlite3AlterFunctions(sqlite3*);
10376 SQLITE_PRIVATE void sqlite3AlterRenameTable(Parse*, SrcList*, Token*);
10378 SQLITE_PRIVATE void sqlite3NestedParse(Parse*, const char*, ...);
10379 SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3*);
10381 SQLITE_PRIVATE void sqlite3SelectPrep(Parse*, Select*, NameContext*);
10383 SQLITE_PRIVATE void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*);
10385 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int);
10386 SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *, Token *);
10387 SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
10390 SQLITE_PRIVATE void sqlite3Analyze(Parse*, Token*, Token*);
10395 SQLITE_PRIVATE void sqlite3DeleteIndexSamples(Index*);
10396 SQLITE_PRIVATE void sqlite3DefaultRowEst(Index*);
10397 SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3*, int);
10399 SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse*, int, int);
10400 SQLITE_PRIVATE void sqlite3SchemaFree(void *);
10404 SQLITE_PRIVATE int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
10405 void (*)(sqlite3_context*,int,sqlite3_value **),
10406 void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*));
10410 SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, char*, int, int);
10411 SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum*,const char*,int);
10413 SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum*);
10414 SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest*,int,int);
10417 SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *);
10418 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
10423 SQLITE_PRIVATE void *sqlite3ParserAlloc(void*(*)(size_t));
10424 SQLITE_PRIVATE void sqlite3ParserFree(void*, void(*)(void*));
10425 SQLITE_PRIVATE void sqlite3Parser(void*, int, Token, Parse*);
10427 SQLITE_PRIVATE int sqlite3ParserStackPeak(void*);
10430 SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3*);
10432 SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3*);
10438 SQLITE_PRIVATE void sqlite3TableLock(Parse *, int, int, u8, const char *);
10457 SQLITE_PRIVATE void sqlite3VtabClear(Table*);
10461 SQLITE_PRIVATE void sqlite3VtabLock(VTable *);
10462 SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *);
10463 SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3*);
10466 SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse*,Table*);
10467 SQLITE_PRIVATE void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*);
10468 SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse*, Token*);
10469 SQLITE_PRIVATE void sqlite3VtabArgInit(Parse*);
10470 SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse*, Token*);
10476 SQLITE_PRIVATE void sqlite3InvalidFunction(sqlite3_context*,int,sqlite3_value**);
10480 SQLITE_PRIVATE void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*);
10493 SQLITE_PRIVATE void sqlite3FkCheck(Parse*, Table*, int, int);
10494 SQLITE_PRIVATE void sqlite3FkDropTable(Parse*, SrcList *, Table*);
10495 SQLITE_PRIVATE void sqlite3FkActions(Parse*, Table*, ExprList*, int);
10507 SQLITE_PRIVATE void sqlite3FkDelete(Table*);
10525 SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void);
10526 SQLITE_PRIVATE void sqlite3EndBenignMalloc(void);
10545 SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *);
10546 SQLITE_PRIVATE int sqlite3MemJournalSize(void);
10550 SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p);
10560 SQLITE_PRIVATE void sqlite3Put4byte(u8*, u32);
10563 SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *, sqlite3 *);
10564 SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db);
10565 SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db);
10573 SQLITE_PRIVATE void sqlite3ParserTrace(FILE*, char *);
10583 SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe*);
10584 SQLITE_PRIVATE void (*sqlite3IoTrace)(const char*,...);
10740 (void*)0, /* pHeap */
10743 (void*)0, /* pScratch */
10746 (void*)0, /* pPage */
10852 SQLITE_PRIVATE void sqlite3StatusAdd(int op, int N){
10864 SQLITE_PRIVATE void sqlite3StatusSet(int op, int X){
11152 static void computeJD(DateTime *p){
11233 static void setDateTimeToCurrent(sqlite3_context *context, DateTime *p){
11283 static void computeYMD(DateTime *p){
11309 static void computeHMS(DateTime *p){
11327 static void computeYMD_HMS(DateTime *p){
11335 static void clearYMD_HMS_TZ(DateTime *p){
11675 static void juliandayFunc(
11692 static void datetimeFunc(
11712 static void timeFunc(
11731 static void dateFunc(
11764 static void strftimeFunc(
11900 static void ctimeFunc(
11914 static void cdateFunc(
11928 static void ctimestampFunc(
11950 static void currentTimeFunc(
11999 SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void){
12064 void *pTstAlloc = sqlite3Malloc(10); \
12086 SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
12090 SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
12116 SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
12170 SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
12173 SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
12176 SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHdle, const char *zSym))(void){
12179 SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
12227 SQLITE_PRIVATE int sqlite3OsInit(void){
12228 void *p = sqlite3_malloc(10);
12268 static void vfsUnlink(sqlite3_vfs *pVfs){
12360 void (*xBenignBegin)(void);
12361 void (*xBenignEnd)(void);
12384 SQLITE_PRIVATE void sqlite3BenignMallocHooks(
12385 void (*xBenignBegin)(void),
12386 void (*xBenignEnd)(void)
12398 SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void){
12404 SQLITE_PRIVATE void sqlite3EndBenignMalloc(void){
12444 static void *sqlite3MemMalloc(int nByte){ return 0; }
12445 static void sqlite3MemFree(void *pPrior){ return; }
12446 static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; }
12447 static int sqlite3MemSize(void *pPrior){ return 0; }
12449 static int sqlite3MemInit(void *NotUsed){ return SQLITE_OK; }
12450 static void sqlite3MemShutdown(void *NotUsed){ return; }
12458 SQLITE_PRIVATE void sqlite3MemSetDefault(void){
12511 static void *sqlite3MemMalloc(int nByte){
12520 return (void *)p;
12531 static void sqlite3MemFree(void *pPrior){
12548 static void *sqlite3MemRealloc(void *pPrior, int nByte){
12559 return (void*)p;
12566 static int sqlite3MemSize(void *pPrior){
12584 static int sqlite3MemInit(void *NotUsed){
12592 static void sqlite3MemShutdown(void *NotUsed){
12603 SQLITE_PRIVATE void sqlite3MemSetDefault(void){
12653 extern int backtrace(void**,int);
12654 extern void backtrace_symbols_fd(void*const*,int,int);
12716 void (*xBacktrace)(int, int, void **);
12746 static void adjustStats(int iSize, int increment){
12769 static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){
12793 static int sqlite3MemSize(void *p){
12805 static int sqlite3MemInit(void *NotUsed){
12819 static void sqlite3MemShutdown(void *NotUsed){
12836 static void randomFill(char *pBuf, int nByte){
12859 static void *sqlite3MemMalloc(int nByte){
12861 void **pBt;
12864 void *p = 0;
12871 mem.nBacktrace*sizeof(void*) + mem.nTitle;
12875 pBt = (void**)&z[mem.nTitle];
12889 void *aAddr[40];
12891 memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*));
12908 p = (void*)pInt;
12917 static void sqlite3MemFree(void *pPrior){
12919 void **pBt;
12923 pBt = (void**)pHdr;
12943 randomFill(z, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) +
12958 static void *sqlite3MemRealloc(void *pPrior, int nByte){
12960 void *pNew;
12978 SQLITE_PRIVATE void sqlite3MemSetDefault(void){
12997 SQLITE_PRIVATE void sqlite3MemdebugBacktrace(int depth){
13004 SQLITE_PRIVATE void sqlite3MemdebugBacktraceCallback(void (*xBacktrace)(int, int, void **)){
13011 SQLITE_PRIVATE void sqlite3MemdebugSettitle(const char *zTitle){
13021 SQLITE_PRIVATE void sqlite3MemdebugSync(){
13024 void **pBt = (void**)pHdr;
13034 SQLITE_PRIVATE void sqlite3MemdebugDump(const char *zFilename){
13037 void **pBt;
13047 z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle;
13052 pBt = (void**)pHdr;
13235 static void memsys3UnlinkFromList(u32 i, u32 *pRoot){
13255 static void memsys3Unlink(u32 i){
13275 static void memsys3LinkIntoList(u32 i, u32 *pRoot){
13289 static void memsys3Link(u32 i){
13310 static void memsys3Enter(void){
13316 static void memsys3Leave(void){
13323 static void memsys3OutOfMemory(int nByte){
13340 static void *memsys3Checkout(u32 i, u32 nBlock){
13358 static void *memsys3FromMaster(u32 nBlock){
13363 void *p = memsys3Checkout(mem3.iMaster, mem3.szMaster);
13383 return (void*)&mem3.aPool[newi];
13403 static void memsys3Merge(u32 *pRoot){
13442 static void *memsys3MallocUnsafe(int nByte){
13524 void memsys3FreeUnsafe(void *pOld){
13565 static int memsys3Size(void *p){
13587 static void *memsys3Malloc(int nBytes){
13593 return (void*)p;
13599 void memsys3Free(void *pPrior){
13609 void *memsys3Realloc(void *pPrior, int nBytes){
13611 void *p;
13640 static int memsys3Init(void *NotUsed){
13665 static void memsys3Shutdown(void *NotUsed){
13677 SQLITE_PRIVATE void sqlite3Memsys3Dump(const char *zFilename){
13761 SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void){
13924 static void memsys5Unlink(int i, int iLogsize){
13946 static void memsys5Link(int i, int iLogsize){
13967 static void memsys5Enter(void){
13970 static void memsys5Leave(void){
13979 static int memsys5Size(void *p){
14018 static void *memsys5MallocUnsafe(int nByte){
14070 return (void*)&mem5.zPool[i*mem5.szAtom];
14076 static void memsys5FreeUnsafe(void *pOld){
14132 static void *memsys5Malloc(int nBytes){
14139 return (void*)p;
14148 static void memsys5Free(void *pPrior){
14167 static void *memsys5Realloc(void *pPrior, int nBytes){
14169 void *p;
14228 static int memsys5Init(void *NotUsed){
14285 static void memsys5Shutdown(void *NotUsed){
14296 SQLITE_PRIVATE void sqlite3Memsys5Dump(const char *zFilename){
14339 SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void){
14387 SQLITE_PRIVATE int sqlite3MutexInit(void){
14418 SQLITE_PRIVATE int sqlite3MutexEnd(void){
14452 SQLITE_API void sqlite3_mutex_free(sqlite3_mutex *p){
14462 SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex *p){
14486 SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex *p){
14546 static int noopMutexInit(void){ return SQLITE_OK; }
14547 static int noopMutexEnd(void){ return SQLITE_OK; }
14549 static void noopMutexFree(sqlite3_mutex *p){ return; }
14550 static void noopMutexEnter(sqlite3_mutex *p){ return; }
14552 static void noopMutexLeave(sqlite3_mutex *p){ return; }
14554 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void){
14601 static int debugMutexInit(void){ return SQLITE_OK; }
14602 static int debugMutexEnd(void){ return SQLITE_OK; }
14636 static void debugMutexFree(sqlite3_mutex *p){
14653 static void debugMutexEnter(sqlite3_mutex *p){
14669 static void debugMutexLeave(sqlite3_mutex *p){
14675 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void){
14736 static int os2MutexInit(void){ return SQLITE_OK; }
14737 static int os2MutexEnd(void){ return SQLITE_OK; }
14846 static void os2MutexFree(sqlite3_mutex *p){
14898 static void os2MutexEnter(sqlite3_mutex *p){
14934 static void os2MutexLeave(sqlite3_mutex *p){
14947 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void){
15040 static int pthreadMutexInit(void){ return SQLITE_OK; }
15041 static int pthreadMutexEnd(void){ return SQLITE_OK; }
15140 static void pthreadMutexFree(sqlite3_mutex *p){
15158 static void pthreadMutexEnter(sqlite3_mutex *p){
15252 static void pthreadMutexLeave(sqlite3_mutex *p){
15272 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void){
15348 static int mutexIsNT(void){
15387 static int winMutexInit(void){
15404 static int winMutexEnd(void){
15492 static void winMutexFree(sqlite3_mutex *p){
15511 static void winMutexEnter(sqlite3_mutex *p){
15549 static void winMutexLeave(sqlite3_mutex *p){
15557 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void){
15601 static void softHeapLimitEnforcer(
15602 void *NotUsed,
15614 SQLITE_API void sqlite3_soft_heap_limit(int n){
15669 void (*alarmCallback)(void*, sqlite3_int64,int);
15670 void *alarmArg;
15686 SQLITE_PRIVATE int sqlite3MallocInit(void){
15728 SQLITE_PRIVATE void sqlite3MallocEnd(void){
15738 SQLITE_API sqlite3_int64 sqlite3_memory_used(void){
15763 void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
15764 void *pArg,
15781 void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
15782 void *pArg,
15792 static void sqlite3MallocAlarm(int nByte){
15793 void (*xCallback)(void*,sqlite3_int64,int);
15795 void *pArg;
15812 static int mallocWithAlarm(int n, void **pp){
15814 void *p;
15841 SQLITE_PRIVATE void *sqlite3Malloc(int n){
15842 void *p;
15865 SQLITE_API void *sqlite3_malloc(int n){
15891 SQLITE_PRIVATE void *sqlite3ScratchMalloc(int n){
15892 void *p;
15917 p = (void*)&((char*)sqlite3GlobalConfig.pScratch)[i];
15942 SQLITE_PRIVATE void sqlite3ScratchFree(void *p){
15956 || p>=(void*)mem0.aScratchFree ){
15985 static int isLookaside(sqlite3 *db, void *p){
15996 SQLITE_PRIVATE int sqlite3MallocSize(void *p){
15999 SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){
16011 SQLITE_API void sqlite3_free(void *p){
16027 SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){
16042 SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, int nBytes){
16044 void *pNew;
16087 SQLITE_API void *sqlite3_realloc(void *pOld, int n){
16098 SQLITE_PRIVATE void *sqlite3MallocZero(int n){
16099 void *p = sqlite3Malloc(n);
16110 SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, int n){
16111 void *p = sqlite3DbMallocRaw(db, n);
16136 SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3 *db, int n){
16137 void *p;
16152 return (void*)pBuf;
16171 SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){
16172 void *pNew = 0;
16202 SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){
16203 void *pNew;
16251 SQLITE_PRIVATE void sqlite3SetString(char **pz, sqlite3 *db, const char *zFormat, ...){
16467 static void appendSpace(StrAccum *pAccum, int N){
16518 SQLITE_PRIVATE void sqlite3VXPrintf(
17032 SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){
17102 SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum *p){
17112 SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, char *zBase, int n, int mx){
17236 SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){
17255 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, const char *zFormat, ...){
17309 static u8 randomByte(void){
17368 SQLITE_API void sqlite3_randomness(int N, void *pBuf){
17391 SQLITE_PRIVATE void sqlite3PrngSaveState(void){
17398 SQLITE_PRIVATE void sqlite3PrngRestoreState(void){
17405 SQLITE_PRIVATE void sqlite3PrngResetState(void){
17561 void *token; /* Copy of SubProgram.token */
17602 void (*xDel)(void *); /* If not null, call this function to delete Mem.z */
17668 void *pAux; /* Aux data for the i-th argument */
17669 void (*xDelete)(void *); /* Destructor for the aux data */
17763 void *pFree; /* Free this when deleting the vdbe */
17786 SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*);
17787 void sqliteVdbePopStack(Vdbe*,int);
17790 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE*, int, Op*);
17796 SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(VdbeFunc*, int);
17798 int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
17808 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
17809 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*);
17811 SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
17812 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64);
17813 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem*, double);
17814 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*);
17815 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int);
17816 SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem*);
17822 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*);
17826 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
17827 SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p);
17832 SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*);
17834 SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem);
17843 SQLITE_PRIVATE void sqlite3VdbeMutexArrayEnter(Vdbe *p);
17850 SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe*);
17851 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
18266 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte){
18312 SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *zIn, int nChar){
18337 SQLITE_PRIVATE void sqlite3UtfSelfTest(void){
18413 SQLITE_PRIVATE void sqlite3Coverage(int x){
18500 SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){
18533 SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
18547 SQLITE_PRIVATE void sqlite3ErrorClear(Parse *pParse){
19335 SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){
19369 SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
19503 SQLITE_PRIVATE void sqlite3HashInit(Hash *pNew){
19515 SQLITE_PRIVATE void sqlite3HashClear(Hash *pH){
19549 static void insertElement(
19648 static void removeElementGivenHash(
19683 SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey, int nKey){
19713 SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, int nKey, void *data){
19728 void *old_data = elem->data;
20067 __inline__ sqlite_uint64 sqlite3Hwtime(void){
20075 __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
20086 __inline__ sqlite_uint64 sqlite3Hwtime(void){
20094 __inline__ sqlite_uint64 sqlite3Hwtime(void){
20118 SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
20156 static void local_ioerr(){
20241 void *pBuf, /* Write content into this buffer */
20272 const void *pBuf, /* The bytes to be written */
20660 static int os2FileControl(sqlite3_file *id, int op, void *pArg){
20702 static void initUconvObjects( void ){
20712 static void freeUconvObjects( void ){
21058 static void *os2DlOpen(sqlite3_vfs *pVfs, const char *zFilename){
21065 return rc != NO_ERROR ? 0 : (void*)hmod;
21071 static void os2DlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
21074 static void *os2DlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
21086 return rc != NO_ERROR ? 0 : (void*)pfn;
21088 static void os2DlClose(sqlite3_vfs *pVfs, void *pHandle){
21229 SQLITE_API int sqlite3_os_init(void){
21255 SQLITE_API int sqlite3_os_end(void){
21456 void *lockingContext; /* Locking style specific state */
21592 __inline__ sqlite_uint64 sqlite3Hwtime(void){
21600 __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
21611 __inline__ sqlite_uint64 sqlite3Hwtime(void){
21619 __inline__ sqlite_uint64 sqlite3Hwtime(void){
21643 SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
21681 static void local_ioerr(){
21770 static void unixEnterMutex(void){
21773 static void unixLeaveMutex(void){
21777 static int unixMutexHeld(void) {
22049 static void vxworksReleaseFileId(struct vxworksFileId *pId){
22315 static void *threadLockingTest(void *pArg){
22329 static void testThreadLockingBehavior(int fd_orig){
22364 static void releaseLockInfo(struct unixLockInfo *pLock){
22391 static void releaseOpenCnt(struct unixOpenCnt *pOpen){
22992 static void setPendingFd(unixFile *pFile){
24227 static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){
24265 void *pBuf,
24301 static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
24337 const void *pBuf,
24644 static int proxyFileControl(sqlite3_file*,int,void*);
24651 static int unixFileControl(sqlite3_file *id, int op, void *pArg){
24733 ** directly at the finder-function since C90 rules prevent a void*
25037 pNew->lockingContext = (void*)zFilename;
25651 static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){
25663 static void unixDlError(sqlite3_vfs *NotUsed, int nBuf, char *zBufOut){
25673 static void (*unixDlSym(sqlite3_vfs *NotUsed, void *p, const char*zSym))(void){
25675 ** GCC with -pedantic-errors says that C90 does not allow a void* to be
25677 ** returns a void* which is really a pointer to a function. So how do we
25681 ** parameters void* and const char* and returning a pointer to a function.
25687 ** you really cannot cast a function pointer into void*. But then, on the
25691 void (*(*x)(void*,const char*))(void);
25693 x = (void(*(*)(void*,const char*))(void))dlsym;
25696 static void unixDlClose(sqlite3_vfs *NotUsed, void *pHandle){
26018 void *oldLockingContext; /* Original lockingcontext to restore on close */
26073 static void proxyGetHostIDPath(char *path, size_t len){
26222 dummyVfs.pAppData = (void*)&autolockIoFinder;
26589 static int proxyFileControl(sqlite3_file *id, int op, void *pArg){
26791 SQLITE_API int sqlite3_os_init(void){
26796 ** silly C90 rules prohibit a void* from being cast to a function pointer
26818 (void*)&FINDER, /* pAppData */ \
26879 SQLITE_API int sqlite3_os_end(void){
27041 __inline__ sqlite_uint64 sqlite3Hwtime(void){
27049 __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
27060 __inline__ sqlite_uint64 sqlite3Hwtime(void){
27068 __inline__ sqlite_uint64 sqlite3Hwtime(void){
27092 SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
27130 static void local_ioerr(){
27257 static int isNT(void){
27439 static void winceMutexAcquire(HANDLE h){
27529 static void winceDestroyLock(winFile *pFile){
27772 void *pBuf, /* Write content into this buffer */
27810 const void *pBuf, /* The bytes to be written */
28208 static int winFileControl(sqlite3_file *id, int op, void *pArg){
28277 static void *convertUtf8Filename(const char *zFilename){
28278 void *zConverted = 0;
28429 void *zConverted; /* Filename in OS encoding */
28579 void *zConverted = convertUtf8Filename(zFilename);
28624 void *zConverted = convertUtf8Filename(zFilename);
28684 void *zConverted;
28756 void *zConverted = convertUtf8Filename(zFullpath);
28806 static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
28808 void *zConverted = convertUtf8Filename(zFilename);
28825 return (void*)h;
28827 static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
28831 void (*winDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol))(void){
28835 return (void(*)(void))GetProcAddressA((HANDLE)pHandle, zSymbol);
28839 return (void(*)(void))GetProcAddress((HANDLE)pHandle, zSymbol);
28842 void winDlClose(sqlite3_vfs *pVfs, void *pHandle){
28998 SQLITE_API int sqlite3_os_init(void){
29024 SQLITE_API int sqlite3_os_end(void){
29070 #define BITVEC_SZ (sizeof(void*)*128) /* 512 on 32bit. 1024 on 64bit */
29266 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){
29303 SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec *p){
29368 void *pTmpSpace;
29467 int (*xStress)(void*,PgHdr*); /* Call to try make a page clean */
29468 void *pStress; /* Argument to xStress */
29507 static void pcacheRemoveFromDirtyList(PgHdr *pPage){
29544 static void pcacheAddToDirtyList(PgHdr *pPage){
29568 static void pcacheUnpin(PgHdr *p){
29583 SQLITE_PRIVATE int sqlite3PcacheInitialize(void){
29589 SQLITE_PRIVATE void sqlite3PcacheShutdown(void){
29598 SQLITE_PRIVATE int sqlite3PcacheSize(void){ return sizeof(PCache); }
29606 SQLITE_PRIVATE void sqlite3PcacheOpen(
29610 int (*xStress)(void*,PgHdr*),/* Call to try to make pages clean */
29611 void *pStress, /* Argument to xStress */
29627 SQLITE_PRIVATE void sqlite3PcacheSetPageSize(PCache *pCache, int szPage){
29702 pPage->pExtra = (void*)&pPage[1];
29703 pPage->pData = (void *)&((char *)pPage)[sizeof(PgHdr) + pCache->szExtra];
29709 assert( pPage->pExtra==(void *)&pPage[1] );
29727 SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr *p){
29746 SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr *p){
29756 SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr *p){
29774 SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr *p){
29787 SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr *p){
29800 SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache *pCache){
29810 SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *pCache){
29821 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
29842 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){
29864 SQLITE_PRIVATE void sqlite3PcacheClose(PCache *pCache){
29873 SQLITE_PRIVATE void sqlite3PcacheClear(PCache *pCache){
29995 SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *pCache, int mxPage){
30008 SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)){
30103 void *pStart, *pEnd; /* Bounds of pagecache malloc range */
30127 #define PGHDR1_TO_PAGE(p) (void*)(((char*)p) - p->pCache->szPage)
30145 SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){
30156 pBuf = (void*)&((char*)pBuf)[sz];
30168 static void *pcache1Alloc(int nByte){
30169 void *p;
30199 static void pcache1Free(void *p){
30220 void *pPg = pcache1Alloc(nByte);
30240 static void pcache1FreePage(PgHdr1 *p){
30254 SQLITE_PRIVATE void *sqlite3PageMalloc(int sz){
30255 void *p;
30265 SQLITE_PRIVATE void sqlite3PageFree(void *p){
30324 static void pcache1PinPage(PgHdr1 *pPage){
30352 static void pcache1RemoveFromHash(PgHdr1 *pPage){
30368 static void pcache1EnforceMaxPage(void){
30385 static void pcache1TruncateUnsafe(
30416 static int pcache1Init(void *NotUsed){
30432 static void pcache1Shutdown(void *NotUsed){
30466 static void pcache1Cachesize(sqlite3_pcache *p, int nMax){
30537 static void *pcache1Fetch(sqlite3_pcache *p, unsigned int iKey, int createFlag){
30600 *(void **)(PGHDR1_TO_PAGE(pPage)) = 0;
30619 static void pcache1Unpin(sqlite3_pcache *p, void *pPg, int reuseUnlikely){
30658 static void pcache1Rekey(
30660 void *pPg,
30698 static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){
30713 static void pcache1Destroy(sqlite3_pcache *p){
30730 SQLITE_PRIVATE void sqlite3PCacheSetDefault(void){
30779 SQLITE_PRIVATE void sqlite3PcacheStats(
30923 SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3 *db, void *pSpace, unsigned int N){
30944 SQLITE_PRIVATE void sqlite3RowSetClear(RowSet *p){
30964 SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet *p, i64 rowid){
31038 static void rowSetSort(RowSet *p){
31070 static void rowSetTreeToList(
31159 static void rowSetToList(RowSet *p){
31519 int (*xBusyHandler)(void*); /* Function to call when busy */
31520 void *pBusyHandlerArg; /* Context argument for xBusyHandler */
31525 void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */
31527 void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
31528 void (*xCodecSizeChng)(void*,int,int); /* Notify of page size changes */
31529 void (*xCodecFree)(void*); /* Destructor for the codec */
31530 void *pCodec; /* First argument to xCodec... methods */
31773 static void pager_set_pagehash(PgHdr *pPage){
31783 static void checkPage(PgHdr *pPg){
32265 (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p);
32275 static void pager_reset(Pager *pPager){
32288 static void releaseAllSavepoints(Pager *pPager){
32332 static void pager_unlock(Pager *pPager){
32425 static void pagerUnlockAndRollback(Pager *pPager){
32777 void *pData;
33008 static void setSectorSize(Pager *pPager){
33398 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
33429 SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int bFullFsync){
33500 SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(
33502 int (*xBusyHandler)(void *), /* Pointer to busy-handler function */
33503 void *pBusyHandlerArg /* Argument to pass to xBusyHandler */
33514 static void pagerReportSize(Pager *pPager){
33592 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){
33623 void disable_simulated_io_errors(void){
33627 void enable_simulated_io_errors(void){
33801 static void assertTruncateConstraintCb(PgHdr *pPg){
33805 static void assertTruncateConstraint(Pager *pPager){
33818 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
33889 SQLITE_PRIVATE void sqlite3PagerRef(DbPage *pPg){
34161 void *pData = pPg->pData;
34186 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
34202 static int pagerStress(void *p, PgHdr *pPg){
34326 void (*xReinit)(DbPage*) /* Function to reinitialize pages */
34518 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
34656 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
34946 static void pagerUnlockIfUnused(Pager *pPager){
35145 SQLITE_PRIVATE void sqlite3PagerUnref(DbPage *pPg){
35356 void *pData = pPg->pData;
35624 SQLITE_PRIVATE void sqlite3PagerDontWrite(PgHdr *pPg){
35702 const void *zBuf = pPgHdr->pData;
36275 static void sqlite3PagerSetCodec(
36277 void *(*xCodec)(void*,void*,Pgno,int),
36278 void (*xCodecSizeChng)(void*,int,int),
36279 void (*xCodecFree)(void*),
36280 void *pCodec
36289 static void *sqlite3PagerGetCodec(Pager *pPager){
36456 SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *pPg){
36465 SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *pPg){
37000 void *pSchema; /* Pointer to space allocated by sqlite3BtreeSchema() */
37001 void (*xFreeSchema)(void*); /* Destructor for BtShared.pSchema */
37069 void *pKey; /* Saved key that was cursor's last known position */
37228 static void lockBtreeMutex(Btree *p){
37242 static void unlockBtreeMutex(Btree *p){
37268 SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){
37330 SQLITE_PRIVATE void sqlite3BtreeLeave(Btree *p){
37364 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
37367 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
37387 SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
37415 SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3 *db){
37468 SQLITE_PRIVATE void sqlite3BtreeMutexArrayInsert(BtreeMutexArray *pArray, Btree *pBtree){
37501 SQLITE_PRIVATE void sqlite3BtreeMutexArrayEnter(BtreeMutexArray *pArray){
37526 SQLITE_PRIVATE void sqlite3BtreeMutexArrayLeave(BtreeMutexArray *pArray){
37546 SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){
37549 SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
37910 static void clearAllSharedCacheTableLocks(Btree *p){
37955 static void downgradeAllSharedCacheTableLocks(Btree *p){
37971 static void releasePage(MemPage *pPage); /* Forward reference */
37989 static void invalidateOverflowCache(BtCursor *pCur){
37999 static void invalidateAllOverflowCache(BtShared *pBt){
38020 static void invalidateIncrblobCursors(
38111 static void btreeClearHasContent(BtShared *pBt){
38140 void *pKey = sqlite3Malloc( (int)pCur->nKey );
38192 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
38206 const void *pKey, /* Packed key if the btree is an index */
38312 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
38436 static void btreeParseCellPtr(
38509 static void btreeParseCell(
38590 static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
39036 static void zeroPage(MemPage *pPage, int flags){
39043 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
39176 static void releasePage(MemPage *pPage){
39180 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
39195 static void pageReinit(DbPage *pData){
39217 static int btreeInvokeBusyHandler(void *pArg){
39515 static void allocateTempSpace(BtShared *pBt){
39524 static void freeTempSpace(BtShared *pBt){
39893 static void unlockBtreeIfUnused(BtShared *pBt){
40554 static void btreeEndTransaction(Btree *p){
40680 SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode){
40921 SQLITE_PRIVATE int sqlite3BtreeCursorSize(void){
40933 SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor *p){
40949 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){
41013 static void assertCellInfo(BtCursor *pCur){
41025 static void getCellInfo(BtCursor *pCur){
41090 ** It might just as well be a procedure (returning void) but we continue
41189 void *pPayload, /* Pointer to page data */
41190 void *pBuf, /* Pointer to buffer */
41381 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
41398 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
41489 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
41490 const void *p = 0;
41494 p = (const void*)fetchPayload(pCur, pAmt, 0);
41498 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
41499 const void *p = 0;
41503 p = (const void*)fetchPayload(pCur, pAmt, 1);
41552 static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){
41572 static void moveToParent(BtCursor *pCur){
41922 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
41928 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
41934 void *pCellKey;
42567 static void freePage(MemPage *pPage, int *pRC){
42632 const void *pKey, i64 nKey, /* The key */
42633 const void *pData,int nData, /* The data */
42787 static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){
42842 static void insertCell(
42929 static void assemblePage(
43144 static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){
43399 pOld->aData = (void*)&pOld[1];
44036 const void *pKey, i64 nKey, /* The key of the new record */
44037 const void *pData, int nData, /* The data of the new record */
44655 SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
44785 static void checkAppendMsg(
44838 static void checkPtrmap(
44868 static void checkList(
45299 SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){
45362 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
45405 SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *pCur){
45689 static void attachBackupObject(sqlite3_backup *p){
45960 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){
45989 SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *pBackup){
46143 pMem->xDel((void *)(pMem->z));
46311 SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p){
46324 p->xDel((void *)p->z);
46339 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){
46453 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
46530 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){
46545 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
46567 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
46578 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
46593 SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem *pMem){
46637 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
46677 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
46709 void (*xDel)(void*) /* Destructor function */
46873 const void *v1, *v2;
46973 SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
47110 SQLITE_PRIVATE void sqlite3ValueSetStr(
47113 const void *z, /* Text of the new string */
47115 void (*xDel)(void*) /* Destructor for the string */
47123 SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value *v){
47197 SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, int isPrepareV2){
47219 SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){
47241 SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe *p, FILE *trace){
47393 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *p, int x){
47536 static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
47651 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){
47663 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){
47674 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, int addr, int val){
47686 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u8 val){
47698 SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe *p, int addr){
47707 static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef){
47716 static void freeP4(sqlite3 *db, int p4type, void *p4){
47761 static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
47787 SQLITE_PRIVATE void sqlite3VdbeProgramDelete(sqlite3 *db, SubProgram *p, int freeop){
47807 SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr, int N){
47845 SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
47853 freeP4(db, n, (void*)*(char**)&zP4);
47895 pOp->p4.p = (void*)zP4;
47898 pOp->p4.p = (void*)zP4;
47903 pOp->p4.p = (void*)zP4;
47919 SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){
47932 SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){
48091 SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe *p, int i){
48107 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
48128 static void releaseMemArray(Mem *p, int N){
48165 SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame *p){
48381 SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe *p){
48398 SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe *p){
48445 static void *allocSpace(
48446 void *pBuf, /* Where return pointer will be stored */
48456 pBuf = (void*)*ppFrom;
48481 SQLITE_PRIVATE void sqlite3VdbeMakeReady(
48605 SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
48621 (void)sqlite3SafetyOff(p->db);
48623 (void)sqlite3SafetyOn(p->db);
48655 static void closeAllCursors(Vdbe *p){
48686 static void Cleanup(Vdbe *p){
48708 SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
48741 void (*xDel)(void*) /* Memory management strategy for zName */
48804 (void)sqlite3SafetyOff(db);
48806 (void)sqlite3SafetyOn(db);
48992 static void checkActiveVdbeCnt(sqlite3 *db){
49027 static void invalidateCursorsOnModifiedBtrees(sqlite3 *db){
49110 SQLITE_PRIVATE void sqlite3VdbeMutexArrayEnter(Vdbe *p){
49337 SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe *p){
49360 (void)sqlite3SafetyOn(db);
49362 (void)sqlite3SafetyOff(db);
49445 SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(VdbeFunc *pVdbeFunc, int mask){
49461 SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){
49854 const void *pKey, /* The binary record */
49906 return (void*)p;
49912 SQLITE_PRIVATE void sqlite3VdbeDeleteUnpackedRecord(UnpackedRecord *p){
49958 int nKey1, const void *pKey1, /* Left key */
50094 (void)getVarint32((u8*)m.z, szHdr);
50103 (void)getVarint32((u8*)&m.z[szHdr-1], typeRowid);
50180 SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){
50190 SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe *v){
50204 SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3 *db){
50248 SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
50368 SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){
50398 SQLITE_API const void *sqlite3_value_text16(sqlite3_value* pVal){
50401 SQLITE_API const void *sqlite3_value_text16be(sqlite3_value *pVal){
50404 SQLITE_API const void *sqlite3_value_text16le(sqlite3_value *pVal){
50420 static void setResultStrOrError(
50425 void (*xDel)(void*) /* Destructor function */
50431 SQLITE_API void sqlite3_result_blob(
50433 const void *z,
50435 void (*xDel)(void *)
50441 SQLITE_API void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
50445 SQLITE_API void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
50451 SQLITE_API void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
50457 SQLITE_API void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
50461 SQLITE_API void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
50465 SQLITE_API void sqlite3_result_null(sqlite3_context *pCtx){
50469 SQLITE_API void sqlite3_result_text(
50473 void (*xDel)(void *)
50479 SQLITE_API void sqlite3_result_text16(
50481 const void *z,
50483 void (*xDel)(void *)
50488 SQLITE_API void sqlite3_result_text16be(
50490 const void *z,
50492 void (*xDel)(void *)
50497 SQLITE_API void sqlite3_result_text16le(
50499 const void *z,
50501 void (*xDel)(void *)
50507 SQLITE_API void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
50511 SQLITE_API void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
50515 SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
50524 SQLITE_API void sqlite3_result_error_toobig(sqlite3_context *pCtx){
50532 SQLITE_API void sqlite3_result_error_nomem(sqlite3_context *pCtx){
50696 SQLITE_API void *sqlite3_user_data(sqlite3_context *p){
50718 SQLITE_PRIVATE void sqlite3InvalidFunction(
50737 SQLITE_API void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
50757 return (void*)pMem->z;
50764 SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
50780 SQLITE_API void sqlite3_set_auxdata(
50783 void *pAux,
50784 void (*xDelete)(void*)
50916 static void columnMallocFailure(sqlite3_stmt *pStmt)
50934 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
50935 const void *val;
50984 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
50985 const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
51019 static const void *columnName(
51022 const void *(*xFunc)(Mem*),
51025 const void *ret = 0;
51055 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
51058 SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
51060 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
51080 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
51083 SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
51085 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
51098 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
51101 SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
51103 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
51114 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
51117 SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
51119 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
51130 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
51133 SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
51135 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
51193 const void *zData, /* Pointer to the data to be bound */
51195 void (*xDel)(void*), /* Destructor for the data */
51225 const void *zData,
51227 void (*xDel)(void*)
51268 void (*xDel)(void*)
51276 const void *zData,
51278 void (*xDel)(void*)
51339 static void createVarMap(Vdbe *p){
51718 static void updateMaxBlobsize(Mem *p){
51781 SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem){
51865 static void applyNumericAffinity(Mem *pRec){
51901 static void applyAffinity(
51944 SQLITE_PRIVATE void sqlite3ValueApplyAffinity(
51957 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
52039 static void memTracePrint(FILE *out, Mem *p){
52059 static void registerTrace(FILE *out, int iReg, Mem *p){
52110 __inline__ sqlite_uint64 sqlite3Hwtime(void){
52118 __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
52129 __inline__ sqlite_uint64 sqlite3Hwtime(void){
52137 __inline__ sqlite_uint64 sqlite3Hwtime(void){
52161 SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
52595 void *t; /* Token identifying trigger */
56787 (void)sqlite3SafetyOff(db);
56796 (void)sqlite3SafetyOn(db);
57049 void *t; /* Token identifying trigger */
58140 (void)sqlite3SafetyOff(db);
58155 (void)sqlite3SafetyOff(db);
58196 (void)sqlite3SafetyOff(db);
58338 void *z,
58341 int (*xCall)(BtCursor*, u32, u32, void*)
58386 SQLITE_API int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
58393 SQLITE_API int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
58394 return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
58494 void *zBuf, /* Put the results here */
58515 const void *zBuf, /* Take data to be written from here */
58720 void *zBuf, /* Put the results here */
58765 const void *zBuf, /* Take data to be written from here */
58882 SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *pJfd){
58901 SQLITE_PRIVATE int sqlite3MemJournalSize(void){
59087 static void resolveAlias(
59740 static void resolveOutOfRangeError(
60222 SQLITE_PRIVATE void sqlite3ResolveSelectNames(
60486 (void*)p4, P4_COLLSEQ);
60522 static void heightOfExpr(Expr *p, int *pnHeight){
60529 static void heightOfExprList(ExprList *p, int *pnHeight){
60537 static void heightOfSelect(Select *p, int *pnHeight){
60557 static void exprSetHeight(Expr *p){
60574 SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
60676 SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(
60775 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
60845 SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){
61252 SQLITE_PRIVATE void sqlite3ExprListSetName(
61277 SQLITE_PRIVATE void sqlite3ExprListSetSpan(
61298 SQLITE_PRIVATE void sqlite3ExprListCheckLength(
61314 SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){
61502 SQLITE_PRIVATE void sqlite3ExprCodeIsNullJump(
61935 sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
62007 static void sqlite3ExprCodeIN(
62130 static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
62151 static void codeInteger(Vdbe *v, Expr *pExpr, int negFlag, int iMem){
62175 static void cacheEntryClear(Parse *pParse, struct yColCache *p){
62189 SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
62262 SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse *pParse, int iReg, int nReg){
62280 SQLITE_PRIVATE void sqlite3ExprCachePush(Parse *pParse){
62289 SQLITE_PRIVATE void sqlite3ExprCachePop(Parse *pParse, int N){
62309 static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){
62361 SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse *pParse){
62377 SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
62385 SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
62402 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
62434 SQLITE_PRIVATE void sqlite3ExprHardCopy(Parse *pParse, int iReg, int nReg){
63289 SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
63344 static void exprCodeBetween(
63402 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
63520 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
63893 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
63908 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
63936 SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
63967 SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
64012 static void renameTableFunc(
64077 static void renameParentFunc(
64132 static void renameTriggerFunc(
64204 SQLITE_PRIVATE void sqlite3AlterFunctions(sqlite3 *db){
64296 static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
64341 SQLITE_PRIVATE void sqlite3AlterRenameTable(
64541 SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
64570 SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
64691 SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
64803 static void openStatTable(
64873 static void analyzeOneTable(
65098 static void loadAnalysis(Parse *pParse, int iDb){
65108 static void analyzeDatabase(Parse *pParse, int iDb){
65131 static void analyzeTable(Parse *pParse, Table *pTab){
65158 SQLITE_PRIVATE void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
65229 static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
65263 SQLITE_PRIVATE void sqlite3DeleteIndexSamples(Index *pIdx){
65332 (void)sqlite3SafetyOff(db);
65334 (void)sqlite3SafetyOn(db);
65352 (void)sqlite3SafetyOff(db);
65354 (void)sqlite3SafetyOn(db);
65359 (void)sqlite3SafetyOff(db);
65409 (void)sqlite3SafetyOn(db);
65486 static void attachFunc(
65576 extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);
65577 extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
65597 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
65610 (void)sqlite3SafetyOn(db);
65614 (void)sqlite3SafetyOff(db);
65655 static void detachFunc(
65707 static void codeAttach(
65779 SQLITE_PRIVATE void sqlite3Detach(Parse *pParse, Expr *pDbname){
65800 SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
66032 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
66033 void *pArg
66047 static void sqliteAuthBadReturnCode(Parse *pParse){
66094 SQLITE_PRIVATE void sqlite3AuthRead(
66187 SQLITE_PRIVATE void sqlite3AuthContextPush(
66202 SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext *pContext){
66242 SQLITE_PRIVATE void sqlite3BeginParse(Parse *pParse, int explainFlag){
66269 SQLITE_PRIVATE void sqlite3TableLock(
66309 static void codeTableLocks(Parse *pParse){
66337 SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
66439 SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
66559 static void freeIndex(Index *p){
66576 static void sqlite3DeleteIndex(Index *p){
66592 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
66628 SQLITE_PRIVATE void sqlite3ResetInternalSchema(sqlite3 *db, int iDb){
66678 SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3 *db){
66685 static void sqliteResetColumnNames(Table *pTable){
66714 SQLITE_PRIVATE void sqlite3DeleteTable(Table *pTable){
66757 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
66800 SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *p, int iDb){
66925 SQLITE_PRIVATE void sqlite3StartTable(
67142 SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token *pName){
67191 SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
67268 SQLITE_PRIVATE void sqlite3AddColumnType(Parse *pParse, Token *pType){
67290 SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse *pParse, ExprSpan *pSpan){
67333 SQLITE_PRIVATE void sqlite3AddPrimaryKey(
67397 SQLITE_PRIVATE void sqlite3AddCheckConstraint(
67417 SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){
67502 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
67540 static void identPut(char *z, int *pIdx, char *zSignedIdent){
67652 SQLITE_PRIVATE void sqlite3EndTable(
67858 SQLITE_PRIVATE void sqlite3CreateView(
67944 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
68032 static void sqliteViewResetAll(sqlite3 *db, int idx){
68065 SQLITE_PRIVATE void sqlite3RootPageMoved(Db *pDb, int iFrom, int iTo){
68092 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
68120 static void destroyTable(Parse *pParse, Table *pTab){
68177 SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
68355 SQLITE_PRIVATE void sqlite3CreateForeignKey(
68444 pFKey->zTo, sqlite3Strlen30(pFKey->zTo), (void *)pFKey
68475 SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
68496 static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
68540 void * const pRegKey = SQLITE_INT_TO_PTR(regIdxKey);
69062 SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){
69083 SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
69166 SQLITE_PRIVATE void *sqlite3ArrayAllocate(
69168 void *pArray, /* Array of objects. Might be reallocated */
69177 void *pNew;
69228 SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
69387 SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
69405 SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
69482 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
69512 SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList *p){
69525 SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
69551 SQLITE_PRIVATE void sqlite3CommitTransaction(Parse *pParse){
69571 SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse *pParse){
69592 SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
69660 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
69699 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
69713 SQLITE_PRIVATE void sqlite3MultiWrite(Parse *pParse){
69734 SQLITE_PRIVATE void sqlite3MayAbort(Parse *pParse){
69744 SQLITE_PRIVATE void sqlite3HaltConstraint(Parse *pParse, int onError, char *p4, int p4type){
69776 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
69795 static void reindexDatabases(Parse *pParse, char const *zColl){
69826 SQLITE_PRIVATE void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
69940 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
70200 SQLITE_PRIVATE void sqlite3FuncDefInsert(
70313 ** Free all resources held by the schema structure. The void* argument points
70320 SQLITE_PRIVATE void sqlite3SchemaFree(void *p){
70449 SQLITE_PRIVATE void sqlite3MaterializeView(
70583 SQLITE_PRIVATE void sqlite3DeleteFrom(
70838 SQLITE_PRIVATE void sqlite3GenerateRowDelete(
70946 SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(
71038 static void minmaxFunc(
71068 static void typeofFunc(
71089 static void lengthFunc(
71129 static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
71179 static void substrFunc(
71265 static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
71296 static void *contextMalloc(sqlite3_context *context, i64 nByte){
71317 static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
71337 static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
71371 static void ifnullFunc(
71390 static void randomFunc(
71416 static void randomBlob(
71440 static void last_insert_rowid(
71454 static void changes(
71468 static void total_changes(
71667 static void likeFunc(
71720 static void nullifFunc(
71736 static void versionFunc(
71750 static void sourceidFunc(
71777 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
71842 static void hexFunc(
71870 static void zeroblobFunc(
71895 static void replaceFunc(
71979 static void trimFunc(
72071 static void soundexFunc(
72124 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
72166 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
72192 static void sumFinalize(sqlite3_context *context){
72205 static void avgFinalize(sqlite3_context *context){
72212 static void totalFinalize(sqlite3_context *context){
72231 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
72247 static void countFinalize(sqlite3_context *context){
72256 static void minmaxStep(
72276 ** sqlite3_user_data() function returns (void *)-1. For min() it
72277 ** returns (void *)db, where db is the sqlite3* database pointer.
72290 static void minMaxFinalize(sqlite3_context *context){
72304 static void groupConcatStep(
72337 static void groupConcatFinalize(sqlite3_context *context){
72357 SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3 *db){
72373 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
72387 SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
72445 SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void){
72846 static void fkLookupParent(
72989 static void fkScanChildren(
73125 static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){
73153 SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
73214 SQLITE_PRIVATE void sqlite3FkCheck(
73662 SQLITE_PRIVATE void sqlite3FkActions(
73690 SQLITE_PRIVATE void sqlite3FkDelete(Table *pTab){
73700 void *data = (void *)pFKey->pNextTo;
73745 SQLITE_PRIVATE void sqlite3OpenTable(
73824 SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){
73948 SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){
73989 static void autoIncStep(Parse *pParse, int memId, int regRowid){
74002 SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){
74156 SQLITE_PRIVATE void sqlite3Insert(
74862 SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
75133 SQLITE_PRIVATE void sqlite3CompleteInsertion(
75576 void *pArg, /* First argument to xCallback() */
75743 void * (*aggregate_context)(sqlite3_context*,int nBytes);
75745 int (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*));
75753 int (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*));
75754 int (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*));
75756 int (*busy_handler)(sqlite3*,int(*)(void*,int),void*);
75760 int (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const char*));
75761 int (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const void*));
75762 const void * (*column_blob)(sqlite3_stmt*,int iCol);
75767 const void * (*column_database_name16)(sqlite3_stmt*,int);
75769 const void * (*column_decltype16)(sqlite3_stmt*,int);
75774 const void * (*column_name16)(sqlite3_stmt*,int);
75776 const void * (*column_origin_name16)(sqlite3_stmt*,int);
75778 const void * (*column_table_name16)(sqlite3_stmt*,int);
75780 const void * (*column_text16)(sqlite3_stmt*,int iCol);
75783 void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
75785 int (*complete16)(const void*sql);
75786 int (*create_collation)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*));
75787 int (*create_collation16)(sqlite3*,const void*,int,void*,int(*)(void*,int,const void*,int,const void*));
75788 int (*create_function)(sqlite3*,const char*,int,int,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*));
75789 int (*create_function16)(sqlite3*,const void*,int,int,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*));
75790 int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
75797 const void * (*errmsg16)(sqlite3*);
75798 int (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**);
75801 void (*free)(void*);
75802 void (*free_table)(char**result);
75804 void * (*get_auxdata)(sqlite3_context*,int);
75806 int (*global_recover)(void);
75807 void (*interruptx)(sqlite3*);
75809 const char * (*libversion)(void);
75810 int (*libversion_number)(void);
75811 void *(*malloc)(int);
75814 int (*open16)(const void*,sqlite3**);
75816 int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
75817 void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
75818 void (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
75819 void *(*realloc)(void*,int);
75821 void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
75822 void (*result_double)(sqlite3_context*,double);
75823 void (*result_error)(sqlite3_context*,const char*,int);
75824 void (*result_error16)(sqlite3_context*,const void*,int);
75825 void (*result_int)(sqlite3_context*,int);
75826 void (*result_int64)(sqlite3_context*,sqlite_int64);
75827 void (*result_null)(sqlite3_context*);
75828 void (*result_text)(sqlite3_context*,const char*,int,void(*)(void*));
75829 void (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*));
75830 void (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*));
75831 void (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
75832 void (*result_value)(sqlite3_context*,sqlite3_value*);
75833 void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
75834 int (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,const char*,const char*),void*);
75835 void (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
75839 void (*thread_cleanup)(void);
75841 void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
75843 void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,sqlite_int64),void*);
75844 void * (*user_data)(sqlite3_context*);
75845 const void * (*value_blob)(sqlite3_value*);
75853 const void * (*value_text16)(sqlite3_value*);
75854 const void * (*value_text16be)(sqlite3_value*);
75855 const void * (*value_text16le)(sqlite3_value*);
75862 int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
75865 int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,void (*xDestroy)(void *));
75871 int (*blob_read)(sqlite3_blob*,void*,int,int);
75872 int (*blob_write)(sqlite3_blob*,const void*,int,int);
75873 int (*create_collation_v2)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*),void(*)(void*));
75874 int (*file_control)(sqlite3*,const char*,int,void*);
75876 sqlite3_int64 (*memory_used)(void);
75878 void (*mutex_enter)(sqlite3_mutex*);
75879 void (*mutex_free)(sqlite3_mutex*);
75880 void (*mutex_leave)(sqlite3_mutex*);
75884 void (*result_error_nomem)(sqlite3_context*);
75885 void (*result_error_toobig)(sqlite3_context*);
75887 void (*soft_heap_limit)(int);
75891 int (*xthreadsafe)(void);
75892 void (*result_zeroblob)(sqlite3_context*,int);
75893 void (*result_error_code)(sqlite3_context*,int);
75895 void (*randomness)(int,void*);
76419 void *handle;
76422 void **aHandle;
76514 SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3 *db){
76561 void (**aExt)(void); /* Pointers to the extension init functions */
76584 SQLITE_API int sqlite3_auto_extension(void (*xInit)(void)){
76604 void (**aNew)(void);
76623 SQLITE_API void sqlite3_reset_auto_extension(void){
76645 SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){
76824 static void returnSingleInt(Parse *pParse, const char *zLabel, i64 value){
76951 SQLITE_PRIVATE void sqlite3Pragma(
78077 extern void sqlite3_activate_see(const char*);
78083 extern void sqlite3_activate_cerod(const char*);
78138 static void corruptSchema(
78168 SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
78311 (void)sqlite3SafetyOff(db);
78313 (void)sqlite3SafetyOn(db);
78436 (void)sqlite3SafetyOff(db);
78439 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
78449 (void)sqlite3SafetyOn(db);
78562 static void schemaIsValid(Parse *pParse){
78698 (void)sqlite3SafetyOff(db);
78715 (void)sqlite3SafetyOff(db);
78914 const void *zSql, /* UTF-8 encoded SQL statement. */
78918 const void **pzTail /* OUT: End of parsed string */
78964 const void *zSql, /* UTF-8 encoded SQL statement. */
78967 const void **pzTail /* OUT: End of parsed string */
78976 const void *zSql, /* UTF-8 encoded SQL statement. */
78979 const void **pzTail /* OUT: End of parsed string */
79011 static void clearSelect(sqlite3 *db, Select *p){
79026 SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
79088 SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3 *db, Select *p){
79225 static void addWhereTerm(
79284 static void setJoinExpr(Expr *p, int iTable){
79401 static void pushOntoSorter(
79441 static void codeOffset(
79465 static void codeDistinct(
79513 static void selectInnerLoop(
79772 static void generateSortTail(
80013 static void generateColumnTypes(
80053 static void generateColumnNames(
80236 static void selectAddColumnTypeAndCollation(
80341 static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
81367 static void substExprList(sqlite3*, ExprList*, int, ExprList*);
81368 static void substSelect(sqlite3*, Select *, int, ExprList *);
81415 static void substExprList(
81427 static void substSelect(
82089 pTab->zName = sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pTab);
82289 static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
82345 static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){
82368 SQLITE_PRIVATE void sqlite3SelectPrep(
82391 static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
82423 static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
82431 (void*)pF->pFunc, P4_FUNCDEF);
82439 static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
82480 (void*)pF->pFunc, P4_FUNCDEF);
83195 SQLITE_PRIVATE void sqlite3PrintExpr(Expr *p){
83211 SQLITE_PRIVATE void sqlite3PrintExprList(ExprList *pList){
83220 SQLITE_PRIVATE void sqlite3PrintSelect(Select *p, int indent){
83318 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
83458 SQLITE_API void sqlite3_free_table(
83492 SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerStep){
83552 SQLITE_PRIVATE void sqlite3BeginTrigger(
83725 SQLITE_PRIVATE void sqlite3FinishTrigger(
83926 SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){
83944 SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){
83992 SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
84050 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
84242 static void transferParseError(Parse *pTo, Parse *pFrom){
84348 pProgram->token = (void *)pTrigger;
84401 SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(
84472 SQLITE_PRIVATE void sqlite3CodeRowTrigger(
84584 static void updateVirtualTable(
84625 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
84653 SQLITE_PRIVATE void sqlite3Update(
85160 static void updateVirtualTable(
85302 SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse){
85321 void (*saved_xTrace)(void*,const char*); /* Saved db->xTrace */
85377 extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
85380 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
85570 void *pAux, /* Context pointer for xCreate/xConnect */
85571 void (*xDestroy)(void *) /* Module destructor function */
85587 pDel = (Module *)sqlite3HashInsert(&db->aModule, zCopy, nName, (void*)pMod);
85612 void *pAux /* Context pointer for xCreate/xConnect */
85624 void *pAux, /* Context pointer for xCreate/xConnect */
85625 void (*xDestroy)(void *) /* Module destructor function */
85638 SQLITE_PRIVATE void sqlite3VtabLock(VTable *pVTab){
85659 SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){
85672 (void)sqlite3SafetyOff(db);
85674 (void)sqlite3SafetyOn(db);
85746 SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3 *db){
85777 SQLITE_PRIVATE void sqlite3VtabClear(Table *p){
85794 static void addModuleArgument(sqlite3 *db, Table *pTable, char *zArg){
85819 SQLITE_PRIVATE void sqlite3VtabBeginParse(
85863 static void addArgumentToVtab(Parse *pParse){
85876 SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
85958 SQLITE_PRIVATE void sqlite3VtabArgInit(Parse *pParse){
85968 SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse *pParse, Token *p){
85988 int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**),
86015 (void)sqlite3SafetyOff(db);
86017 (void)sqlite3SafetyOn(db);
86133 aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
86267 (void)sqlite3SafetyOn(db);
86289 static void callFinaliser(sqlite3 *db, int offset){
86428 void (*xFunc)(sqlite3_context*,int,sqlite3_value**) = 0;
86429 void *pArg = 0;
86485 SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
86757 static void whereClauseInit(
86771 static void whereClauseClear(WhereClause*);
86776 static void whereOrInfoDelete(sqlite3 *db, WhereOrInfo *p){
86784 static void whereAndInfoDelete(sqlite3 *db, WhereAndInfo *p){
86793 static void whereClauseClear(WhereClause *pWC){
86876 static void whereSplit(WhereClause *pWC, Expr *pExpr, int op){
86915 static void createMask(WhereMaskSet *pMaskSet, int iCursor){
87005 static void exprCommute(Parse *pParse, Expr *pExpr){
87103 static void exprAnalyze(SrcList*, WhereClause*, int);
87110 static void exprAnalyzeAll(
87263 static void transferJoinMarkings(Expr *pDerived, Expr *pBase){
87345 static void exprAnalyzeOrTerm(
87595 static void exprAnalyze(
88017 static void TRACE_IDX_INPUTS(sqlite3_index_info *p){
88035 static void TRACE_IDX_OUTPUTS(sqlite3_index_info *p){
88057 static void bestIndex(
88067 static void bestOrClauseIndex(
88267 (void)sqlite3SafetyOff(pParse->db);
88272 (void)sqlite3SafetyOn(pParse->db);
88313 static void bestVirtualIndex(
88714 static void bestBtreeIndex(
89038 static void bestIndex(
89084 static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
89110 static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
89955 static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){
90501 SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
90685 static void spanSet(ExprSpan *pOut, Token *pStart, Token *pEnd){
90694 static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token *pValue){
90703 static void spanBinaryExpr(
90717 static void spanUnaryPostfix(
90731 static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
90742 static void spanUnaryPrefix(
91514 SQLITE_PRIVATE void sqlite3ParserTrace(FILE *TraceFILE, char *zTracePrompt){
91935 static void yyGrowStack(yyParser *p){
91966 SQLITE_PRIVATE void *sqlite3ParserAlloc(void *(*mallocProc)(size_t)){
91988 static void yy_destructor(
92116 SQLITE_PRIVATE void sqlite3ParserFree(
92117 void *p, /* The parser to be deleted */
92118 void (*freeProc)(void*) /* Function used to reclaim memory */
92128 (*freeProc)((void*)pParser);
92135 SQLITE_PRIVATE int sqlite3ParserStackPeak(void *p){
92244 static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
92265 static void yy_shift(
92647 static void yy_accept(yyParser*); /* Forward Declaration */
92653 static void yy_reduce(
93811 static void yy_parse_failed(
93830 static void yy_syntax_error(
93848 static void yy_accept(
93882 SQLITE_PRIVATE void sqlite3Parser(
93883 void *yyp, /* The parser */
94697 void *pEngine; /* The LEMON-generated LALR(1) parser */
94713 pEngine = sqlite3ParserAlloc((void*(*)(size_t))sqlite3Malloc);
95096 SQLITE_API int sqlite3_complete16(const void *zSql){
95242 SQLITE_API const char *sqlite3_libversion(void){ return sqlite3_version; }
95243 SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
95244 SQLITE_API int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
95245 SQLITE_API int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
95254 SQLITE_PRIVATE void (*sqlite3IoTrace)(const char*, ...) = 0;
95297 SQLITE_API int sqlite3_initialize(void){
95430 SQLITE_API int sqlite3_shutdown(void){
95526 sqlite3GlobalConfig.pScratch = va_arg(ap, void*);
95533 sqlite3GlobalConfig.pPage = va_arg(ap, void*);
95556 sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
95609 static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
95610 void *pStart;
95678 void *pBuf = va_arg(ap, void*);
95710 void *padFlag,
95711 int nKey1, const void *pKey1,
95712 int nKey2, const void *pKey2
95740 void *NotUsed,
95741 int nKey1, const void *pKey1,
95742 int nKey2, const void *pKey2
95779 SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *db){
95919 SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db){
95999 void *ptr, /* Database connection */
96062 int (*xBusy)(void*,int),
96063 void *pArg
96079 SQLITE_API void sqlite3_progress_handler(
96082 int (*xProgress)(void*),
96083 void *pArg
96107 sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
96117 SQLITE_API void sqlite3_interrupt(sqlite3 *db){
96133 void *pUserData,
96134 void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
96135 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
96136 void (*xFinal)(sqlite3_context*)
96217 void *p,
96218 void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
96219 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
96220 void (*xFinal)(sqlite3_context*)
96233 const void *zFunctionName,
96236 void *p,
96237 void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
96238 void (*xStep)(sqlite3_context*,int,sqlite3_value**),
96239 void (*xFinal)(sqlite3_context*)
96293 SQLITE_API void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
96294 void *pOld;
96310 SQLITE_API void *sqlite3_profile(
96312 void (*xProfile)(void*,const char*,sqlite_uint64),
96313 void *pArg
96315 void *pOld;
96331 SQLITE_API void *sqlite3_commit_hook(
96333 int (*xCallback)(void*), /* Function to invoke on each commit */
96334 void *pArg /* Argument to the function */
96336 void *pOld;
96349 SQLITE_API void *sqlite3_update_hook(
96351 void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
96352 void *pArg /* Argument to the function */
96354 void *pRet;
96367 SQLITE_API void *sqlite3_rollback_hook(
96369 void (*xCallback)(void*), /* Callback function */
96370 void *pArg /* Argument to the function */
96372 void *pRet;
96500 SQLITE_API const void *sqlite3_errmsg16(sqlite3 *db){
96513 const void *z;
96515 return (void *)outOfMem;
96518 return (void *)misuse;
96522 z = (void *)outOfMem;
96574 void* pCtx,
96575 int(*xCompare)(void*,int,const void*,int,const void*),
96576 void(*xDel)(void*)
96836 createCollation(db, "RTRIM", SQLITE_UTF8, SQLITE_COLL_USER, (void*)1,
96981 const void *zFilename,
97021 void* pCtx,
97022 int(*xCompare)(void*,int,const void*,int,const void*)
97040 void* pCtx,
97041 int(*xCompare)(void*,int,const void*,int,const void*),
97042 void(*xDel)(void*)
97059 const void *zName,
97061 void* pCtx,
97062 int(*xCompare)(void*,int,const void*,int,const void*)
97085 void *pCollNeededArg,
97086 void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
97103 void *pCollNeededArg,
97104 void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
97121 SQLITE_API int sqlite3_global_recover(void){
97145 SQLITE_PRIVATE int sqlite3Corrupt(void){
97158 SQLITE_API void sqlite3_thread_cleanup(void){
97192 (void)sqlite3SafetyOn(db);
97251 (void)sqlite3SafetyOff(db);
97306 SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
97397 typedef void (*void_function)(void);
97587 static void checkListProperties(sqlite3 *db){
97613 static void removeFromBlockedList(sqlite3 *db){
97628 static void addToBlockedList(sqlite3 *db){
97643 static void enterMutex(void){
97651 static void leaveMutex(void){
97680 void (*xNotify)(void **, int),
97681 void *pArg
97727 SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *db, sqlite3 *pBlocker){
97755 SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db){
97756 void (*xUnlockNotify)(void **, int) = 0; /* Unlock-notify cb to invoke */
97759 void **aArg; /* Arguments to the unlock callback */
97760 void **aDyn = 0; /* Dynamically allocated space for aArg[] */
97761 void *aStatic[16]; /* Starter space for aArg[]. No malloc required */
97787 || (aDyn && nArg==(int)(sqlite3DbMallocSize(db, aDyn)/sizeof(void*)))
97790 void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2);
97792 memcpy(pNew, aArg, nArg*sizeof(void *));
97854 SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db){
98377 void *data; /* Data associated with this element */
98378 void *pKey; int nKey; /* Key associated with this element */
98399 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey);
98400 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
98401 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
98402 SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash*);
98403 SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem(const Fts3Hash *, const void *, int);
98494 #define UNUSED_PARAMETER(x) (void)(x)
98656 SQLITE_PRIVATE int sqlite3Fts3InitVtab(int, sqlite3*, void*, int, const char*const*,
98662 SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *);
98667 SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3Table *, Fts3SegReader *);
98670 int (*)(Fts3Table *, void *, char *, int, char *, int), void *
98694 SQLITE_PRIVATE void sqlite3Fts3Dequote(char *);
98707 SQLITE_PRIVATE void sqlite3Fts3Offsets(sqlite3_context*, Fts3Cursor*);
98708 SQLITE_PRIVATE void sqlite3Fts3Snippet(sqlite3_context*, Fts3Cursor*,
98711 SQLITE_PRIVATE void sqlite3Fts3Snippet2(sqlite3_context *, Fts3Cursor *, const char *,
98714 SQLITE_PRIVATE void sqlite3Fts3Matchinfo(sqlite3_context *, Fts3Cursor *);
98720 SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *);
98807 SQLITE_PRIVATE void sqlite3Fts3Dequote(char *z){
98831 static void fts3GetDeltaVarint(char **pp, sqlite3_int64 *pVal){
98837 static void fts3GetDeltaVarint2(char **pp, char *pEnd, sqlite3_int64 *pVal){
98999 void *pAux, /* Hash table containing tokenizers */
99128 void *pAux, /* Pointer to tokenizer hash table */
99138 void *pAux, /* Pointer to tokenizer hash table */
99392 static void fts3PutDeltaVarint(
99406 static void fts3PoslistCopy(char **pp, char **ppPoslist){
99433 static void fts3ColumnlistCopy(char **pp, char **ppPoslist){
99466 static void fts3ReadNextPos(
99500 static void fts3PoslistMerge(
99912 void *pContext, /* Pointer to TermSelect structure */
100072 fts3TermSelectCb, (void *)&tsc
100550 static void fts3SnippetFunc(
100587 static void fts3Snippet2Func(
100628 static void fts3OffsetsFunc(
100654 static void fts3OptimizeFunc(
100688 static void fts3MatchinfoFunc(
100714 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */
100715 void **ppArg /* Unused */
100719 void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
100798 static void hashDestroy(void *p){
100815 SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
100816 SQLITE_PRIVATE void sqlite3Fts3PorterTokenizerModule(sqlite3_tokenizer_module const**ppModule);
100817 SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule(sqlite3_tokenizer_module const**ppModule);
100849 if( sqlite3Fts3HashInsert(pHash, "simple", 7, (void *)pSimple)
100850 || sqlite3Fts3HashInsert(pHash, "porter", 7, (void *)pPorter)
100852 || (pIcu && sqlite3Fts3HashInsert(pHash, "icu", 4, (void *)pIcu))
100878 db, "fts3", &fts3Module, (void *)pHash, hashDestroy
101085 static void *fts3ReallocOrFree(void *pOrig, int nNew){
101086 void *pRet = sqlite3_realloc(pOrig, nNew);
101401 static void insertBinaryOperator(
101635 SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *p){
101673 memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
101686 static void exprToString(Fts3Expr *pExpr, char *zBuf){
101738 static void fts3ExprTest(
101860 static void *fts3HashMalloc(int n){
101861 void *p = sqlite3_malloc(n);
101867 static void fts3HashFree(void *p){
101881 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){
101896 SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash *pH){
101919 static int fts3StrHash(const void *pKey, int nKey){
101929 static int fts3StrCompare(const void *pKey1, int n1, const void *pKey2, int n2){
101937 static int fts3BinHash(const void *pKey, int nKey){
101945 static int fts3BinCompare(const void *pKey1, int n1, const void *pKey2, int n2){
101960 ** with types "const void*" and "int" and returns an "int".
101962 static int (*ftsHashFunction(int keyClass))(const void*,int){
101977 static int (*ftsCompareFunction(int keyClass))(const void*,int,const void*,int){
101988 static void fts3HashInsertElement(
102021 int (*xHash)(const void*,int); /* The hash function */
102044 const void *pKey, /* The key we are searching for */
102050 int (*xCompare)(const void*,int,const void*,int); /* comparison function */
102070 static void fts3RemoveElementByHash(
102106 const void *pKey,
102110 int (*xHash)(const void*,int); /* The hash function */
102125 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
102147 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(
102149 const void *pKey, /* The key */
102151 void *data /* The data */
102157 int (*xHash)(const void*,int); /* The hash function */
102167 void *old_data = elem->data;
102191 memcpy((void*)new_elem->pKey, pKey, nKey);
102193 new_elem->pKey = (void*)pKey;
102497 static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
102544 static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
102840 SQLITE_PRIVATE void sqlite3Fts3PorterTokenizerModule(
102902 static void scalarFunc(
102908 void *pPtr = 0;
102920 void *pOld;
102926 pPtr = *(void **)sqlite3_value_blob(argv[1]);
102927 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
102942 sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT);
103039 char const **aNew = (const char **)sqlite3_realloc((void *)aArg, nNew);
103042 sqlite3_free((void *)aArg);
103058 sqlite3_free((void *)aArg);
103095 static void testFunc(
103224 memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
103231 SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
103251 static void intTestFunc(
103309 void *p = (void *)pHash;
103315 void *pdb = (void *)db;
103561 SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(
104087 SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *p){
104361 static void fts3SegReaderFirstDocid(Fts3SegReader *pReader){
104379 static void fts3SegReaderNextDocid(
104420 SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3Table *p, Fts3SegReader *pReader){
104534 static int fts3CompareElemByTerm(const void *lhs, const void *rhs){
104754 static void fts3SegReaderSort(
105037 static void fts3NodeFree(SegmentNode *pTree){
105235 static void fts3SegWriterFree(SegmentWriter *pWriter){
105367 static void fts3ColumnFilter(
105407 void *pContext, /* Pointer to SegmentWriter* to write with */
105423 void *pContext, /* Pointer to SegmentWriter* to write with */
105463 int (*xFunc)(Fts3Table *, void *, char *, int, char *, int), /* Callback */
105464 void *pContext /* Callback context (2nd argument) */
105702 &filter, fts3MergeCallback, (void *)&pWriter
105755 void *c = (void *)&pWriter; /* SegReaderIterate() callback context */
105966 static void fts3SnippetSbInit(StringBuffer *p){
105975 static void fts3SnippetAppend(StringBuffer *p, const char *zNew, int nNew){
106000 static void fts3SnippetAppendWhiteSpace(StringBuffer *p){
106007 static void fts3SnippetTrimWhiteSpace(StringBuffer *p){
106020 static void fts3SnippetFree(Snippet *p){
106396 static void snippetOffsetText(Snippet *p){
106478 static void snippetText(
106589 SQLITE_PRIVATE void sqlite3Fts3Offsets(
106608 SQLITE_PRIVATE void sqlite3Fts3Snippet(
106638 static void fts3GetDeltaPosition(char **pp, int *piPos){
106656 int (*x)(Fts3Expr *, void *), /* Callback function to invoke for phrases */
106657 void *pCtx /* Second argument to pass to callback */
106681 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, void *ctx){
106700 rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx);
106764 static int fts3SnippetFindPositions(Fts3Expr *pExpr, void *ctx){
106781 static void fts3SnippetCnt(
106876 (void)fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void *)&sCtx);
107088 static void fts3LoadColumnlistCounts(char **pp, u32 *aOut){
107108 void *pCtx /* Pointer to MatchInfo structure */
107131 void *pCtx /* Pointer to MatchInfo structure */
107179 (void)fts3ExprIterate(pCsr->pExpr, fts3ExprGlobalMatchinfoCb, (void *)&g);
107191 (void)fts3ExprIterate(pCsr->pExpr, fts3ExprLocalMatchinfoCb, (void *)&g);
107198 SQLITE_PRIVATE void sqlite3Fts3Snippet2(
107230 SQLITE_PRIVATE void sqlite3Fts3Matchinfo(sqlite3_context *pContext, Fts3Cursor *pCsr){
107480 static void readCoord(u8 *p, RtreeCoord *pCoord){
107538 static void nodeReference(RtreeNode *p){
107547 static void nodeZero(Rtree *pRtree, RtreeNode *p){
107579 static void nodeHashInsert(Rtree *pRtree, RtreeNode *pNode){
107592 static void nodeHashDelete(Rtree *pRtree, RtreeNode *pNode){
107688 static void nodeOverwriteCell(
107706 static void nodeDeleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell){
107813 static void nodeGetCoord(
107827 static void nodeGetCell(
107845 sqlite3 *, void *, int, const char *const*, sqlite3_vtab **, char **, int
107853 void *pAux,
107866 void *pAux,
107877 static void rtreeReference(Rtree *pRtree){
107885 static void rtreeRelease(Rtree *pRtree){
108454 static void cellUnion(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
108642 static void AdjustTree(
108708 static void LinearPickSeeds(
108802 static void QuadraticPickSeeds(
108852 static void SortByDistance(
108918 static void SortByDimension(
109339 static void fixBoundingBox(Rtree *pRtree, RtreeNode *pNode){
109899 void *pAux, /* One of the RTREE_COORD_* constants */
110013 static void rtreenode(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){
110051 static void rtreedepth(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){
110079 void *c = (void *)RTREE_COORD_REAL32;
110083 void *c = (void *)RTREE_COORD_INT32;
110160 static void xFree(void *p){
110260 static void icuLikeFunc(
110306 static void icuFunctionError(
110321 static void icuRegexpDelete(void *p){
110345 static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){
110426 static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){
110470 static void icuCollationDel(void *pCtx){
110480 void *pCtx,
110482 const void *zLeft,
110484 const void *zRight
110511 static void icuLoadCollation(
110538 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
110555 void *pContext; /* sqlite3_user_data() context */
110556 void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
110562 {"upper", 1, SQLITE_UTF16, (void*)1, icuCaseFunc16},
110563 {"upper", 2, SQLITE_UTF16, (void*)1, icuCaseFunc16},
110567 {"upper", 1, SQLITE_UTF8, (void*)1, icuCaseFunc16},
110568 {"upper", 2, SQLITE_UTF8, (void*)1, icuCaseFunc16},
110573 {"icu_load_collation", 2, SQLITE_UTF8, (void*)db, icuLoadCollation},
110851 SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule(